meta-theory · v3.0.0 · 2026-11-15 · sha256 3ae4f215527881aa

meta-theory v3.0.0A

Immutable. This exact content never changes and is served at /api/v1/blob/3ae4f215527881aa.

No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_m3tvirs32vstjpsu/3ae4f215527881aa39e62f9b56b32fc7c30986373d3a807339609757256a3d82.json

Then /plugin install meta-theory@markdownregistry-m3tvirs32vstjpsu in Claude Code. It installs this exact version, the one graded A here, pinned to the commit it was graded at, and leaves it there.

---
name: meta-theory
version: 3.0.0
author: KimYx0207
user-invocable: true
trigger: "元理论|执行元理论|跑元理论|meta theory|run meta theory|execute meta theory|meta-theory|agent governance|intent amplification|governance|治理|重构|多文件|跨模块|debug|fix|验证|verification"
tools:
  - shell
  - filesystem
  - browser
  - memory
description: |
  Meta_Kim executable governance dispatcher. It classifies the run, loads only needed references, preserves foundational capabilities and runtime-native abilities, routes owner + weapon + dependency + runtime + OS + verification, and closes only with evidence, intent acceptance, and writeback decision.
---
# Meta-Theory Dispatcher
## Purpose
Run Meta_Kim as an executable governance system, not a theory essay. The main thread locks intent, gathers evidence, chooses route, delegates bounded work, reviews, verifies, and synthesizes. It must not become a generic implementation worker for non-trivial work. Machine contract: `config/contracts/core-loop-contract.json` is the compact default-path contract for this skill. It binds ordinary durable work and explicit meta-theory shortcuts to `npm run meta:theory:run`, requires the eight-stage spine, and defines which gates block, warn, or stay progressive.
The default governed runner remains planned-only. When the maintainer explicitly supplies `--execute-stage-dag`, the P-117 bridge executes the existing `coreLoop.stageDagPacket` in read-only shadow mode through either `--stage-runner-runtime codex` or `--stage-runner-runtime claude`, with the P-118 kernel retaining durable node commits; `--resume-stage-dag` continues only the exact bound unfinished run. The ready-set executor defaults to native concurrency. `--stage-runner-orchestrator langgraph` may dynamically load an explicitly installed, currently tested `@langchain/langgraph@1.4.8` and use only its Functional API `entrypoint` plus `task`; it consumes the scheduler-selected ready set and may not define topology or persistence. Both runtimes keep the same graph, checkpoint, and local merge authority. A native terminal result proves invocation, while Review still owns semantic acceptance. Do not claim write execution, external effects, a runtime-specific graph, LangGraph checkpoint authority, or live OpenAI/Claude SDK adapters without credential-backed evidence. The process timeout is a safety fuse, never a task/token/cost budget.

## Active host and shared skills

Shared `.agents/skills` bundles are host-neutral. Identify the active host before loading `references/runtime-codex.md`, `references/runtime-claude.md`, `references/runtime-gemini.md`, `references/runtime-zcode.md` or `references/runtime-dsh.md`; use the existing Cursor/OpenClaw guidance for those clients. Canonical agent paths identify responsibility sources. Native agent paths, callable tools, Hook schemas and authority come from that runtime's actual reference and inventory. Never run another host's tool/schema examples verbatim. A generated projection is separate from native invocation evidence. DSH loads the canonical roles as native Skills and inherits the current host preset for actual delegation; a Skill name is not a registered custom-agent preset. Read all method parts and relevant resources before execution, and keep file loading, MCP observations, native delegation and final outcome evidence distinct.

For substantial software delivery, load [intent to delivery](references/intent-to-delivery.md): architecture exploration precedes the detailed module view of the same PRD; actual professional knowledge travels with selected methods; source navigation supports evidence-based cleanup. Reuse current decisions and continue the returned host action until a material user choice or real blocker requires a pause. Do not ask the user to select internal roles or manufacture a second plan.

## Global-First Owner Discovery

Discovery is **capability-first**: inspect shared foundations and the actual project before selecting a professional owner. Start with first-party capability search (`meta:capability:search`) over the existing indexes, then inspect relevant local canonical assets, global runtime homes, package scripts and MCP / runtime configs or use `meta-scout` investigation as the current gap requires. Follow the cached-inventory, project-light, stop-on-match policy in `config/contracts/core-loop-contract.json`; use `findskill` only when installed and appropriate, without requiring a full scan or external call by default. An existing suitable project owner is reused. Shared global methods support investigation and capability preparation; persistent professional project delivery creates or updates an independent project owner with substantive project rules. Full source-by-source guidance lives in `references/global-owner-discovery.md`; it must not override the machine contract's stage order, full-scan triggers, or stage-internal parallel policy.

The dispatcher (main thread or `meta-conductor`) is the **single merge owner** of `dispatchEnvelopePacket.capabilityInventory`. Fetch may discover independent sources concurrently after Critical has closed its intent merge, but the inventory is merged once before Thinking closes the route. This is a main-flow step, not a hook. The inventory records which relevant sources were actually scanned, which owners were considered, why one was selected, and why any route-relevant source was skipped. Discovery without a recorded inventory is fake discovery and is rejected by Review on the same chain, not by a separate gate.

## Trigger
Activate from ordinary natural-language durable work, not only from command words. If the user asks to plan and start work, organize priorities, produce repair suggestions, build a verification checklist, fix a non-trivial issue, handle multi-file execution, run review/verification, or resolve subjective/taste-dependent quality, classify the entry and choose the governed route automatically. Explicit `/meta-theory`, `meta-theory`, or `元理论` mentions are maintainer shortcuts, not required human behavior.

At run start, show a concise human-readable reason for the route. If the 8-stage spine triggers, say briefly why governance is needed before execution. If the 11-phase business workflow triggers, say briefly why closure, feedback, evolution, or mirror tracking is needed. Keep this to short user-facing lines; do not dump packet names or internal reasoning.

## Path classification
- `fast_path`: read-only query, no mutation, no durable artifact. Output may be direct, but evidence claims still need source.
- `standard_path`: ordinary executable work. Preserve the 8-stage order and capability-first truth boundary, but use fitness-informed depth: concise inline Critical / Fetch / Thinking for clear low-risk work, conditional Review, required fresh Verification, and no dedicated Evolution dispatch without a durable trigger.
- `regulated_path`: governance, security, runtime, dependency, release, public-ready, or cross-platform work. Require full spine, Review, Meta-Review, Verification, and Evolution.

## Canonical spine
Critical -> Fetch -> Thinking -> Execution -> Review -> Meta-Review -> Verification -> Evolution.

The current host AI produces Critical, Fetch and Thinking; the Node runner does not call another model or infer those stages from route keywords. For ordinary durable work, use the existing `meta:theory:run` entry as a staged exchange. Read its pending artifact first. Produce `criticalInput` from the actual request, applicable context and settled answers, using the existing intent-packet fields; place only unresolved material questions and concrete options in `requirementsDiscoveryInput.decisionItems`. Ask through the current native host surface only when an answer changes direction, scope, cost, risk or acceptance. Investigate discoverable facts yourself and decide routine reversible details. Never require the user to write these records or repeat an already settled choice.

Before Critical, read the ordinary entry's `projectContextPacket`: existing projects need bounded inspection of actual manifests, declared versions, runnable script entries, module languages and tracked/untracked WIP. Confirm route-changing facts against the referenced source bytes; a scan or digest does not prove host understanding. Critical evidence references must identify the project material actually read. Empty/new projects proceed directly to Critical; uncertain or bounded scans retain their limitations. This is context preparation, never a ninth stage. Nontechnical users describe outcomes; Thinking chooses or reuses suitable language/framework engineers from discovered capabilities. For a new project, propose a language only after comparing viable routes; ask with a recommendation and practical tradeoffs when cost, portability, maintenance or product direction materially differs.

Use `requirementsDiscoveryInput.research` for evidence that can change a current design choice, or for research the user explicitly requests. Start with existing evidence; select official documentation, actual user flows, relevant implementation source, transferable cases or primary research for the question. Record the mechanism, conditions, decision impact, findings, limits, observation time and applicable revision; evidence may justify keeping the existing design. Repository counts, popularity and mandatory search channels are not general sufficiency rules. Preserve explicit task-specific source/count requirements and report inaccessible, contradictory or insufficient evidence as concrete unknowns. A clear reversible change needs no research ceremony; one unknown needs only its own probe. Critical retains user decisions, Fetch resolves decision-changing facts, and Thinking compares designs; only dependency-ready material questions reach users. Keep one PRD/task authority and immutable supporting records. Give workers only related evidence and stable readable references, verifying and rereading selected records before dispatch. See [project analysis, research and PRD](references/project-research-prd.md).

`needs_input` has no formal worker packets or execution DAG. Consume the actual native answer through the current host Decision/CAS port, retain the old question/options/material binding and follow the returned intent-evolution link; do not replace it with a recommended answer or a local trusted flag. `needs_thinking` with Critical still pending asks this host to finish understanding, not to execute. Once Critical is clear, the entry returns only the actual Fetch inventory. Read its relevant sources/contracts, compare feasible approaches, resolve any new material choice through the same question history, and then submit `thinkingInput` with the existing Critical/Fetch/Thinking and worker-work-order fields, including exact selected inventory objects, selection reasons, scope/non-goals, tool needs, criterion ownership and verification owner. Only then may Node verify the bindings and form formal workers/DAG; source hashes and permission/runtime/budget gates remain independent. Missing host reasoning yields candidates and a current host action, never invented C/F/T completion. Resume preparation through `previousPlanChallengeRunId`; do not overwrite a completed or running execution run. See the bounded API/CLI and actual-host sequence in `references/runtime-codex.md`.

You are the DISPATCHER, not the executor. Use the active host's native delegation tool and observed schema for dispatch only after Fetch evidence and Thinking owner resolution prove the route.

Fetch-first capability matching principle: Fetch gathers evidence, then Thinking performs capability match, never hardcoded agent-name matching. Gate 1: Clarity Check blocks unclear intent before Fetch. Gate 2: Dispatch-Not-Execute blocks self-execution and requires a named owner, weapon, and verification owner.

Decision information is responsibility-scoped. Fetch is not the only stage that creates user choice material. Critical decides which intent dimensions matter, Fetch decides which evidence changes routes, Thinking decides owner / weapon / dependency / runtime / lane options, Execution records route-changing discoveries, Review decides quality and revision trade-offs, Meta-Review decides claim standard, Verification decides truth state, and Evolution decides writeback or none-with-reason. The 11-phase business workflow, meta workflow phases, business lanes, capability route, owner/weapon/dependency choice, runtime/OS support, tool/provider selection, verification path, evolution writeback, and user interaction surface are also decision boundaries. Each boundary must collect information that matches its responsibility and explain how that information changes the user's choices; do not collapse all decision evidence into Fetch or Thinking.

## Architecture Type Pre-judgment

Important: Architecture Type Distinction. Meta Architecture means agent governance, collaboration relationships, and responsibility boundaries. Project Technical Architecture means code organization, tech stack, and design patterns; redirect that lane to an architect or backend-architect capability when the needed owner is technical implementation rather than Meta_Kim governance.

## General Agent Outcome Binding

Meta_Kim governs goals across domains: decisions, research, operations, learning, writing, engineering, and combinations discovered from the request. Industry packages supply capabilities; they do not define the framework's scope. Bind the actual user request to a run-scoped goal before choosing a route. Framework roadmap IDs, schema checks and runtime installation checks are not the user's success criteria.

**Cross-Agent thinking methods:** Any professional Agent may use the same transferable ways to clarify a problem, challenge assumptions, reverse-plan a goal, compare expertise or tradeoffs, probe opportunity, practice and receive feedback, design a repeatable routine, extract knowledge or focus strategy. At Critical/Fetch identify the *specific* uncertainty or feedback need; use capability-first discovery to find Kim_Service's optional `agent-thinking-patterns` Skill (or an already qualified equivalent), then bind only the needed thinking pattern as a method/loadout of the existing professional owner in Thinking. Do not route every learning/practice request to an education Agent, force all patterns on each task, require a new user decision for an internal method choice, or substitute the Skill for the professional Agent. If no provider is installed or actually loaded, say so rather than claim its invocation. Read [cross-Agent thinking patterns](references/cross-agent-thinking-patterns.md) when the choice of method could materially change the task result.

Choose the best evidenced feasible route under the user's constraints, compare meaningful alternatives, and record uncertainty; never promise a globally optimal answer or universal proven capability. Reuse capability discovery and the existing stage DAG for execution. Validate structure, routing/boundaries and actual task outcomes separately. The default runner's `traceEvalControlPlane.outcomeEvaluation` remains incomplete until task-bound criterion observations exist. Read `references/outcome-evaluation.md` for the source-backed evaluation method and material/pacing boundaries.

## Type-First Route Invariant

Before adding another checklist, hook rule, or validator gate, classify the route-critical type. The minimum axes are object type, evidence type, and ownership type. Unknown object type returns `null`, `capabilityGapPacket`, or `reference_only`; unknown evidence type must not be promoted from structural/validator pass into runtime truth; unknown ownership preserves or blocks instead of overwriting user-owned local state. This is a route-selection invariant for Fetch and Thinking, not a new stage or acceptance matrix.

## Dynamic Flow Selection

- Type A: prompt/reference/contract hardening.
- Type B: agent/skill/owner creation or upgrade.
- Type C: external capability, tool, MCP, dependency, or web evidence discovery.
- Type D: review, verification, rollback, public-ready, or warning closure.
- Type E: orchestration, planning files, business-flow, and cross-runtime release.

## Task progress visible to the user

At the start of governed work, use the exact current project/run Live link supplied by the local launch path. If the active host exposes a supported browser panel, open that link once in this conversation and reuse its existing tab. Subsequent task events update that view; do not create tabs or take focus on every event. Preserve an explicit current-run selection while its first observation is pending, rather than replacing it with a historical run. A generated link, Hook context, queued open request, or healthy server does not prove that the user can see the panel.

The task board and conversation progress must describe the same existing task/DAG/event records. Show concrete work, owner, dependencies, current action, available output, failure and next step. A worker return, process exit, acceptance and release are separate facts. Announce actual state changes in short localized messages; deduplicate repeated observations and reconnects. If no browser panel is exposed, use the host conversation or CLI stderr while keeping structured stdout intact. Do not replace a user's status-line configuration, open an external browser automatically, or introduce another task/status authority.

Host capability discovery comes first: a browser feature documented for a desktop host does not prove that its CLI, remote session or current tool inventory supports it. Use runtime adapter guidance for tool names and report unsupported, pending or unverified states honestly.

## Complexity Fan-out Trigger

Do not wait for the user to spell out agent names before recognizing complexity. Treat the run as fan-out eligible when any of these signals appear:

- explicit `/meta-theory`, `meta-theory`, `元理论`, natural-language governed work, `critical and fetch thinking and review`, `Critical Thinking -> Fetch -> Deep Thinking -> Review`, "并行", "多个 agent", "review + fix + verify", or equivalent wording
- 2+ independent files, runtimes, platforms, capability families, PR/issue lanes, research angles, product lanes, or verification lanes
- cross-runtime behavior, release/update/sync, hook/security/sandbox, PRD/contract/validator, or repeated same-type failure work
- user feedback that the current Meta_Kim route is slow, serial, missing agents, missing dynamic workflow, or repeatedly corrected

Fan-out eligibility is only an entry hint; `coreLoop.stageDagPacket` is the runtime authority for whether lanes are dependency-ready, resource-safe, permission-safe, and worth dispatching concurrently. Live host-agent dispatch also requires runtime authorization and a callable host surface. In every active stage, dispatch the maximal safe ready set up to active host capacity using that runtime adapter's native concurrency primitive. Do not silently serialize ready independent lanes, but do not require one universal batching shape across hosts: concurrency must be proved by the host's batched-call evidence or overlapping invocation intervals. For Codex, entering meta-theory / governed Meta_Kim execution is itself fan-out authorization when the stage DAG proves separable safe lanes; direct subagent/delegation/parallel-agent wording and structured governance-chain requests such as `Critical Thinking -> Fetch -> Deep Thinking -> Review` are examples of that authorization, not exclusive gates. Native choice is required for branch-changing route, scope, risk, or acceptance decisions, not as the mechanism that first permits safe parallelism. Direct user corrections such as "我要的是派发 / 并行 / 多 agent" are governed execution entries and direct fan-out authorization. If the host tool is unavailable, rejected, or unauthorized, record `subagentCapabilityStatus`, `degradationReason`, and `hostInvocationRequestPacket`; do not claim live fan-out, completion, or public-ready.
Visible owner binding rule: before any live host worker/subagent call, each lane must bind `ownerAgent`, `ownerSource`, `ownerBindingMode`, capability/loadout, `roleDisplayName`, `roleInstanceId`, `parallelGroup`, `mergeOwner`, and the runtime-specific invocation plan. Codex uses `ownerBindingMode=native_custom_agent` only when the active native `spawn_agent` schema exposes `agent_type` and the selected owner is a validated Codex TOML custom-agent definition; that request carries `nativeAgentType`, and only its successful result may be presented as invoked/completed. Otherwise Codex uses `ownerBindingMode=run_scoped_owner_contract`, keeps `nativeAgentType` null/absent, and carries the professional owner in the bounded message. A Markdown owner is never promoted to a Codex native custom agent merely because its name matches. Claude Code keeps its own native Agent/Task binding. The user-visible dispatch notice must show the professional owner separately from any `runtimeInstanceAlias`, and the same compact ledger must retain Agent, Skill, Command, MCP, runtime-tool, and Hook selected-versus-actual state plus next action. It must not say only "created N agents", "派 agent", or equivalent wording with no owner/capability binding. If no reusable owner or capability binding can be found, block or return to Thinking with `capabilityGapPacket` instead of spawning unnamed side agents.
## Stage map

| # | Stage | Action | Interaction |
|---|---|---|---|
| 1 | Critical | clarify intent first, lock user pain, value, success criteria, non-goals, permissions, and Architecture Type; for wishful or ambiguous input, enter Critical-Fetch intent loop: translate intent -> read context -> enrich intent -> present IntentCard for user confirmation (up to `criticalFetchLoopMax` rounds) | If a required intent dimension is missing and the answer changes route, scope, risk, or non-goal, set `choiceSurfaceState = critical_clarification_allowed` and ask before proceeding. Do not present execution options during Critical. Present an IntentCard after context-enriched intent translation; an unresolved material understanding needs the native interactive choice surface on Codex/Claude Code, while compatibility runtimes may use a labeled fallback. Preserve settled understanding and existing authorization without repeated confirmation. |
| 2 | Fetch | gather online/web and local evidence, confirm the problem, list candidate solutions with sources, extract material claims, run targeted read-only baseline verification when it changes the route, discover retrieval capabilities, complete a multi-type capability inventory before Thinking, read every target file that may be changed, and build a change fact card before any file mutation | If evidence suggests multiple valid paths with different trade-offs, surface the options in the user's language before Thinking. If current external facts or third-party capability claims matter, `meta-scout` or an equivalent evidence owner must finish source-backed research before Thinking. |
| 3 | Thinking | determine needed execution capabilities across governance agents, execution agents, skills, scripts, commands, MCP capabilities/providers/tools, runtime tools, plugins/connectors, retrieval capabilities, dependency/external packages, and run-scoped workerTasks; match existing capabilities; create or upgrade only for gaps; bind the file delivery contract and carry confirmed output format, protected/forbidden changes and acceptance criteria into each actual native worker prompt: an internal packet alone is not a handoff, and generic Skill defaults never override explicit user requirements; plan DAG/parallel/serial lanes with `mergeOwner` | Compare evidence-backed viable directions when a material choice remains, with cost, time, quality and extension trade-offs where relevant. Use the native choice surface for that unresolved choice; reuse an already settled direction and existing authorization without reconfirming routine implementation details. Never invent a second path to fill a quota. |
| 4 | Execution | run multi-agent work using the agents, skills, scripts, commands, MCP capabilities, runtime tools, plugins/connectors, retrieval capabilities, dependencies, and tools selected by Thinking artifacts | No interaction unless route-changing discovery occurs mid-execution — then pause and inform. |
| 5 | Review | meta-prism checks upstream Critical, Fetch, Thinking, and result quality | If review finds issues that require user preference (quality vs speed trade-off), ask before proceeding. |
| 6 | Meta-Review | meta-warden verifies Review standard and public-ready gate | No interaction. Internal governance check. |
| 7 | Verification | run real tests with fresh evidence and `verificationPacket.fixEvidence` | No interaction. Run checks and record evidence. |
| 8 | Evolution | after Warden approval, directly edit the target agent definition or SOUL.md for meta-agent lessons; execution-agent gaps use `capabilityGapPacket` + Type B pipeline | No interaction. Record writeback decision. |

Autonomous discovery rule: for natural-language durable work, Fetch starts capability discovery from the entry classification itself. The user must not need to say "Critical", "Fetch", "Thinking", "Review", agent, skill, MCP, command, or tool for Meta_Kim to search local/global agents, skills, commands, MCP providers, runtime tools, plugins, hooks, and verification owners. Native choice gates may pause branch-changing execution, but they must not be the mechanism that first reveals missing discovery.

### Parallelism Boundaries

The 8-stage spine is the canonical order within each scope and every transition is a merge barrier: no next-stage lane in a scope starts before that scope's active stage merge node closes. Without an explicit `moduleScopePlan`, retain the existing global stage graph and barriers. Explicit independent module scopes may overlap stages, subject to shared architecture, declared task/interface dependencies, current decisions, resource locks and permissions; final completion still requires every required module and an observed integration Verification receipt. Inside each stage, independent support, execution, review, verification, or candidate-analysis lanes use maximal safe parallelism under DAG dependencies, resource locks, permissions, isolation, useful-work, and host-capacity limits. Within each scope, Critical keeps one intent authority; Thinking keeps one route/DAG authority; Execution keeps one merge owner; Review keeps one findings verdict; Meta-Review keeps one Warden verdict; Verification keeps one evidence/claim authority; Evolution keeps one candidate merge and one approved durable writer. The machine authority is `config/contracts/core-loop-contract.json`; `references/dev-governance.md` explains it without introducing Stage 0, fixed waves, or competing strict-serial stage rules.

When the host supplies company-owned Work context, follow `references/dev-governance.md#optional-company-work-context`: carry the provided `workContext` through the ordinary runner, check its sources/version within authorized Fetch, preserve the same binding in workers, and summarize produced/verified/adopted/effect separately. Without this optional input, keep the existing flow; do not invent a Work, expand access, repeat an applicable prior approval or publish organization knowledge automatically.

For runtime/model selection, follow `references/dev-governance.md#client-model-and-provider-selection`: use explicit configuration or current host evidence, keep method/client/provider separate, pass an explicitly configured model through a declared adapter parameter, and distinguish requested, applied and observed. A profile is not native execution proof; unsupported explicit choices must not silently change clients or models.

## User Interaction

**MANDATORY**: Use the current runtime adapter's verified native choice surface at key decision points. Keep the canonical card contract platform-neutral; renderer-specific schemas and tool names belong in runtime references such as `runtime-claude.md` or `runtime-codex.md`, not in the generic contract. For Codex and Claude Code, required branch-changing decisions must use `request_user_input` or `AskUserQuestion`; if that native interactive surface is unavailable, empty, rejected, stripped, or not deferred to host UI, block before Execution and return to Critical/Thinking. Only compatibility runtimes may fall back to a localized chat decision card, and that fallback must not be reported as a Codex or Claude Code popup.

False native choice claim guard: do not write that a popup, panel, or native surface was shown, used, returned empty, timed out, failed, or selected an option unless the current runtime adapter has returned matching evidence. In Codex, that means a `request_user_input` answer or `nativeChoiceSurfaceBlocked`; in Claude Code, that means an `AskUserQuestion` answer, deferred `AskUserQuestion` evidence, or `nativeChoiceSurfaceBlocked`. Cursor, OpenClaw, and other compatibility runtimes may report a fallback only as fallback. If the tool is unavailable, say blocked or pending, not "the choice panel did not return". Use the risk-adaptive plan-challenge overlay for explicit `反证` / `帮我挑刺` / `压力测试` intent or evidence-backed actionable irreversible, high-cost, permission-sensitive, or materially contradictory work. It stays inside Critical -> Fetch -> Thinking -> Review: Fetch facts, collect only dependency-ready material user decisions in impact order within the active host capability, remain pending without trusted user evidence, continue from a validator-passing same-task prior run instead of restarting the questions, support continue/recommend/skip/summary/stop, keep understanding separate from the single scoped `executionAllowed` side-effect gate, suppress ritual questions, and close in chat. Full interaction, state, trust, locale, and rhythm contracts live in `references/dev-governance.md`, `references/spine-state.md`, and `references/rhythm-orchestration.md`.

### Choice Dialog Style

Use the existing seven intent dimensions and `preDecisionOptionFrame.unresolvedQuestions` history as one dialogue authority. Read discoverable facts before asking; replay a concrete user scenario or example/counterexample when it helps distinguish outcomes. Start with the highest-impact unresolved question that changes execution; independent questions whose prerequisites are settled may share one round within the native form's capacity. Recompute that frontier after the answers, and defer dependent questions. If direction is uncertain and a cheap sample can resolve it, agree its scope and inspect the sample before scaling. Carry settled decisions and their evidence into the goal, blueprint, capability bindings and worker work orders. Reopen them only for new material evidence. Read `references/intent-amplification.md` for the internalized dialogue method and dependency boundaries.

### Requirements conversation before product design

For an uncertain product or multi-deliverable request, the normal path is **requirements exploration -> complete design -> deliverable tasks -> execution and independent acceptance**. Requirements exploration is an active conversation, not a missing-field check and not a questionnaire generated after a finished design. It can start without `designInput`. The dispatcher first reads the existing product and materials, explains useful improvements and their trade-offs, offers evidence-backed recommendations, and lets the user choose material product directions. Answers change which proposals and questions are useful next. Keep decision dependencies and existing answers in the current plan-challenge history; do not create another interview ledger. Facts are investigated by the agent, routine reversible implementation choices are handled autonomously, and already settled user choices are reused.

Separate product alternatives from execution routes: compare how the same user achieves the same goal through genuinely different feasible mechanisms before selecting models, tools or agents. Do not invent a fixed number of alternatives or expand explicit requests into a larger product. Keep requirements/prohibitions, settled choices, decision-changing assumptions and assistant preferences distinct. Use the discovered professional design method to compare value, total state/credential/maintenance burden, failure conditions and what would reverse the recommendation; a single feasible route explains its constraints. Use lightweight flow sketches or input/output examples before full specifications. Choose thinking methods for the unknown they can resolve, not a mandatory roster of lenses.

Once the current delivery's relevant choices are settled, invoke the discovered design capability in Thinking with the complete applicable method. Walk the whole user path through entry, action, feedback, result, failure and continuation before fixing production modules. Probe critical capabilities and high-risk interfaces early. Then divide by independently demonstrable outcomes, shared state ownership, interfaces and real dependencies; first deliver a usable whole path. Synthesize these into the existing authoritative PRD at task-appropriate depth, rather than concatenating module reports. Design changes update affected decisions and descendants; same-design recovery retains current bindings and prior answers.

Execution depth follows evidenced design uncertainty, implementation coupling, operational consequences/reversibility and verification conditions for each task. File count, worker count, lexical complexity and an uncalibrated total score cannot establish those facts. Unknown safety remains unknown; lightweight work never grants permission. A fixed local change can reuse its accepted design, one key unknown can receive a focused probe, and a changed journey/shared contract receives relevant whole-design work. Actual dispatch and recovery must consume this choice. Each worker receives its relevant complete scenario, selected mechanism/reason, shared concepts/state/interface constraints and readable current upstream artifacts; previews must mark truncation and cannot replace required content. Missing, stale or inaccessible sources return a precise gap, never a silent fallback.

Thinking records the delivery's evidenced `lifecycle` (`first_delivery`, `material_revision`, `within_accepted_scope` or `unknown`) and each existing `artifactFlow[].artifactKind`; use the seven human milestones in `workflow-contract.json`, never a task-title keyword or `revision=1` as lifecycle proof. Direction/system-plan and PRD flows need an actual selected read-only review producer before implementation consumes their current files. A support-only report with no implementation or artifact flow does not acquire missing plan/PRD gates. Missing producers for actual implementation return a concrete read-only slice to the existing capability-discovery route; do not synthesize completed nodes. Place sample and working-MVP checkpoints after actual artifacts and their technical prerequisites, then before the dependent next work. Link investment/durable-change material decisions through `affects.artifactFlowRefs`, and release/scale through the same flow plus the current `sideEffectActions`. The ordinary runner derives durable decisions from these normalized facts and actual producer results, rather than requiring a hand-filled runtime checkpoint array. Ordinary approved repairs with no new design keep their existing route. Reuse a consumed material judgement by resuming its original run with unchanged lifecycle/design and current material bindings. Cross-run acceptance inheritance is not implemented; `within_accepted_scope` alone proves no prior human acceptance and returns the affected plan to Thinking/Fetch when that basis is missing. Unknown stage or missing material facts are not automatic approval questions. Present the current real material, its version and the relevant next work through an available authentic native host surface; a supplied design, worker self-score, local JSON or a policy-choice reply is not a human milestone answer. Preserve permissions, unrelated ready work and completed results; unsupported host callbacks remain pending.

On a Codex Desktop host exposing native `request_user_input_async` and official `mcp__codex_app__read_thread`, the project host owns the actual ask and reader calls. Use `scripts/codex-desktop-human-milestone.mjs` with the existing issued milestone/run: `prepare` binds the current goal/intent/design/material/node, host thread/turn, a fresh challenge and that turn's pre-ask reader baseline; only a fresh `mayAsk=true` permits one actual native ask. Persist the unchanged official returns privately and `record-presented` to register the newly observed call/index and exact question/options. A later turn only `observe`s that original question and `consume`s its exact explicit user reply through the existing Decision/substrate CAS; it must not re-ask a pending, ambiguous or unknown question. Keep question and reply turns distinct. The reader return, file path, XML wrapper and host-call-ref string do not authenticate a human: source trust belongs to the current host's actual official call chain, never a model/peer report or ordinary business JSON. The library permanently reports `executionAllowed:false` and `originAuthenticatedByLibrary:false`; only a consumed current judgement may clear its own dependency wait. Recheck pause, authority and material version; preserve unrelated ready work and completed outputs. Resume the same ordinary run with the `consumer` from `openCodexDesktopHumanMilestoneHost` as the existing `stageRunner.humanDecisionConsumer`; this factory accepts the current host's scoped `authorize` and original-reader port, not an `approved` flag. To observe a review while unrelated workers remain active, also pass the existing current `stageDagPacket`; the adapter verifies its graph digest, each active claim's stored node-definition binding, independent ancestry and supported read-only effect. Missing or conflicting graph/claim evidence retains the wait. This graph input is evidence for branch independence, not permission. CLI consumption alone does not invoke workers, complete the parent goal or register a background callback. Without the actual host tools or trustworthy source chain, keep the decision pending.

The bounded shell entry uses the approved source package, not a guessed global version: `node <approved-source-root>/scripts/codex-desktop-human-milestone.mjs prepare --project-root <B> --db <existing-db> --input <owned-context.json> --exchange-root <owned-exchange> --host-connection-ref <opaque-host-ref> --host-binding-digest <current-binding-digest> --reader-result <owned-official-return.json> --reader-args <owned-original-args.json> --reader-call-ref <actual-call-ref> --reader-observed-at <actual-observation-time>`. Keep these files under B's `.meta-kim/work`; prepare context contains the issued `runId`/`bindingDigest`, current `hostContext`, actual native `activeSchema`, option-id-bearing `presentation` and expiry; include the same current `stageDagPacket` when independent active workers may overlap the review. Reuse those bindings for `record-presented`, `observe` and `consume`, supplying the corresponding new actual reader return rather than changing a pending question. The original host call/arguments and raw return remain private evidence; shared events contain refs/digests only.

When a source-bound Service method result needs to become a delivery design, Thinking sends the actual decoded result, original goal/constraints/criterion and required current design format to the same selected qualified professional owner, using that method's supported `currentSystem.priorResults` input. That owner returns an explicit `designInput` candidate for the existing `product-design.mjs` normalizer; missing lifecycle, artifact-flow, criterion ownership or other facts return to that owner. The host supplies this candidate through the ordinary runner's existing `designInput` before the new legal run's fingerprint is committed. Do not cast `domainOutput`, loosely copy slices, silently change a completed run or claim that Service results automatically become normalized designs. Preserve source/method digests, actual input/output evidence and human acceptance boundaries throughout this host step.

Keep one current product entry in the existing PRD: goal, scope, user journey and UI states, data rules, acceptance, unresolved choices and a short current-stage note. Maintain task status, dependencies, blockers and evidence links in the project's existing authoritative task source; research and full run originals stay in their existing research/owned evidence locations. Update changed requirements in place and update their existing tasks; record important design changes with their reason and links, not a full report appended or prepended every turn. An actual document reorganization first preserves a snapshot and maps sections, requirements and stable task IDs, preserves content and links, then clearly archives the old full text as non-current. Preserve each project's existing task IDs and layout; do not impose one column count or turn supplemental planning files into a second PRD.

Only then split the design into narrow deliverable tasks with inputs, outputs, true dependencies, criterion ownership and a concrete demonstration or check. Use existing task packets and the existing DAG. Load the selected Kim method's verified `AGENT.md`, `method.json` and capability input/output contract into the actual worker invocation. Producer self-checks remain pending independent review. The reviewer reads actual current artifacts against the user's constraints; ordinary failures return to the responsible task and continue within the existing authorization. Design changes invalidate affected descendants; same-design restart uses existing durable identity and never blindly repeats an uncertain side effect.

For an already-authorized existing-chat continuation on a Codex host that actually exposes the official `wait_threads` and `send_message_to_thread` tools, bind the parent run/task/graph, current claim, original thread, human authorization reference and approved work-order digest before acting. Keep only a safe opaque work-order reference and digest in the command; supply the complete text from an owned private file through `--work-order`. Use the first-party `scripts/live-host-continuation.mjs prepare` entry with the existing kernel and current host scope; only a fresh `mayDispatch=true` allows the host to proceed under that existing authorization and call the returned fixed tool request through its real `tools` surface. Keep the complete request and unchanged tool return in owned private exchange files; use the same script's `commit` entry to ingest the bound return and recheck the private prepared request against that digest. The host then checks the actual result against the parent criteria and continues its existing approved ready work; `commit` itself only reconciles the tool return. A duplicate request, explicit pause, missing authority or uncertain return must not resend or restart the original job. Node does not possess these host tools, local JSON does not authenticate human approval, and message acceptance is neither owner receipt nor business acceptance. Distinguish source-only checks, actual host calls and parent-goal verification; selected tools or a printed next action do not prove consumption. Without the host surface remain pending; do not start an app-server or Goal to manufacture support. An active parent must stay active while authorized child tasks are running, wait for their native completion/return, verify the actual artifacts against the parent criteria and continue the next authorized ready action; it must not finalize early and claim that a later child message will open a new turn. Native child agents must return results to their native ancestors through native collaboration/final return, not `send_message_to_thread`; native collaboration messages do not themselves start a new parent turn. Only a still-active worker notifying an existing chat that is not its native ancestor may use the completion-notification route, with independent trusted human authorization explicitly permitting that notification, a frozen result and the original run and claim still valid, before its final response and before `completeNode`. Bind the original parent thread/turn/run/node, criteria, actual artifact references/digests and that authorization in the private handoff; an orchestrator request to reply is not itself permission. Recheck the parent chat's current human input, pause and goal state; if any changed, wait for reassessment. Follow the same `prepare` -> fresh `mayDispatch=true` -> actual official `send_message_to_thread` -> unchanged-return `commit` sequence, then finalize. The send tool has no `expectedTurn` compare-and-swap, so the recheck does not make delivery atomic. A host refusal must retain its original receipt and unresolved effect; do not proxy the refused notification or retry it through another channel. Notification grants no new authority and is not business acceptance. An unfinished parent may end its turn and retain the already-authorized official heartbeat only when no authorized child task is running, no authorized ready work remains and progress genuinely waits for human input or permission. Immediate automatic wakeup of an ended parent turn from native-child completion is unsupported on this host; a heartbeat wakeup does not prove that capability.

This path internalizes grilling/domain-modeling, the user's game-design method and to-tickets as different responsibilities, not interchangeable templates or separately installed orchestrators. Clear simple reads and already specified small changes keep their proportionate route. Default CLI output remains planned-only; design data and supplied reviews never certify native invocation. See `references/intent-amplification.md` for inputs and evidence boundaries.

Route Decision and action Permission have different authority. A choice or confirmed understanding does not grant paid-tool, credential, deployment or other external-write permission. Professional dependencies receive the settled task and return material discoveries to the single Meta_Kim intent/route owner; they do not restart the interview, planning authority or orchestrator.

Use the actually exposed host choice surface and its current schema for a material unresolved user decision. If that surface is unavailable, retain the pending decision and use only a supported host-answer path; never manufacture a native receipt. Reuse direction already settled in the conversation unless new material evidence changes it.

Typical decision-impacting scenarios:

- Unresolved alternatives that change the user-visible outcome, scope, cost, risk or acceptance; owner/tool substitutions alone are internal choices
- Persistence layer and write-back target
- Change scope, rollback, and continue vs. stop

Choice presentation uses the host's actual interface. Pass supported option labels, concise practical tradeoffs and a recommendation where appropriate. Do not invent a two-pane layout, keyboard shortcuts or rendered controls that the host does not expose. Keep internal packet fields out of the user's question.

Trigger stages: Critical / Fetch / Thinking / Review.

**When you MUST pop** — use the native choice surface (Claude `AskUserQuestion` / Codex `request_user_input` / runtime equivalent) when an unresolved choice materially changes the user-visible outcome, scope, cost, risk, permission or acceptance and existing user direction does not resolve it. Describe each feasible option through its practical result and tradeoffs. Owner or loadout differences alone are internal selections for the host. Decide routine reversible details under existing authorization. New material evidence can reopen an affected decision; silence, elapsed time and a recommendation cannot approve it.

**When NOT to pop** — symmetric guardrail to keep the dialog from becoming UI decoration:

- Pure informational confirmation where any short reply (y/n, ok, continue) is equivalent
- Single-word answers already implied by the prior context
- Low-risk follow-ups chained inside the same decision (e.g., "which file?" right after "which path?")
- User has already expressed a clear, unambiguous direction in the same turn

If in doubt, prefer one consolidated dialog over a chain of small ones. Do not ritual-question every micro-step.

## Global-First Project Bootstrap

General capability foundations are global. Discover Agents, Commands, MCP providers/config, hooks, skills, prompts/rules and tools from the relevant inventory, then research the current project. Each persistent professional project maintains its own specialist Agents, Skills and rules, together with context, merged configuration, evidence and source versions. Retain only the needed foundations and project specializations; existing project capabilities are reused or updated in place.

For each persistent professional project, Fetch and Thinking identify the needed specialist responsibilities and evidence-backed project rules, then reuse a suitable existing project capability or create or update it through the existing project-capability lifecycle. Keep genuinely shared foundations as versioned references; copying an unchanged global template does not establish project specialization. Record the researched project need, substantive adaptation and source ownership before writing any project-local agent, Command, MCP, hook, skill, prompt/rule, or runtime adapter file.

Default source chain:

```text
installed Meta_Kim package root
-> canonical/ and config/sync.json
-> global runtime homes and capability inventories
-> project .meta-kim/state/cache/overrides evidence
-> project-local capability files only after projectCustomizationPacket approval
```

Required behavior:

- Before creating project-local capability files, run capability discovery across global runtime homes, project inventories, package scripts, MCP/tool catalogs, and existing local config. Use global assets as versioned foundations and preparation methods; persistent professional work requires the project-owned capability lifecycle.
- Project bootstrap may write project context/config/state: managed `AGENTS.md` / `CLAUDE.md` blocks, additive MCP/settings merges, `graphify-out/`, and `.meta-kim/state|cache|backups|local.overrides.json`. These are not evidence that reusable capability assets should be copied into the project.
- A project-local capability write requires `projectCustomizationPacket` with `capabilityType`, `globalCandidateChecked`, `projectNeed`, `customizationReason`, `targetPath`, `mergePolicy`, `owner`, `verification`, and `rollback`. If any field is missing, return to Fetch or Thinking.
- Project-local capability files use `copy_to_project_for_modification`, `create_project_local_capability`, or `already_project_local`; a suitable existing project capability uses `reuse_existing_project` in the customization decision. Global preparation and truly shared foundations may remain referenced with `use_global_directly`, without satisfying project-owned professional delivery.
- 项目内迭代或创新需要专用能力时,必须创建在对应 runtime 的原生项目目录,不要再包一层 `.meta_kim` 或 `.meta-kim` capability 目录:Claude Code 用 `.claude/agents/`、`.claude/skills/<skill>/`、`.claude/commands/`、`.claude/hooks/`;Codex 用 `.codex/agents/`、`.agents/skills/<skill>/`、`.codex/commands/`、`.codex/hooks.json` + `.codex/hooks/`;Cursor 用 `.cursor/agents/`、`.cursor/skills/<skill>/`、`.cursor/rules/`、`.cursor/hooks.json` + `.cursor/hooks/`;OpenClaw 用 `openclaw/workspaces/<agent>/`、`openclaw/skills/<skill>/`、`openclaw/openclaw.template.json`。
- MCP、settings、hooks JSON、OpenClaw template, and other runtime config files are always merge targets. Add missing project-specific entries, preserve user entries and credentials, and never overwrite the whole file to "make it clean".
- Project-local capability assets created by Meta_Kim must leave ownership evidence: either a manifest entry in `.meta-kim/state/default/project-bootstrap.json`, a managed block, or a small `PROJECT_CUSTOMIZATION.md` next to the asset that names the `projectCustomizationPacket`, owner, verification command, and rollback path.
- Install scope and run-time sedimentation are independent. `setup.mjs` lets the user choose global or project installation; later governed execution must still copy every newly created or project-iterated Agent, Skill, or Command into the current project's native runtime directory. Use `meta-kim project capability copy ... --mode create|iterate --apply` before modifying a global provider or accepting a staged new provider. Its independent `.meta-kim/state/default/project-capabilities.json` ownership record protects that project copy from later dependency/global updates. Global preparation and shared foundations remain read-only references. Persistent professional delivery additionally requires a discovered and loaded project owner.
- A normal global install/update must also merge-refresh current, explicit, or saved projects that already have a valid Meta_Kim project-bootstrap manifest. This does not materialize a fresh project projection, change update topology, add another confirmation, or authorize cleanup. Cleanup stays explicit. Packed CLI project discovery uses the trusted caller cwd rather than the package-cache root.
- Before any project bootstrap plan, write, stale cleanup, or explicit redundancy cleanup, read `.meta-kim/state/default/project-capabilities.json`. Agent, Skill, and Command paths marked `runtime_sedimented_project_copy` or `preserve_project_copy` outrank bootstrap/install ownership and must remain byte-for-byte untouched.
- During update/bootstrap cleanup, remove stale project-local capability assets only when previous Meta_Kim manifest evidence proves ownership and the current plan no longer manages that path. Unknown project files, user-created files, credentials, and merge config files are preserved; empty runtime capability folders may be pruned after their last Meta_Kim-managed file is removed.
- Hooks are last-resort fuses, not the normal design path. If a spine gate, ECC/fact gate, or runtime hook blocks repeatedly, return to Thinking and select the required abstract check/output contract before execution; do not rely on hook denial loops as the way to discover the right output.
- For initialization, update or a project-specific override, use existing user authorization. Ask through the actual host surface only if the destination or a material scope/permission choice remains unresolved; do not re-confirm an already requested install/update. A compatibility runtime decision card is not Claude/Codex native invocation proof.
- Apply only after confirmation or an explicit trusted-auto policy. The apply path must create a backup under `.meta-kim/backups/project-bootstrap/<timestamp>` before overwriting or merging existing files and must write `.meta-kim/state/default/project-bootstrap.json`.
- Preserve user-owned content: JSON configs use additive preserve-user-state merge; existing `AGENTS.md` and `CLAUDE.md` keep user text and receive or update only a Meta_Kim managed block; credentials, project trust state, local runtime state, and workspace state are never copied as project bootstrap files.
- Stale, readonly, permission-denied, or conflicting managed-block cases are not success. Record the blocker, show the next safe action, and do not claim project bootstrap pass until a fresh probe or apply result proves it.

**When to ask:**

| Stage | When to Ask | Example |
|---|---|---|
| Critical | Intent dimension missing, answer changes route/scope/risk/non-goal | "This could be a quick fix or a full rewrite. Which direction?" |
| Fetch | Evidence shows multiple paths with different trade-offs | "I found approach A (faster) and B (more thorough). Which?" |
| Thinking | Choosing between solution paths with different scope/cost | "Minimal fix: 2 hours. Ten-x shift: 2 days. Your call?" |
| Review | Issues found that need user preference to resolve | "Quality concern: rebuild or patch?" |

**Question format:**
- Use the active runtime-native maximum meaningful option count; Meta_Kim must not add a lower option cap of its own
- One recommended default labeled clearly
- User's language, not internal packet field names
- For Codex, inspect the active `request_user_input` schema and use its maximum accepted meaningful option count. If the active host exposes 2-3 options per question, use up to 3; if a future or different host exposes more, use that larger maximum. If semantic options exceed the active host maximum, show the strongest host-maximum set and record omitted alternatives instead of retrying an oversized payload unchanged.
- The native payload is a structured decision panel: preserve AI understanding, AI additions, Capability route, Candidate paths, expected result, advantages, disadvantages/risk, and verification impact when those fields affect the decision.
- Stop and wait — do not proceed until the user answers

**Do not ask:**
- Ritual questions or stage-by-stage confirmation spam
- Just because the work is read-only; ask only when read-only analysis still exposes route-changing choices
- Questions during Meta-Review, Verification, or Evolution (these are mechanical checks)

## Type A: Prompt / Reference / Contract Hardening

Dispatch to `meta-prism` for prompt executability review and `meta-warden` for final gate. The main thread is not the executor. Use the active host's native delegation tool when the task has more than a direct query or >3 sentences of change. Output: reviewed contract diff, `workerResultPackets[].fileCompletionList`, workerExecutionEvidence, and verification evidence.

## Type B: Agent / Skill / Owner Creation Or Upgrade

Dispatch to `meta-genesis` for identity/prompt architecture, `meta-artisan` for capability loadout, then `meta-prism` and `meta-warden` for review. Optional: `meta-sentinel`, `meta-librarian`, `meta-conductor`. Existing owner wins; owner upgrade or project-local creation is allowed only when Fetch proves a gap. Execution-agent evolution uses this Type B pipeline, not direct edit.

## Type C: External Capability / Tool / Dependency Discovery

Fetch starts with first-party capability search (`meta:capability:search`) and the existing cached inventory, then inspects route-relevant local capability indexes, runtime mirrors, MCP, package scripts, installed skills and global capabilities. Expand to external capability or specialist ecosystem evidence through `meta-scout` when a concrete unresolved gap requires it; use `findskill` only when installed and appropriate. Apply the existing project-light, stop-on-match policy without a mandatory full scan or external call. Optional owners: `meta-prism`, `meta-sentinel`, `meta-scout`. Use the active host's native delegation tool only after Thinking binds an owner; the DISPATCHER does not execute discovery side effects. If no callable owner exists, return to Thinking with `capabilityGapPacket`; do not use temporary fallback.

## Type D: Review / Verification / Rollback / Public-Ready

Dispatch to `meta-prism` and `meta-warden`; optional `meta-scout`, `meta-sentinel`, `meta-chrysalis`. Stage 4 owner prohibition: never dispatch Type: general-purpose, runtime alias, or governance agent as implementation worker. Public-ready requires verification evidence, userGoalDone, warning classification, and Warden gate.

## Type E: Orchestration / Business Flow / Release

Dispatch to `meta-conductor` for dynamic business-flow blueprint and stage-DAG orchestration, then `meta-warden` for synthesis. Conductor must classify the user's natural-language intent, choose lanes by evidence and dependency signals, record omitted lanes with reasons, and derive stage-ready sets only after dependency, resource, permission, isolation, and merge boundaries are known. Native Claude Code Agent/Task or Codex `spawn_agent` is sufficient when the stage DAG and owner bindings are valid; `agent-teams-playbook` may be selected as an optional orchestration aid but is never a prerequisite for safe native fan-out. Size concurrent ready sets from the runtime's current capacity and the task DAG. Meta_Kim installs Codex with the visible resource-safe default `[agents].max_threads = 2`, preserves an explicit user override, and adds no hidden cap beyond that runtime configuration. Schedule the maximal safe subset instead of disabling all fan-out because one lane conflicts, and avoid role inflation. Use stop-on-match capability resolution: bind a qualified local/global Agent, Skill, Tool, Command, or MCP provider immediately, run external discovery only for a proven gap, and never relabel planned or selected capability as invoked without exact host evidence. Degraded mode requires a real host-surface, permission, isolation, resource, or owner gap.

The 11-phase business workflow must prove phase decisions, not only list phase names. `businessPhasePlanPacket` requires a trigger standard: every phase records whether it triggered, skipped, blocked, or waits; the phase decision must score at least 80 with quantitative signals, evidence references, and falsification checks. Accurate skips such as `revision` after a clean Review and waits such as `feedback` before user acceptance are valid only when the evidence explains them.

Card dealing must prove card decisions, not only list the deck. `cardPlanPacket` requires a deal accuracy standard: every card records whether it was dealt, suppressed, deferred, skipped, interrupted, or escalated; the decision must score at least 80 with quantitative signals, evidence references, and falsification checks. At run start and in the readable report, show a short card summary so the user sees why cards triggered without reading raw packets.

Routine Type E release work defaults to lightweight smoke when the change is low-risk prompt/docs/governance wording, changelog, or version metadata. Use `meta:release:smoke` plus `git diff --check`, then commit/tag/publish without upgrading unless risk or the user asks. Standard full-release Type E uses `meta:verify:all` for install/update, global sync, hooks, runtime matrix, provider registry, dependency compatibility, probes, package contents, security-sensitive behavior, or explicit full verification requests; a complete passing run permits an ordinary release. After a standard full release is published with its exact npm tgz asset, run `meta-kim release audit --tag <tag> --verification-report <report> --package-file <tgz> --require-exact`; keep every immutable attempt and attach the successful audit record to the Release. Exact promotion requires the uploaded tgz digest to match the byte-exact npm candidate installed and tested by that clean full gate; package name, version, or `package.json` alone are insufficient. A dirty or unavailable historical report may be indexed only as `published_artifacts_bound_verification_unbound` and must never be promoted. If the run uses local planning files and a local-private PRD, finish the stable Claude Code/Codex global update and read-only global check, then run `meta-kim release close --issue <P-NNN> --prd <repo-relative-private-prd>`. This explicit final step verifies the exact audit and appends an idempotent, interruption-recoverable release-fact block to existing planning files; it never publishes the PRD or creates a second queue. `meta:verify:live-certified` is a separate optional highest-assurance mode that appends private-attested external-observer exact-binding clean-room verification. Missing that attestation forbids only the `live-certified` claim and does not block a separately passing standard release. Detailed evidence chains live in `dev-governance.md`, `owner-resolution.md`, and `verification-evidence.md`. Validators, gates, and hooks are protection, not the engine; if they patch missing route evidence after the fact, return to Thinking before public-ready or release.

## Dispatch Self-Check
Before Execution, record the minimum Protocol-first Dispatch evidence: intent, Fetch evidence, a Thinking route, selected owner, owner loadout, memory strategy, Review standard, and the current `stageDagPacket`. Preferred compatibility views include `runHeader`, `dispatchBoard`, `businessFlowBlueprintPacket`, `agentBlueprintPacket`, `ownerDiscoveryPacket`, and Execution-stage `workerTaskPackets`, but hooks must not require every optional field before useful work can continue. `agentInvocationState`: `idle -> discovered -> matched -> requested -> dispatched -> returned/escalated`. `workerTaskPackets`, `parallelGroup`, and scheduler waves are derived Execution views of authoritative stage-DAG nodes; they must not become a second dependency or collision source. `ownerDiscoveryPacket` should list the relevant repo canonical owners, runtime mirror owners, project runtime agents, local global agents, and reusable skill/command/hook/rule/prompt/MCP/plugin/tool providers checked before a create or upgrade decision. Option Exploration is MANDATORY when materially different paths exist: compare ≥2 solution paths with Pros / Cons or Decision Record, or record `no_branching_choice` with evidence. Apply Skip-Level Self-Reflection Gate and Escalation Signals before dispatch.

## Fetch Evidence Inventory

Research -> Inventory -> Thinking Handoff. Fetch first records the question, source requirements, retrieval capability readiness, and multi-type capability inventory. Thinking determines needed execution capabilities after Fetch, matches existing capabilities, and creates or upgrades only for gaps. Fetch material claims include version, price, third-party, platform, current web state, dependency, provider, and tool assertions. If current facts matter, set `contentEvidencePacket.researchRequired = true`, run `researchCapabilityDiscovery`, and prefer `web_search`, `url_fetch`, `docs_lookup`, `browser_open`, `mcp_search`, or `plugin_search` before route design. Deep research must identify key information targets, run iterative query / read / update loops, record stop conditions, update `decisionImpactMap` when evidence changes owner/route/scope/risk/verification, and convert route-changing claims into `claimEvidenceCards` with source refs, counterevidence, confidence, and falsification status. If research is blocked, return `blocked` with `user_fallback` rather than guessing. Run command/script discovery by package.json script scan and npm run inventory. Apply DRY conflict detection: overlap detect, duplicate reject, and keep one owner per capability. Capability selection ROI = (Task Coverage x Usage Frequency) / (Context Cost + Learning Curve).

Global professional provider first: a governed route must prefer already-discovered professional capability providers over inventing temporary small agents. Global execution agents, skills, MCP providers/tools, commands, runtime tools, hooks, plugins, memory/graph providers, and dependency providers are candidate professional owners or weapons when their contracts fit the task. `workerTaskPacket` is only a run-scoped work order for a selected professional owner/loadout; it is not an agent, not a subagent identity, and not a durable provider. For explicit agent fan-out, each executable lane must bind a reusable execution-agent owner first; selected skills, commands, MCP tools, and runtime tools are loadout/dependency bindings and must not replace the lane's agent owner. A runtime worker instance is allowed only after this owner binding exists, and the visible dispatch surface must name the reused owner/capability before or alongside any host-created worker badge. Reuse an existing suitable project owner for the recurring responsibility. If the project lacks one, use the discovered global foundation and researched project requirements to create or adapt an independent owner through `GapDecision = create_agent` and the existing Type B review path.

Fetch discovery minimum checklist: use this source catalog for route-relevant discovery before Thinking. Follow `config/contracts/core-loop-contract.json`: consult cached global inventory plus a project-light scan, stop-on-match when a qualified provider fits, and refresh all applicable sources only for `capabilityDiscovery.fullScanTriggers`. The catalog preserves every runtime and capability family; it does not require reading every path on every run:
- canonical sources and capability indexes: `canonical/agents/`, `canonical/skills/`, `canonical/runtime-assets/`, `config/capability-index/*.json`, and runtime capability-index mirrors
- Claude Code project and global inventories: `.claude/agents/`, `.claude/skills/`, `.claude/commands/`, `.claude/hooks/`, `.claude/settings.json`, `~/.claude/agents/`, `~/.claude/skills/`, `~/.claude/commands/`, `~/.claude/hooks/`, and `~/.claude/settings.json`
- Codex project and global inventories: `.codex/agents/`, `.agents/skills/`, `.codex/commands/`, `.codex/hooks/`, `.codex/hooks.json`, `.codex/config.toml`, `~/.codex/agents/`, `~/.codex/skills/`, `~/.codex/commands/`, `~/.codex/hooks/meta-kim/`, `~/.codex/hooks.json`, `~/.codex/config.toml`, and `~/.agents/skills/`
- Cursor project and global inventories: `.cursor/agents/`, `.cursor/skills/`, `.cursor/rules/`, `.cursor/prompts/`, `.cursor/hooks/`, `.cursor/hooks.json`, `.cursor/mcp.json`, `~/.cursor/agents/`, `~/.cursor/skills/`, `~/.cursor/rules/`, `~/.cursor/prompts/`, `~/.cursor/hooks/meta-kim/`, and `~/.cursor/hooks.json`
- OpenClaw project and global inventories: `openclaw/workspaces/`, `openclaw/skills/`, `openclaw/hooks/`, `openclaw/openclaw.template.json`, `~/.openclaw/openclaw.json`, `~/.openclaw/workspace-*`, `~/.openclaw/skills/`, `~/.openclaw/hooks/`, and `~/.agents/skills/`
- Gemini CLI project and global inventories: `.gemini/agents/`, shared host-neutral `.agents/skills/`, `.gemini/skills/`, `.gemini/settings.json`, `.gemini/hooks/`, `GEMINI.md`, `~/.gemini/agents/`, `~/.gemini/skills/`, and `~/.gemini/settings.json`; check the active client's skill priority and exact native Hook schema
- ZCode project and user inventories: `.zcode/agents/`, `.zcode/skills/`, `.zcode/config.json`, `~/.zcode/agents/`, `~/.zcode/skills/`, and `~/.zcode/cli/config.json`; current project Hooks are ignored, so execution Hooks use the reviewed user-level or plugin surface only
- runtime package and command providers: `package.json` scripts, local scripts, runtime commands, hooks, validators, prompts/rules, setup/status/doctor/sync/install routes
- `.mcp.json`, runtime MCP config such as `.codex/config.toml` and `.cursor/mcp.json`, MCP server/tool inventory, and connector/plugin inventories
- `config/runtime-capability-matrix.json`, `config/os-compatibility-matrix.json`, `config/capability-index/dependency-project-registry.json`, and dependency/external package registries
- retrieval capability inventory: `web_search`, `url_fetch`, `docs_lookup`, `browser_open`, `mcp_search`, `plugin_search`, `local_only`, and user-supplied source paths

Pass condition: `fetchPacket.capabilityDiscovery.searchLog` exists with actual checked sources and results, including empty or unavailable source entries for sources actually checked and reasons for skipping route-relevant sources; `fetchPacket.capabilityDiscovery.capabilityInventory` covers the capability types and runtime-specific paths that affect the route; and planned file mutation records `fileChangeFactCard`; detailed schema lives in `dev-governance.md`. Cached inventory is discovery evidence, not a claim that each underlying path was freshly scanned.

Fetch angle decomposition: for research or analysis tasks (when `contentEvidencePacket.researchRequired = true`), decompose the core question into N semantically distinct search angles before searching. Each angle must target a different aspect; rephrasing the same angle is forbidden. Output: `contentEvidencePacket.searchAngles = [{angle, keywords, expectedCoverage}]`. Choose N from the actual unresolved questions. A single focused probe may be sufficient; broaden only for concrete missing coverage or conflicting evidence.

Decision-grade research synthesis: Fetch must turn external research practice into Meta_Kim-native evidence, not copy another project's prompt text, template, command examples, or visible structure into canonical governance. For research-required runs, record `contentEvidencePacket.deepResearchPlan` with the user's decision use, the relevant unresolved sub-questions (without a default count), planned source classes, key-source deep-read targets, source-quality ladder, claim attribution rules, cross-check strategy, original-synthesis rules, and decision-impact criteria. Search volume is not evidence; at least one material claim must map to owner, route, scope, risk, acceptance, blocker, or rejected path before Thinking can use it. Search snippets alone are insufficient for route-changing claims; Fetch must read the strongest relevant primary or official material and state uncertainty. One authoritative source can establish its own documented contract; independent corroboration is needed when a disputed, inferred or high-impact claim requires it. External methods may be cited in private research notes, but durable Meta_Kim prompts keep only abstract invariants: question decomposition, source breadth, key-source reading, citation discipline, contradiction handling, assumption ledger, and Thinking handoff.

Graphify knowledge policy: Graphify is an agent capability, not a context dump. At run start, check only whether `graphify-out/graph.json`, `graphify-out/GRAPH_REPORT.md`, or wiki indexes exist; do not run a global freshness check or rebuild just because a graph exists. For focused questions, prefer `graphify query "<question>"` with a small budget, `graphify path "<A>" "<B>"` for relationships, or `graphify explain "<concept>"` for concepts; use `GRAPH_REPORT.md` only for broad architecture orientation or when query/path/explain do not surface enough context. Treat Graphify output as candidate navigation, not truth: if results are generic, stale, polluted by generated/local state, or route-changing, fall back to targeted repository search and read the target source files before deciding. Inject only worker-relevant graph slices, short hints, and file anchors; never inject the full `graph.json`, full `GRAPH_REPORT.md`, or broad graph dumps into every worker. After code, canonical, contract, or runtime-facing doc mutation, rebuild Graphify in Verification/Evolution; reserve `meta:graphify:check` for verification, release, public-ready, or explicit graph validation.

Execution-agent identity must stay abstract and provider-first. Durable `executionAgentCard` content may describe a reusable capability class, boundaries, abstract dependencies, inputs, and outputs; it must not contain repo paths, file lists, tickets, one-run work instructions, `todayTask`, `scopeFiles`, `deliverableLink`, or `verifySteps`. Match existing agents, skills, commands, hooks, rules/prompts, MCP tools, runtime tools, and plugins before creating or upgrading an execution agent. Put concrete work in `workerTaskPackets`, `capabilityBindings`, and `orchestrationTaskBoardPacket` only. If a card cannot be written without concrete task binding, return to Thinking and reuse an existing owner/provider or emit `capabilityGapPacket`. When `GapDecision = create_agent`, require a `GeneratedAgentSpec` review artifact with flow position, handoff, loadout slots, scoped memory, gap policy, verification policy, install projection, and identity-cleanliness proof before any agent file is written.

Temporary small-agent prohibition: do not create a new agent merely to execute this run's task, shard, file set, or role instance. If the work is one-run, keep it in `workerTaskPackets` and bind it to an existing professional provider. If the work is recurring but the best global provider is partial, prefer `upgrade_existing_owner` or a project-local professional profile over a throwaway runtime agent. A runtime adapter may expose a coarse role name for host routing, but it must not become the professional owner unless it has its own reviewed capability contract.

Capability scan UX: full global scans happen on install, update, explicit refresh, missing cache, cache older than 14 days, missing required provider, or high-risk provider routes. Normal execution reads cached global inventory, performs a lightweight project scan, shows only counts/top candidates/source refs, and avoids dumping full provider definitions into chat. If the last full scan is older than 2 weeks, tell the user this run will update first to match newly added content and reach the best capability route, then refresh before execution.

## Warden Entry Gate

Governed meta-theory entry enters through `meta-warden` entry gate, whether it was triggered by ordinary natural language or by an explicit maintainer shortcut. Then `meta-conductor` owns the evidence lane and sequencing, `meta-scout` owns external evidence, and `meta-prism` audits Critical, Fetch, and Thinking quality before output polish. All meta agents are dispatch targets: `meta-warden`, `meta-conductor`, `meta-scout`, `meta-artisan`, `meta-genesis`, `meta-sentinel`, `meta-librarian`, `meta-prism`, `meta-chrysalis`.

## Product Reasoning Contract

Translate the surface request into the real product problem. Compare minimal fix against ten-x path challenge and path shift. Final user-facing closure states the root goal, what this run did, whether it still fits the root direction, whether delivery is complete or partial, chosen rationale, why changed / why change, what changed, where changed, user impact, verification, complexity added or avoided, remaining limits, deferred work, and next action.

Product-route or strategy-unclear requests must not automatically expand into a full product build. When the user's real question is "which route should I take?", first design a decision protocol and minimum evidence bench: candidate routes, required evidence, first experiment, pass/kill signals, time box, and review checks. A UI, backend, database, automation, or full app lane starts only when the user asks to build, evidence proves the route, or Thinking records why implementation is now the smallest useful test.

Repository or product-doc cleanup requests must first separate change pressure from durable architecture. Before suggesting directory moves, classify the current work into change trains and source layers: source layer, projection layer, evidence layer, and reader layer. Record whether scripts or commands are read-only, generate state, sync runtime projections, install/update dependencies, or run live/slow checks. Do not treat "many files visible" as proof that directories should be moved; first decide which layer the confusion belongs to.

## Decision Cross-Validation Gate

For PR, issue, release, compatibility, public-ready, or skill-prioritization decisions, the answer must survive adversarial cross-validation before it is treated as done. Record the evidence snapshot time, source state matrix, confidence labels, counterevidence, contradiction log, falsification checks, and replay commands. Re-check current external state when it can change, such as open PRs, open issues, comments, labels, review state, release status, package versions, or platform support.

Decision recommendations must bind one primary risk lane and at most one secondary lane to the next executable gate. For example, runtime/setup/install/sync changes bind to cross-runtime contract design; localized routing or choice-surface changes bind to multilingual QA; review finding or release-closure work binds to review closure discipline; hook/dispatch/state/validator changes bind to state-machine failure modeling. When two lanes compete, choose by failure cost: user install/runtime breakage, wrong execution or repeated hook blocks, incomplete public closure, then localized user route failure.

Fail the gate if the decision relies on stale PR/issue state, a single source with no countercheck, unlabeled inference, unverifiable "verified" claims, command-pass equals user-goal-done, or four equal priorities with no next action. A cross-validatable decision must let an independent reviewer replay the evidence and either reach the same conclusion or see exactly which contradiction changed the route.

## Human-Readable Stage Feedback

Stage updates must be compact, human, and in the resolved user language. Record internally with packet field name / internal keys and debug traces, but show human label and human-readable label in user-facing output. Mention Critical, Fetch, Thinking, Review only when the stage status matters. Keep token use low and avoid dumping raw packet fields unless the user asks for debug.

Public status surface uses `runStatusEnvelope`, `publicLabels`, `.meta-kim/state/{profile}/active-run.json`, and `.meta-kim/state/{profile}/runs/{runId}/status.json`. Apply runtime/tool selected output language first, then latest input language. Do not hardcode labels. The public notice must not expose internal protocol fields such as `Preflight` or `conversation_fallback` unless debug is requested.

Host-visible notice rule: in Codex App and Claude Code, a governed run must say the important progress information in normal assistant chat, in the resolved user language. HookPrompt / `additionalContext`, `systemMessage` warnings, CLI artifacts, JSON packets, and markdown reports may help the model or maintainer, but they do not count as user-visible progress unless the assistant also renders the notice in the conversation. HookPrompt is prompt-intake context only: it must not be treated as active-run authority, Fetch evidence, Thinking evidence, workerTaskPacket evidence, execution evidence, verification evidence, or public-ready proof. Required visible moments are run start, route selected before Execution, blocker/degraded state when present, and closure. Keep each notice to at most three information blocks; nested human-readable details inside those blocks must preserve stage/current work, owner/capability, result, risk or blocker, verification, and next action. Do not reduce chat guidance merely to shorten the notice; move only raw packet keys and duplicate telemetry to report/debug. Use native choice surfaces only for branch-changing decisions, not for routine status.
The governed runner must emit ordered conversation progress snapshots at run start, Fetch completion, Thinking route lock before Execution, Execution planning, Review snapshot, and closure. Do not call a snapshot a completed eight-stage runtime boundary unless host evidence proves that boundary. Host adapters consume progress through the API callback or stderr progress channel and relay it into normal assistant chat; stdout remains a single machine-readable final JSON summary. A final three-block aggregate remains available for user summary and audit. The blocks must show final artifact status and readable partial reasons, actual orchestration owner, selected provider bindings with invocation state, planned/structural versus host-observed mesh truth, and control graph nodes/edges/state/checkpoints. A sentence claiming that these are visible is not evidence by itself.
Governed run identity is a filesystem boundary. Validate every requested or latest-file `runId` with a strict filename-safe allowlist and a resolve-within-output-root check. A caller-provided ID that already exists must fail by default; overwrite requires an explicit API/CLI authorization and must be recorded in the artifact. Update `latest.json` through same-directory temporary write plus atomic rename so readers never observe a partial pointer.
Fetch anti-churn rule: do not start Critical or Fetch by creating, updating, or narrating a host task/todo board. In Claude Code, `TaskCreate`, `TaskUpdate`, and `TodoWrite` are continuity aids after useful evidence exists, not the first Fetch action and not user-visible progress. If the run needs continuity, say a short localized status in chat, then batch read/search the next evidence files. Planning files and spine-state writes are allowed only when they preserve route-changing continuity; they do not replace visible progress or Fetch evidence.
User experience truth boundary: users should not need to run `npm` scripts, inspect JSON, or know packet names to understand a governed run. Internal artifacts such as `ownerDiscoveryPacket`, `orchestrationTaskBoardPacket`, `workerTaskPackets`, and command output are evidence, not the user experience itself. When reporting orchestration, show compact localized notices for progress, route, owner handoff, blockers, and verification, and explicitly avoid claiming that users can experience a feature when it only exists as an internal artifact or maintainer-only command.

Natural-language trigger rule: the user does not need to ask for stages, agents, skills, MCPs, commands, packets, or reports. If a normal human task triggers meta-theory, the dispatcher must automatically translate the internal route into a plain-language stage plan: what this stage does, what capability/loadout will be used, what result the user will see, and what starts next. Technical names may appear only as a compact backing loadout for traceability; the primary explanation must read like an operation handoff, not a protocol dump.
Interactive execution communication: during multi-stage work, the dispatcher must report progress to the user at natural transition points — not only at the pre-decision gate. Report triggers: (1) Fetch complete — brief evidence summary and route impact, (2) Thinking complete — chosen path and trade-offs, (3) each Execution phase complete — what was done and what remains, (4) Review findings that change scope — surface them immediately, (5) route-changing discovery mid-execution — pause and inform. Each report is a compact notice with at most three information blocks, with nested details allowed when needed to keep the user informed; it is not a full packet dump. If the discovery changes scope, owner, or risk, upgrade the notice to a Decision card requiring user input. This "communicate while working" pattern keeps the user informed and in control without requiring them to ask for status.
Meta-theory visible surface: when the user explicitly triggers meta-theory or the task enters governed execution, the user-facing output must expose a compact orchestration surface before or alongside execution. It must name the orchestration owner/board, Dynamic Workflow lane choice, capability discovery beyond Skill, peer agent mesh / handoff shape, and LangGraph-style node-edge-state-checkpoint shape. Do not hide these behind `coreLoop`, JSON, packet names, or generated reports only. If a runtime cannot show this surface directly, state the blocked/degraded surface and provide the readable report artifact; do not claim P-104 user perception pass from hidden artifacts alone.
Capability invocation truth: every governed run that names agents/subagents, app-visible host UI subagents, skills, MCP, hooks, prompts/rules, commands/scripts, runtime tools, memory, graph, `agent-teams-playbook`, or worker tasks must classify each capability family as `invoked`, `applied`, `host_visible_observed`, `selected_not_invoked`, `discovered_not_selected`, `unavailable`, `not_authorized`, `blocked`, or `not_required`. `invoked` requires fresh externally observed invocation evidence joined to every exact selected `family + provider + task/lane` binding. A selected skill, selected `agent-teams-playbook` provider, configured MCP server, matched hook, command candidate, runtime tool candidate, readiness probe, or runner-generated worker plan is not invoked. Prompt/rule behavior is `applied`, not an external tool call. Host UI subagent badges are `host_visible_observed`, not Meta_Kim runner `spawn_agent` / `Agent` invocation. `capabilityInvocationProbePacket` reports readiness only and never satisfies `realInvocationCoverage`. Product-experience pass requires `realInvocationCoverage.status=pass`, a `live_host_observed` evidence tier, and zero missing bindings; `selected_not_invoked` is never execution pass. Live evidence must come from a hash-verified external host observation artifact with matching run/session/event/provider/binding/timestamp/result fields. Fixtures, self-tests, public CLI trust flags, synthesized worker results, and generic caller-authored JSON are forbidden substitutes. `hostInvocationRequestPacket` is a handoff, not proof. If no real runtime Agent/subagent tool call is available or attached, record whether the host tool is unavailable, blocked by authorization, not required, or merely selected_not_invoked; keep peer workers as structural plans and do not call them live subagents or peer-to-peer runtime agents. If `agent-teams-playbook` is selected, record it separately as `agent_teams_playbook=selected_not_invoked` unless a live Skill/Agent Team/spawn_agent call is externally observed.
User execution presentation is separate from exact-binding and live-certification audit. In normal Codex App or Claude Code chat, the active host renders the actual current-turn native tool results directly: all returned subagent calls mean called/completed; at least one returned call plus at least one failed, missing, or blocked call means called with partial failures; and a zero-success native result says failed, denied, or blocked according to that result. `unavailable` is reserved for a genuine zero-call capability boundary such as an unsupported surface or missing provider, with zero successful bindings and zero strict failed bindings. A missing audit association never erases a successful current-turn call. The Node runner does not accept a lifecycle-evidence/trust bridge for presentation and does not claim automatic host-failure ingestion: its artifact projection uses only the existing strict truth packet. Without private verified failure evidence, denied/blocked/failed offline input stays pending. CLI flags, environment variables, caller-supplied subagent names, UI badges, and generic JSON remain unverified hints and cannot produce called/completed or a verified failure. Users never provide evidence flags, session ids, or event ids. Normal chat, Markdown, and panel text must keep the useful guidance but speak at task level: state the call result, whether the run record is linked, and that an optional additional independent review does not alter the calls already made. Do not expose exact-binding/live-certification wording, provider ids, or lane terms there; raw rows, state counts, binding coverage, and exact evidence stay in the strict audit packet/debug surface.

Assistant-message visibility is also not caller-promotable runner state. Runner-side assistant-message records may diagnose expected hashes, but they always remain `host_observation_required`; arbitrary JSON or an API trust boolean cannot mark the conversation visible. Normal Codex/Claude chat visibility comes from the active host conversation itself. The governed runner exposes no caller trust input for invocation evidence. Without the separate private observer/verifier, its strict audit result stays pending; the fail-closed validator helper may be exercised by focused tests but cannot directly mint user-facing called/completed or live-certified labels. The runner does not claim a production path from caller failure JSON to verified failure. Presentation may use failed/denied/blocked only when the strict truth packet already contains verified `failedBindings`; those bindings affect failure presentation only and never satisfy invoked success, coverage pass, completed, or called. Current native chat instead reports the actual tool result directly, while offline artifacts without external verification remain pending.

## Dynamic business-flow capability matrix

Fetch expands executable deliverables into a Business-flow capability matrix by intent signals, not by a fixed template. The candidate lane universe may include product, research, content, UX, UI, frontend, backend, database, integration, security, motion, accessibility, browser QA, performance, release, feedback, and evolution. Thinking selects only the lanes justified by the current task, records omitted lanes with reasons, binds dependencies and merge owner per selected lane, and uses fan-out / synthesize / adversarial verification when the task has independent work streams.

For strategy, product-route, prioritization, roadmap, or "I do not know what to build first" asks, the default selected lane is a decision-protocol lane, not implementation. Its output is a route judgment card: user/value frame, 2-3 candidate routes, evidence needed for each route, first experiment, pass/kill signal, and next review gate. Mark UI/frontend/backend/database/integration lanes as omitted unless they are the smallest experiment or explicitly requested.

Selected dynamic lanes must synthesize project-scoped agent profiles from the current project profile and capability requirements. Thinking records them in `projectAgentBlueprintPacket` with `ownerMode = project-agent-profile`, a pinned `capabilityProfileId`, `capabilityLoadout`, `roleSoulPolicy`, project memory strategy, `externalEvidencePolicy`, `localBaselineComparison`, and `knowledgeGraphPolicy`. Current external claims such as platform rules, provider/API capability, dependency versions, pricing, compliance, security, release, or third-party workflow feasibility require source-backed Fetch evidence through `web_search`, `url_fetch`, `docs_lookup`, `browser_open`, `mcp_search`, or equivalent runtime retrieval before route lock; if that evidence is unavailable, block or return to Fetch instead of guessing. Every selected lane must also compare against local reality before dispatch: canonical agents/skills/contracts, capability indexes, runtime mirrors, package scripts, MCP configs, OS/runtime matrices, project memory, and graph navigation slices when available. Execution then calls the selected real provider surfaces when the host exposes them: agents/subagents, skills, MCP tools, commands/scripts, runtime tools, prompts/rules, or bounded run-scoped workers. A degraded structural runner may create only run-scoped worker instances and must mark uncalled selected providers as partial rather than pass, plus emit `hostInvocationRequestPacket` so the host adapter knows the exact calls still required. Capability updates change the capability profile for future runs; in-flight workers keep the pinned profile. A synthesized profile becomes a durable high-quality project agent file only through `GapDecision = create_agent` plus the Type B `GeneratedAgentSpec` review path. Durable-agent completion needs the `durableAgentLifecyclePacket` chain: definition candidate, Warden approval/writeback, host reload/discovery, and live invocation proof.

## Evolution target map

| Gap type | Evolution target |
|---|---|
| prompt gap | canonical skill or reference contract |
| agent boundary gap | target agent definition / SOUL.md |
| capability gap | `capabilityGapPacket` then Type B owner upgrade |
| dependency gap | dependency registry and compatibility validator |
| runtime/OS gap | runtime matrix or OS matrix |
| warning/hook scar | validator, hook policy, regression test |

## Stage packet table

| Stage | Required packet | Pass condition |
|---|---|---|
| Critical | `intentPacket`, `taskClassification` | outcome, success criteria, non-goals, permissions, blocking unknowns recorded |
| Fetch | `fetchPacket`, `foundationalCapabilityPreservationPacket`, `dependencyCapabilityAuditPacket`, `fileChangeFactCard` when mutation is planned | evidence changes route/risk/owner/verification or records no-impact; planned file changes have purpose, consumer, overlap, data-shape, and user-instruction evidence |
| Thinking | `dispatchBoard`, `workerTaskPackets`, `routeScoreBreakdown` | selected route has owner + weapon + dependency policy + runtime + OS + verification owner; worker tasks bind target files to their consumer and delivery contract |
| Execution | `workerResultPackets`, `workerExecutionEvidence` | bounded tasks produce declared artifacts and evidence |
| Review | `reviewPacket.findings` | upstream Critical/Fetch/Thinking and output quality are reproducibly checked |
| Meta-Review | review-standard checks on `reviewPacket` | Review catches native/foundational/dependency/intent/public-ready/evolution risks |
| Verification | `verificationPacket`, `verificationEvidence` | fresh commands/logs/artifacts/human acceptance bind claims |
| Evolution | `evolutionWritebackPacket`, `scarPacket` | writeback or `none-with-reason` with next-run reuse key |

## Required Fetch config

Before Execution, inspect the relevant local source of truth:

- `config/runtime-capability-matrix.json` for Claude Code, Codex, Cursor, OpenClaw support.
- `config/os-compatibility-matrix.json` for macOS, Windows, Linux, WSL2 support.
- `config/capability-index/weapon-registry.json` for weapons.
- `config/capability-index/dependency-project-registry.json` and `.meta-kim/state/default/dependency-capability-index.json` for dependencies.
- `config/skills.json`, runtime projections, MCP configs, hooks, package scripts, Graphify, Memory, and repository search for foundational capabilities.

## Project fit and creator handoff

Before each task, the host's Fetch/Thinking reads the target project's verified constraints, relevant same-project review/failure evidence and the current method source/version, then chooses reuse, project adaptation or creation. A task-only/default-global Node decision is not a project-fit assessment. Use `references/evolution-writeback.md` for the distinct repeat-failure, pattern-reuse and explicit-learning triggers. Bind sources through existing worker `evidenceRefs`, `referenceDirection` and `handoffContract`; the receiving owner reports what was actually read, which action changed and what result was observed.

Skill creation, refactoring and review apply the discovered `meta-skill-creator` core contract; official `skill-creator`, the Agent factory and team playbook are not substitutes. New Agent identity retains Type B. Load `references/create-agent.md` for the reviewed `creationArtifact` handoff: missing creator output, provenance or content-bound approval returns a factory next step without writing a placeholder. A copied global package is adaptation preparation; file materialization proves neither method improvement nor native invocation.

## Abstract foundational capability triggers

Do not narrow Meta_Kim to a few named skills. Treat named packages such as `findskill`, `hookprompt`, `planning-with-files`, and `meta-skill-creator` as examples inside a wider abstract capability surface described by `config/contracts/prompt-abstract-capability-contract.json`.

Hardcode capability families and conflict rules in prompts; discover concrete providers at run time:

| Capability family | Trigger in the prompt | Conflict boundary |
|---|---|---|
| `governance-orchestration` | Durable planning, governance, review, verification, prioritization, repair, runtime, or release work | Governance agents route and review; they do not become generic implementation workers. |
| `capability-discovery-and-retrieval` | Owner, tool, dependency, current fact, provider, or verification path affects the route | First-party capability search, `findskill` when installed and appropriate, and relevant external search are run-scoped Fetch inputs, not permanent agent identity bindings. |
| `prompt-intake-optimization` | User prompt submission or prompt optimization request | `hookprompt` may add prompt context and, when the runtime emits a mandatory foreground prompt-understanding block, that block must be rendered before Meta_Kim route notices or native choice surfaces. It is prompt-intake context only and must not override user intent, PRD decisions, meta-theory route, planning state, later progress notices, active-run state, Fetch records, Thinking packets, workerTaskPackets, execution evidence, verification evidence, or public-ready claims. |
| `planning-continuity` | Non-query durable work needs resume, progress, evidence, route, or acceptance continuity | Planning files are update-only continuity state: append, refine, or mark superseded; do not overwrite or reset `task_plan.md`, `findings.md`, or `progress.md`. Host task/todo boards must not be the first Fetch action; use visible chat status plus evidence reads before task bookkeeping. |
| `skill-agent-tool-creation` | Fetch proves a reusable capability gap after existing providers are checked | Skill authoring uses `meta-skill-creator`; Agent identity uses Type B. Creation needs a real reviewed prepared source, provenance and content-bound approval after gap proof. |
| `runtime-native-surfaces` | Runtime-facing route, projection, hook, command, skill, agent, MCP, choice, sandbox, or approval behavior | Preserve native, partial, unknown, and blocked states; do not fake or replace runtime-native abilities. |
| `execution-tools-and-commands` | Real execution, file edits, browser/UI proof, command output, or validator/test evidence is needed | Select tools by owner, permission, runtime, OS, and verification; command pass is evidence, not user-goal completion. |
| `mcp-external-provider-and-plugin` | External data, external tool, provider SDK, plugin, connector, dependency, or MCP affects the route | Configured or installed providers are not live proof; external writes, credentials, paid actions, and mutations need approval and verification. |
| `memory-graph-and-observability` | Prior decisions, project map, graph freshness, run state, trace, or evidence continuity affects route or acceptance | Memory and graph guide navigation; verify route-changing claims against source files or fresh artifacts. |
| `safety-hooks-and-permissions` | Unsafe mutation, missing dispatch evidence, hook loop, install/update, sandbox, approval, or credential risk appears | Hooks are last-resort fuses, not planners; repeated blocks return to the responsible stage. |
| `verification-eval-and-release` | A prompt, route, runtime, release, or user goal is claimed complete | Do not relabel smoke, config validation, skipped, needsAuth, or old artifacts as live/release-grade proof. |
| `user-interaction-and-i18n` | Route-changing ambiguity, user choice, progress notice, or output-language handling is visible | Ask only route-changing questions and preserve locale; renderer schemas stay in runtime adapters. |

## Native ability preservation

For delegation, parent returns, worker recovery and fresh Live work consumption, load [native-host-interaction.md](references/native-host-interaction.md). Use the installed host's actual tools and limits; a child that cannot delegate returns bounded work to its native parent. A second client is not a prerequisite, and a stopped or user-paused host is not automatically restarted.

Governance may add trigger, evidence, trust review, approval, sandbox, fallback, verification, and risk boundaries. It must not delete, downgrade, or replace runtime-native abilities for Claude Code, Codex, Cursor, or OpenClaw. Unknown or partial native abilities stay `unknown` or `partial` until verified; they are not removed.

Provider-registry truth has four separate layers. `providers[*].support` is the only durable runtime-claim authority, while `runtimeAdapters` is a mechanically checked projection of it. Provider selection is run-scoped and must never be persisted as a registry fact. Availability comes only from the target runtime's support state and install-layer evidence; a projection file does not prove availability. Native support belongs only to a provider's declared target runtime, and live execution requires a fresh verification artifact. Runtime-specific providers must be `blocked` with `unsupported` layers and no activation event on every non-target runtime; never copy a Claude, Codex, Cursor, or OpenClaw trigger or `verified` label across runtimes.

## Foundational capability preservation

Do not delete or hide existing Skills, WebSearch, web search, browser, online research, fetch, filesystem, shell, command, apply_patch, edit, MCP, memory, Graphify, graph, hooks, scripts, validators, commands, rules, agents, subagents, approval, sandbox, permission mode, runtime tools, setup, uninstall, status, doctor, sync, install, or verification capability. If a capability is risky or unavailable, mark `needs_probe`, `unknown`, `partial`, `requires_approval`, `requires_trust_review`, `reference_only`, or `not_for_execution_route`.

## Dependency compatibility

Dependencies are retained and routed by state, not deleted by score.

- Unsupported, reference-only or missing required capability evidence remains blocked or needs a probe; a high score cannot make it executable.
- A selected dependency needs its actual invocation path, verified source, required inputs, supported runtime/OS, owner, allowed tools and verification path.
- Retained provider-fit score bands are diagnostics, not measured design quality and not an independent approval protocol. Ask users only when the choice changes the delivered result, maintenance/resource commitment or authorization; internal owner/tool selection remains the host's responsibility.

`Kim_Decision` is a decision protocol candidate, not a code executor. Discover it through `META_KIM_DEP_ROOTS`, sibling repo scan, installed skill paths, registry, or external reference. Never hardcode a personal path. Valid states: `local_inspected_protocol`, `installed_skill_candidate`, `external_reference`, `internalized_pattern`, `blocked`, `not_for_code_execution`, `eligible_for_decision_route`, `needs_probe`.

## Execution gate

Execution may start only when the key behavior gate is true (or degraded mode is explicitly active with recorded degradation reason). Hooks enforce this minimum; fuller packet shape is validated by validators and Review:

- `realIntent`, success criteria, non-goals, and blocking unknowns are recorded.
- Fetch evidence and capability discovery are complete enough for the chosen path.
- Existing-owner discovery has checked enough available agents, skills, commands, MCP tools, runtime tools, and prompt/rule providers to justify the selected owner/loadout; skipped sources appear as blockers or no-impact evidence.
- Current evidence establishes capability fit and the allowed execution/verification route. Provider-fit scores cannot replace missing facts, create material product choices or relax permissions; an internal single-path selection may record `no_branching_choice`.
- Owner is not `general-purpose`, not a runtime alias, and not a governance agent acting as implementation worker.
- Owner has a usable loadout: skill, command, MCP capability, runtime tool, normal tool, or abstract prompt.
- Runtime/OS support is not known-unsupported; unknown or partial support is recorded with a probe/degraded route.
- Memory strategy exists (`project_only`, `cross_project_readonly`, `none-with-reason`, or equivalent).
- For file mutation, the current content of every target file has been read in the same execution turn before editing, and `fileChangeFactCard` exists with each target file's consumer/distribution path, overlap decision, and data-shape note when applicable.
- Review standard is known. Verification owner, rollback, dependency eligibility, and detailed packet fields are required for public-ready, not as universal hook blockers.

Worker output schema validation: when `workerTaskPacket.output` defines an expected structure, the dispatcher (or receiving agent) must validate the worker result against that structure before accepting it. On mismatch, the worker retries (up to 2 attempts) before reporting failure. Record `workerResultPacket.schemaValidationAttempts = [{attempt, passed, violationDetail}]`. This prevents format drift between Thinking's output contract and Execution's actual return.

## Review gate

Review must check upstream chain before output polish:

- Critical locked the right user outcome and success criteria.
- Fetch evidence changed or justified the route.
- Thinking selected owner + weapon + dependency + runtime + OS + verification.
- Planned file changes were preceded by reading the target files and justified by `fileChangeFactCard`; no new file exists only because the worker found a convenient place to write.
- Execution evidence is reproducible.
- No foundational capability or runtime-native ability was deleted or downgraded.
- No reference-only dependency entered execution.

Adversarial verify pattern: when Review runs for `regulated_path` or when the user requests cross-check, spawn N independent skeptic reviewers (default N=3). Each skeptic receives a different lens (correctness, security, completeness) and must explicitly try to refute each finding. A finding survives only if a majority (>= ceil(N/2) refutations fail). Record per-finding vote tallies in `reviewPacket.findings[].adversarialVotes = [{lens, verdict, refutationEvidence}]`. In degraded mode, the main thread applies the same checklist with `degradedFlag: true` and records self-assessment as one vote (not a majority).

## Verification gate

### Installed-user compatibility invariant

For every bug fix or feature involving install, update, sync, cleanup, runtime
homes, dependencies, startup registration, manifests, or generated config,
Verification must cover the applicable state matrix: fresh install, existing
same-version reinstall, historical-version update, partial/failed-install
residue, and user-modified drift. A fresh-install pass alone never proves the
change safe for existing users.

When a bug can already exist on installed machines, the normal public
install/update route must perform a bounded automatic migration. Maintainer-only
cleanup, one-off support commands, and instructions that make each user edit
local files do not count as a product fix. Migration may act only on exact
manifest ownership, exact signatures, closed-set fingerprints, or strict
historical classifiers. Unknown or modified state is preserved and reported as
a collision. Release evidence must bind a real prior packed version or exact
historical fixture to the packed public CLI and prove rollback or preservation.

Do not claim verified unless a command, log, artifact, or human acceptance record supports the claim. Command pass is not `userGoalDone`. Template validation is not strict run validation.

Runtime-live and `live-certified` evidence are stricter than structural checks; smoke, config validation, UI/systemMessage output, auth-present checks, and skipped/needsAuth states cannot be relabeled as live pass. Routine low-risk releases may ship after the smoke path, and standard releases may ship after a complete passing `meta:verify:all`. Only the optional `live-certified` label waits for the private-attested exact-binding evidence chain in `verification-evidence.md`.

## Evolution gate

Every run still records `writebackDecision = writeback` or `none-with-reason`, but Evolution is removed from the default execution scaffold. When no reusable capability gap, repeated failure scar, agent/skill/tool/MCP/hook/workflow/runtime/OS lesson, governance-contract change, or explicit durable-learning request exists, close inline with `none-with-reason` and do not dispatch Chrysalis or candidate-analysis lanes. Durable failures still require a scar with `failurePattern`, `preventionRule`, `test`, and `nextRunReuseKey`. Triggered Evolution writeback needs Warden approval; Chrysalis coordinates; target owners update their own sources.

## Reference loading

Load only references needed for the run:

- `path-selection.md`: route scoring and path bands.
- `owner-resolution.md`: owner + weapon + dependency route.
- `runtime-codex.md`: Codex-specific sandbox, approval, subagent, hook, and choice behavior.
- `runtime-claude.md`: Claude Code-specific native question surface, Agent / Skill / Command / prompt / MCP dispatch, and no-self-execution behavior.
- `verification-evidence.md`: verified claim and public-ready evidence.
- `intent-amplification.md`: real intent, first action, pass/kill, userGoalDone.
- `cross-agent-thinking-patterns.md`: choose optional, transferable reasoning, evidence, strategy or practice-feedback methods for any domain Agent; use discovered provider contracts without creating another route or task state.
- `evolution-writeback.md`: writeback, scars, reuse keys.
- `rhythm-orchestration.md`: choice/card timing.
- `native-host-interaction.md`: current-host work consumption, native parent/child returns and supported resumption.
- `planning-files.md`: `task_plan.md`, `findings.md`, `progress.md`.
- `create-agent.md`: new/changed owner design.
- `spine-state.md`: stage state and packet transitions.
- `dev-governance.md`: full-flow compact index.
- `ten-step-governance.md`: business workflow compatibility.
- `meta-theory.md`: background only; do not load as execution contract unless theory terms are disputed.

## User-facing compact output rule
Use the user's language. For Chinese input, output Chinese stage summaries. Each visible stage summary should use at most three information blocks unless final reporting requires more. A block may contain nested details so the chat still covers progress, current work, owner/capability, result, risk/blocker, verification, and next action; users are not expected to inspect generated files for essential guidance.

## No fake owner
Reject `general-purpose`, temporary fallback, runtime nickname, missing owner, or governance agent as implementation worker. Return to Thinking with a `capabilityGapPacket`.

## No general-purpose fallback

Compatibility fallback may preserve runtime usability. Governance fallback may not hide missing intent, owner, weapon, dependency, evidence, or verification. Missing governance readiness blocks or returns to the responsible stage.

## No public-ready without userGoalDone

`public-ready` requires `userGoalDone = true`, current outcome verification and intent acceptance, no unresolved high/critical findings, closed deliverable/summary bindings and a writeback decision. Legacy `intentAmplificationScore` or `publicReadyScore` values are diagnostic compatibility data; a fixed score or complete fields cannot establish design quality or compensate for failed outcomes.

## No deletion of foundational capabilities

Prompt cleanup may delete vague language only. It may not remove Skills, WebSearch, browser, research, filesystem, shell, apply_patch, MCP, memory, graph, Graphify, hooks, scripts, commands, runtime tools, validators, setup, sync, install, uninstall, or projections.

## No removal of runtime native abilities

Meta_Kim adds boundaries around Claude Code, Codex, Cursor, and OpenClaw native abilities. It must not replace native UI, approval, sandbox, hooks, skills, agents, commands, MCP, or rules with fake Meta_Kim equivalents.

## No dependency deletion due to low score

Low-score, unknown, partial, uninstalled, external, high-risk, or reference-only dependencies stay registered. They may be blocked from execution, marked for probe, downgraded to evidence/reference, or assigned upgrade suggestions.

## No Hook loop

Hooks are last-resort fuses, not the main governance engine. Governed Agent dispatch and public-ready claims must pass the key behavior preflight: intent, evidence, capability discovery, runtime/OS not known-unsupported, owner, owner loadout across skill/command/MCP/tool/prompt, memory strategy, and Review standard. Ordinary local edits and commands do not wait for that proof. Detailed dependency eligibility, rollback, verification owner, warning classification, and writeback reservation are validator/public-ready gates unless their absence makes execution unsafe. A Hook block must include `returnToStage`, `repairOwner`, `repairAction`, `allowedNextAction`, and `forbiddenRetry`. The same Hook reason may block once; the second same-reason block enters `hookRepairMode`; a third same-hook block stops Execution and creates `hookFailurePacket`. Never retry the same blocked action unchanged.
Hooks must not duplicate generic keyword safety gates or turn stage progress into a local file/command permission system. User-explicit local execution stays runtime-native in observed and managed modes, including ordinary edits, tests, Git, delete/cleanup, install, publish, GitHub Release, and GitHub API writes. `enforce-agent-dispatch` may block an Agent dispatch when governed owner/capability/choice evidence is missing, a meta-agent attempts direct execution, or an explicit read-only `queryBypass` run attempts mutation; it must not block or warn on ordinary project edits or local commands because Critical, Fetch, Thinking, Review, Verification, or Evolution evidence is incomplete. Review and Verification judge release truth, rollback evidence, policy adherence, and public-ready claims.
## Same-Type Failure Design Gate

This gate applies beyond hooks. If the same failure class appears for the second time in one goal or acceptance run, treat it as `bottom_design_failure`, not as another local patch opportunity. Return to Critical, Fetch, or Thinking and change the underlying goal contract, route design, evidence path, owner/loadout choice, runtime adapter, or verification gate before retrying.

Failure classes include missing native choice surface before Execution, fixture-specific hardcoding, validator rescue after a weak route, verification pass without runtime evidence, repeated hook reason, and repeated user correction about the same target. A fix must change the design or evidence route and add a regression test or scar. Do not rerun the same action, prompt, fixture, or local edit unchanged after the second same-class failure.

## Degraded Mode

When Agent dispatch is unavailable or no matching owner exists after capability discovery, the spine enters degraded mode instead of silently skipping stages.

Required actions:
- Record `capabilityGapPacket` with `currentAgentsChecked` and `currentProvidersChecked`.
- Record `degradationReason`: `tool_limitation`, `no_matching_owner`, or `permission_blocked`.
- Set `publicReadinessState` or the summary/public surface packet state to `internal-ready`; keep runtime `surfaceState` at `notice` or `silent`; never claim `public-ready` in degraded mode.
- Log which spine stages execute in degraded mode vs fully executed.
- Review and Verification stages: read the relevant meta-agent definition for criteria, apply the same checklist, and record `degradedFlag: true` with `reviewerRole: "main-thread-degraded"`.
- Verification: add `humanAcceptanceRequired: true` when no independent verification owner exists.

Forbidden:
- Silently skip any stage.
- Claim `public-ready` while in degraded mode.
- Self-execute when Thinking assigned a different owner (unless degraded mode explicitly overrides and records the override reason).

## Real testing and warning classification

Script validation is necessary but not sufficient. Public-ready requires real route fixtures, strict run artifact validation, dependency discovery output, runtime/OS probe output, and warning review. Warnings must be classified as `BLOCKING_WARNING`, `FIXABLE_WARNING`, `ENVIRONMENT_WARNING`, `EXPECTED_WARNING`, `DEPRECATED_WARNING`, or `NOISE_WARNING`. Unclassified warnings, unresolved Hook blocks, unresolved high/critical findings, missing verification evidence, or missing `userGoalDone` keep `publicReady=false`.