morphisms 0.1.0-beta.1

package/templates/agent/skills/morphisms/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: morphisms
+description: Run Morphisms starter issue workflows from an agent session. Use when the user asks to start Morphisms onboarding, orchestrate Morphisms issues, or move records through the starter issues front-half contract.
+---
+
+# Morphisms starter issue loop
+
+You are the orchestrator. Keep this session focused on coordination; delegate one worker per actionable record when your harness supports delegation.
+
+## Orient first
+
+1. Run `mor agent instructions` and read the S1/S2/S3 paths it reports. If you need the fully rendered prompt, run `mor agent instructions preview`.
+2. Open Workbench at `http://localhost:4400/#workbench` unless local init printed a different port. Use Workbench, not legacy graph routes.
+3. If you are inside a MOR Workbench thread capsule, narrate with `mor-thread reply` and propose viewer movement with `mor-thread suggest`; otherwise narrate in the current agent conversation and include the Workbench deep-link.
+
+## Frontier
+
+Use the active starter store alias `issue`:
+
+```bash
+mor issue ls
+```
+
+For each non-terminal, non-human-only record, hydrate the exact current node before doing anything:
+
+```bash
+mor issue hydrate ISS0001 journey.triage
+mor issue inspect ISS0001 --packet journey.triage --inline-persona
+```
+
+The packet is the authority: persona, context, legal moves, required witnesses, and refusal diagnostics beat memory or guesses.
+
+## Delegation policy
+
+- Start **one fresh worker per actionable record**. Parallel workers are allowed when your harness supports them; each gets a hydration command, target node, and the exact artifact/edge it may attempt.
+- Do not let workers invent hidden phases. One worker produces evidence for one current node, attaches it, attempts at most one edge, verifies the new state, and reports back.
+- `attention.awaiting_operator` is human-only. Do not spawn an autonomous worker for it; summarize the ambiguity and wait for the operator decision artifact.
+
+## Worker brief template
+
+Give each worker a brief like:
+
+```text
+You are working one Morphisms node turn for issue ISS0001.
+Run: mor issue hydrate ISS0001 journey.investigating
+Use the packet/persona as authority. Produce a real investigation_report with file:line citations, attach it with mor issue enrich, then attempt only journey.submit_standard_investigation. If MOR refuses, report the refusal and do not work around it.
+```
+
+## Evidence and movement
+
+Attach typed artifacts before walking evidence-gated edges:
+
+```bash
+mor issue enrich ISS0001 triage_decision --role triage_decision --payload /tmp/triage.json
+mor issue walk ISS0001 journey.choose_standard_investigation
+mor issue enrich ISS0001 investigation_report --role investigation_report --payload /tmp/investigation.json
+mor issue walk ISS0001 journey.submit_standard_investigation
+mor issue enrich ISS0001 scoped_plan --role scoped_plan --payload /tmp/scoped-plan.json
+mor issue walk ISS0001 journey.complete_scoped_plan
+```
+
+A refusal is a success signal from the runtime, not a CLI problem. Read the diagnostic, attach the missing witness or choose the correct edge, then retry only when the packet supports it.
+
+## Starter issue vocabulary
+
+- Store: `issues`, alias `issue`, record ids `ISS0001`, `ISS0002`, ...
+- Dimensions:
+  - `journey`: `triage` -> `investigating` -> `scoping` -> `plan_review` -> `done`
+  - `attention`: `autonomous_entry` -> `autonomous` <-> `awaiting_operator`
+- Human-only node: `attention.awaiting_operator`
+- Artifacts: `triage_decision`, `investigation_report`, `scoped_plan`, `plan_review`, `operator_decision`
+- Common edges:
+  - `journey.choose_quick_scope`, `journey.choose_standard_investigation`, `journey.choose_rigorous_investigation`
+  - `journey.close_discarded_from_triage`, `journey.close_duplicate_from_triage`
+  - `journey.submit_standard_investigation`, `journey.submit_rigorous_investigation`
+  - `journey.complete_scoped_plan`, `journey.close_blocked_from_scoping`
+  - `journey.submit_rigorous_plan_review`, `journey.revise_rigorous_plan`, `journey.approve_rigorous_plan`
+  - `attention.start_autonomous`, `attention.request_operator_from_entry`, `attention.request_operator`, `attention.return_to_autonomous`
+
+## Concierge trigger
+
+If `.mor/onboarding-complete` is missing, follow the S3 concierge onboarding section before normal orchestration. At the end, write one line to `.mor/onboarding-complete`:
+
+```text
+<ISO-8601 date> <first issue id>
+```

package/templates/claude/skills/morphisms/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: morphisms
+description: Run Morphisms starter issue workflows from Claude Code. Use when the user says to start Morphisms onboarding, orchestrate Morphisms issues, or move records through the starter issues front-half contract.
+---
+
+# Morphisms starter issue loop
+
+You are the orchestrator. Keep this Claude Code session focused on coordination; spawn one subagent per actionable record and let each worker handle exactly one node turn.
+
+## Orient first
+
+1. Run `mor agent instructions` and read the S1/S2/S3 paths it reports. If you need the fully rendered prompt, run `mor agent instructions preview`.
+2. Open Workbench at `http://localhost:4400/#workbench` unless local init printed a different port. Use Workbench, not legacy graph routes.
+3. If you are inside a MOR Workbench thread capsule, narrate with `mor-thread reply` and propose viewer movement with `mor-thread suggest`; otherwise narrate in the current Claude conversation and include the Workbench deep-link.
+
+## Frontier
+
+Use the active starter store alias `issue`:
+
+```bash
+mor issue ls
+```
+
+For each non-terminal, non-human-only record, hydrate the exact current node before doing anything:
+
+```bash
+mor issue hydrate ISS0001 journey.triage
+mor issue inspect ISS0001 --packet journey.triage --inline-persona
+```
+
+The packet is the authority: persona, context, legal moves, required witnesses, and refusal diagnostics beat memory or guesses.
+
+## Spawn policy
+
+- Spawn **one Claude Code subagent per actionable record**. Parallel subagents are allowed; each receives a hydration command, the target node, and the exact artifact/edge it may attempt.
+- Do not let workers invent hidden phases. One worker produces evidence for one current node, attaches it, attempts at most one edge, verifies the new state, and reports back.
+- `attention.awaiting_operator` is human-only. Do not spawn an autonomous worker for it; summarize the ambiguity and wait for the operator decision artifact.
+
+## Worker brief template
+
+Give each worker a brief like:
+
+```text
+You are working one Morphisms node turn for issue ISS0001.
+Run: mor issue hydrate ISS0001 journey.investigating
+Use the packet/persona as authority. Produce a real investigation_report with file:line citations, attach it with mor issue enrich, then attempt only journey.submit_standard_investigation. If MOR refuses, report the refusal and do not work around it.
+```
+
+## Evidence and movement
+
+Attach typed artifacts before walking evidence-gated edges:
+
+```bash
+mor issue enrich ISS0001 triage_decision --role triage_decision --payload /tmp/triage.json
+mor issue walk ISS0001 journey.choose_standard_investigation
+mor issue enrich ISS0001 investigation_report --role investigation_report --payload /tmp/investigation.json
+mor issue walk ISS0001 journey.submit_standard_investigation
+mor issue enrich ISS0001 scoped_plan --role scoped_plan --payload /tmp/scoped-plan.json
+mor issue walk ISS0001 journey.complete_scoped_plan
+```
+
+A refusal is a success signal from the runtime, not a CLI problem. Read the diagnostic, attach the missing witness or choose the correct edge, then retry only when the packet supports it.
+
+## Starter issue vocabulary
+
+- Store: `issues`, alias `issue`, record ids `ISS0001`, `ISS0002`, ...
+- Dimensions:
+  - `journey`: `triage` -> `investigating` -> `scoping` -> `plan_review` -> `done`
+  - `attention`: `autonomous_entry` -> `autonomous` <-> `awaiting_operator`
+- Human-only node: `attention.awaiting_operator`
+- Artifacts: `triage_decision`, `investigation_report`, `scoped_plan`, `plan_review`, `operator_decision`
+- Common edges:
+  - `journey.choose_quick_scope`, `journey.choose_standard_investigation`, `journey.choose_rigorous_investigation`
+  - `journey.close_discarded_from_triage`, `journey.close_duplicate_from_triage`
+  - `journey.submit_standard_investigation`, `journey.submit_rigorous_investigation`
+  - `journey.complete_scoped_plan`, `journey.close_blocked_from_scoping`
+  - `journey.submit_rigorous_plan_review`, `journey.revise_rigorous_plan`, `journey.approve_rigorous_plan`
+  - `attention.start_autonomous`, `attention.request_operator_from_entry`, `attention.request_operator`, `attention.return_to_autonomous`
+
+## Concierge trigger
+
+If `.mor/onboarding-complete` is missing, follow the S3 concierge onboarding section before normal orchestration. At the end, write one line to `.mor/onboarding-complete`:
+
+```text
+<ISO-8601 date> <first issue id>
+```

package/templates/contract/README.md

@@ -0,0 +1,57 @@
+# Starter issues front-half contract
+
+This is the default Morphisms starter contract for new users. It captures an `issues` store and moves each issue through the front half of work: triage, optional investigation, scoping, optional review, and a single terminal `done` state.
+
+The contract intentionally stops before execution. It produces ready `scoped_plan` evidence and a pasteable `handoff_prompt`; it does not create tasks, branches, worktrees, or execution records.
+
+## Store
+
+- Store: `issues` (CLI alias `issue`)
+- Required fields: `title`, `kind`, `summary`
+- `kind`: `bug | idea | feature`
+
+## Journey lanes
+
+All lanes share the same `journey` dimension and states rather than using parallel lane dimensions.
+
+- **Quick:** `triage -> scoping -> done`
+  - Use when triage can choose `quick` because the issue is already clear enough to scope.
+- **Standard:** `triage -> investigating -> scoping -> done`
+  - Use when one evidence-gathering investigation is needed before scoping.
+- **Rigorous:** `triage -> investigating -> scoping -> plan_review -> done`, with `plan_review -> scoping` on revise.
+  - Use when a plan should be explicitly reviewed before becoming ready.
+
+The single terminal state is `done`. Terminal means the record's journey in this dimension is complete, not that the work succeeded. Typed outcomes live on the closing artifact:
+
+- `triage_decision.closing_outcome`: `discarded | duplicate`
+- `scoped_plan.plan_outcome`: `ready_for_execution | blocked`
+- `plan_review.review_outcome`: `ready_for_execution`
+
+## Evidence gates
+
+- `triage_decision`: chooses `quick`, `standard`, `rigorous`, `discard`, or `duplicate`.
+- `investigation_report`: required for investigated lanes; schema requires a non-empty `citations` array with `file`, `line`, `excerpt`, and `why_it_matters`.
+- `scoped_plan`: contains `plan_round`, `problem`, `evidence`, `approach`, `acceptance_criteria`, `handoff_prompt`, and `plan_outcome`.
+- `plan_review`: rigorous lane only; includes `review_round` and `reviewed_plan_round`; `PASS` closes, `REVISE` returns to scoping.
+
+Rigorous review freshness uses the generic `latest_attachment_after_edge` precondition. After `revise_rigorous_plan`, the next `submit_rigorous_plan_review` requires a scoped plan attached after that REVISE. `revise_rigorous_plan` and `approve_rigorous_plan` require a plan review attached after the current `submit_rigorous_plan_review`. The round fields make the human-readable loop explicit; the runtime enforces attachment freshness.
+
+## Provisional operator routing
+
+A second dimension, `attention`, models v0 operator routing on the same store:
+
+```text
+autonomous_entry -> autonomous -> awaiting_operator -> autonomous
+                 \-> awaiting_operator
+```
+
+The compiled contract includes an entry-only bootstrap state, `autonomous_entry`, because Morphisms initial states cannot be targeted by return edges. A new record has two legal first attention moves:
+
+- `attention.start_autonomous` when no operator input is needed.
+- `attention.request_operator_from_entry` when first triage immediately needs the operator.
+
+After that, the operative loop is `autonomous -> awaiting_operator -> autonomous` via `attention.request_operator` and `attention.return_to_autonomous`.
+
+The out-edge from `awaiting_operator` requires an `operator_decision` artifact. To keep first-time semantics simple, `operator_decision.decision` is limited to values coherent with returning to autonomous work: `resume | revise_scope`. Abandon/discard/duplicate/block outcomes belong on journey artifacts (`triage_decision` or `scoped_plan`), not on the attention dimension.
+
+This mechanism is **PROVISIONAL**: the longer-term cross-store operator queue / W3 actor-states design question is still open, so downstream code and docs should treat this as swappable.

package/templates/contract/contract.mor

@@ -0,0 +1,247 @@
+distro starter_issues_front_half version v1
+
+store issues {
+  alias issue
+  identity prefix "ISS" width 4
+  storage table "starter_issues_front_half_issues"
+  field title: text required patchable(false)
+  field kind: enum [bug, idea, feature] required patchable(false)
+  field summary: text required patchable
+  field reporter_context: text patchable default("")
+  field source_anchor: text patchable default("")
+  field priority: enum [low, medium, high] patchable default(medium)
+  field triage_decision_ref: artifact_ref patchable(false) managed(artifact_cache_ref)
+  field investigation_report_ref: artifact_ref patchable(false) managed(artifact_cache_ref)
+  field scoped_plan_ref: artifact_ref patchable(false) managed(artifact_cache_ref)
+  field plan_review_ref: artifact_ref patchable(false) managed(artifact_cache_ref)
+  field operator_decision_ref: artifact_ref patchable(false) managed(artifact_cache_ref)
+
+  artifact triage_decision {
+    schema "schemas/triage-decision.schema.json"
+    allowed_in journey.triage
+    attach role triage_decision cardinality many
+    cache latest_ref triage_decision_ref
+  }
+
+  artifact investigation_report {
+    schema "schemas/investigation-report.schema.json"
+    allowed_in journey.investigating
+    attach role investigation_report cardinality many
+    cache latest_ref investigation_report_ref
+  }
+
+  artifact scoped_plan {
+    schema "schemas/scoped-plan.schema.json"
+    allowed_in journey.scoping
+    attach role scoped_plan cardinality many
+    cache latest_ref scoped_plan_ref
+  }
+
+  artifact plan_review {
+    schema "schemas/plan-review.schema.json"
+    allowed_in journey.plan_review
+    attach role plan_review cardinality many
+    cache latest_ref plan_review_ref
+  }
+
+  artifact operator_decision {
+    schema "schemas/operator-decision.schema.json"
+    allowed_in attention.awaiting_operator
+    attach role operator_decision cardinality many
+    cache latest_ref operator_decision_ref
+  }
+
+  dimension journey {
+    state_field journey_state
+
+    initial state triage
+    state investigating
+    state scoping
+    state plan_review
+    terminal state done
+    plateau rigorous_review_loop [scoping, plan_review]
+
+    edge choose_quick_scope: triage -> scoping {
+      doc "Choose the quick lane when the issue is already clear enough to scope."
+      when_to_use "Use only after a triage_decision whose decision is quick."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: quick)
+      }
+    }
+
+    edge choose_standard_investigation: triage -> investigating {
+      doc "Choose the standard lane when one investigation pass is needed before scoping."
+      when_to_use "Use only after a triage_decision whose decision is standard."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: standard)
+      }
+    }
+
+    edge choose_rigorous_investigation: triage -> investigating {
+      doc "Choose the rigorous lane when investigation plus plan review is warranted."
+      when_to_use "Use only after a triage_decision whose decision is rigorous."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: rigorous)
+      }
+    }
+
+    edge close_discarded_from_triage: triage -> done {
+      doc "Complete the journey at triage when the issue should be discarded."
+      when_to_use "Use only when the triage_decision records decision discard and closing_outcome discarded."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: discard)
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: closing_outcome, value: discarded)
+      }
+    }
+
+    edge close_duplicate_from_triage: triage -> done {
+      doc "Complete the journey at triage when the issue duplicates another known record."
+      when_to_use "Use only when the triage_decision records decision duplicate and closing_outcome duplicate."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: duplicate)
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: closing_outcome, value: duplicate)
+      }
+    }
+
+    edge submit_standard_investigation: investigating -> scoping {
+      doc "Finish standard-lane fact-finding and move to scoping."
+      when_to_use "Use after attaching an investigation_report with file/line citations."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: standard)
+        latest_attachment_exists(kind: investigation_report, role: investigation_report, latest: true)
+      }
+    }
+
+    edge submit_rigorous_investigation: investigating -> scoping {
+      doc "Finish rigorous-lane fact-finding and move to scoping before review."
+      when_to_use "Use after attaching an investigation_report with file/line citations."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: rigorous)
+        latest_attachment_exists(kind: investigation_report, role: investigation_report, latest: true)
+      }
+    }
+
+    edge complete_scoped_plan: scoping -> done {
+      doc "Complete quick or standard lane with a ready scoped plan."
+      when_to_use "Use for quick or standard lanes after scoped_plan has outcome ready_for_execution."
+      requires all {
+        artifact_field_equals(kind: scoped_plan, role: scoped_plan, latest: true, field: plan_outcome, value: ready_for_execution)
+        any {
+          artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: quick)
+          artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: standard)
+        }
+      }
+    }
+
+    edge close_blocked_from_scoping: scoping -> done {
+      doc "Complete any lane as blocked when scoping exposes a blocker instead of an executable plan."
+      when_to_use "Use after scoped_plan records plan_outcome blocked and explains the blocker."
+      requires all {
+        artifact_field_equals(kind: scoped_plan, role: scoped_plan, latest: true, field: plan_outcome, value: blocked)
+      }
+    }
+
+    edge submit_rigorous_plan_review: scoping -> plan_review {
+      doc "Send a rigorous-lane scoped plan to explicit plan review."
+      when_to_use "Use only for rigorous lane after investigation and a ready scoped_plan are attached."
+      requires all {
+        artifact_field_equals(kind: triage_decision, role: triage_decision, latest: true, field: decision, value: rigorous)
+        latest_attachment_exists(kind: investigation_report, role: investigation_report, latest: true)
+        artifact_field_equals(kind: scoped_plan, role: scoped_plan, latest: true, field: plan_outcome, value: ready_for_execution)
+        latest_attachment_after_edge(kind: scoped_plan, role: scoped_plan, edge: "journey.revise_rigorous_plan")
+      }
+    }
+
+    edge revise_rigorous_plan: plan_review -> scoping {
+      doc "Return rigorous work to scoping when a fresh plan review asks for revision."
+      when_to_use "Use when the latest plan_review gate is REVISE and that review was attached after this review round began."
+      requires all {
+        artifact_field_equals(kind: plan_review, role: plan_review, latest: true, field: gate, value: REVISE)
+        latest_attachment_after_edge(kind: plan_review, role: plan_review, edge: "journey.submit_rigorous_plan_review", edge_required: true)
+      }
+    }
+
+    edge approve_rigorous_plan: plan_review -> done {
+      doc "Complete rigorous lane after a fresh plan review passes the scoped plan."
+      when_to_use "Use when the latest plan_review gate is PASS, review_outcome is ready_for_execution, and the review was attached after this review round began."
+      requires all {
+        artifact_field_equals(kind: plan_review, role: plan_review, latest: true, field: gate, value: PASS)
+        artifact_field_equals(kind: plan_review, role: plan_review, latest: true, field: review_outcome, value: ready_for_execution)
+        latest_attachment_after_edge(kind: plan_review, role: plan_review, edge: "journey.submit_rigorous_plan_review", edge_required: true)
+      }
+    }
+  }
+
+  dimension attention {
+    state_field attention_state
+
+    initial state autonomous_entry
+    state autonomous
+    state awaiting_operator
+    plateau operator_loop [autonomous, awaiting_operator]
+
+    edge start_autonomous: autonomous_entry -> autonomous {
+      doc "Enter the normal autonomous attention state after record creation."
+      when_to_use "Use once after add; the explicit entry state keeps the loop from targeting the compiler's entry-only initial state."
+    }
+
+    edge request_operator_from_entry: autonomous_entry -> awaiting_operator {
+      doc "Pause immediately after record creation when first triage needs the human operator."
+      when_to_use "Use for product-owner ambiguity before attention.start_autonomous has been walked."
+    }
+
+    edge request_operator: autonomous -> awaiting_operator {
+      doc "Pause autonomous work when product-owner ambiguity needs the human operator."
+      when_to_use "Use sparingly for genuine ambiguity after the record is in attention.autonomous."
+    }
+
+    edge return_to_autonomous: awaiting_operator -> autonomous {
+      doc "Resume autonomous work after the operator answers or redirects."
+      when_to_use "Use only after attaching an operator_decision artifact."
+      requires all {
+        latest_attachment_exists(kind: operator_decision, role: operator_decision, latest: true)
+      }
+    }
+  }
+
+  profile journey.triage persona "personas/triager.md"
+  profile journey.investigating persona "personas/investigator.md"
+  profile journey.scoping persona "personas/scoper.md"
+  profile journey.plan_review persona "personas/plan-reviewer.md"
+  profile attention.awaiting_operator persona "personas/operator-facing-intake.md"
+
+  context journey.triage {
+    record(fields: [title, kind, summary, reporter_context, source_anchor, priority], as: issue)
+    artifacts(kind: triage_decision, role: triage_decision, latest: false, limit: 3, as: prior_triage_decisions)
+  }
+
+  context journey.investigating {
+    record(fields: [title, kind, summary, reporter_context, source_anchor, priority], as: issue)
+    artifacts(kind: triage_decision, role: triage_decision, latest: true, required: true, as: triage_decision)
+    artifacts(kind: investigation_report, role: investigation_report, latest: false, limit: 3, as: investigation_reports)
+  }
+
+  context journey.scoping {
+    record(fields: [title, kind, summary, reporter_context, source_anchor, priority], as: issue)
+    artifacts(kind: triage_decision, role: triage_decision, latest: true, required: true, as: triage_decision)
+    artifacts(kind: investigation_report, role: investigation_report, latest: true, as: investigation_report)
+    artifacts(kind: scoped_plan, role: scoped_plan, latest: false, limit: 3, as: scoped_plans)
+    artifacts(kind: plan_review, role: plan_review, latest: true, as: latest_plan_review)
+  }
+
+  context journey.plan_review {
+    record(fields: [title, kind, summary, reporter_context, source_anchor, priority], as: issue)
+    artifacts(kind: triage_decision, role: triage_decision, latest: true, required: true, as: triage_decision)
+    artifacts(kind: investigation_report, role: investigation_report, latest: true, required: true, as: investigation_report)
+    artifacts(kind: scoped_plan, role: scoped_plan, latest: true, required: true, as: scoped_plan)
+    artifacts(kind: plan_review, role: plan_review, latest: false, limit: 3, as: prior_plan_reviews)
+  }
+
+  context attention.awaiting_operator {
+    record(fields: [title, kind, summary, reporter_context, source_anchor, priority], as: issue)
+    artifacts(kind: triage_decision, role: triage_decision, latest: true, as: triage_decision)
+    artifacts(kind: investigation_report, role: investigation_report, latest: true, as: investigation_report)
+    artifacts(kind: scoped_plan, role: scoped_plan, latest: true, as: scoped_plan)
+    artifacts(kind: operator_decision, role: operator_decision, latest: false, limit: 3, as: operator_decisions)
+  }
+}

package/templates/contract/personas/investigator.md

@@ -0,0 +1,20 @@
+# Issue investigator persona
+
+You are a Claude Code agent operating from a hydrated Morphisms packet for `journey.investigating`.
+
+Goal: turn uncertainty into cited facts.
+
+Attention routing:
+- If the packet's `attention_state` is `autonomous_entry` and you need the operator, walk `attention.request_operator_from_entry`.
+- If it is `autonomous` and you need the operator, walk `attention.request_operator`.
+- Otherwise continue with the journey edge instructions.
+
+Checklist:
+- Inspect the codebase or repository evidence relevant to the issue.
+- Produce an `investigation_report` with at least one `citations` entry naming `file`, integer `line`, `excerpt`, and `why_it_matters`.
+- Prefer concrete file:line evidence over broad claims.
+- Record reproduction steps when applicable; say when reproduction is not available.
+- Walk the standard or rigorous investigation edge only after the report is attached and accepted.
+- Use operator routing only when the next choice depends on product-owner judgment rather than code facts.
+
+Do not implement fixes or materialize tasks.

package/templates/contract/personas/operator-facing-intake.md

@@ -0,0 +1,16 @@
+# Operator-facing intake persona
+
+You are a Claude Code agent handling `attention.awaiting_operator` for an issue record.
+
+Goal: present the smallest useful question to the human operator, then encode the answer.
+
+Checklist:
+- Summarize current issue state, latest artifacts, and the exact ambiguity.
+- Ask for a product-owner decision in plain language.
+- Attach an `operator_decision` artifact with `decision`, `rationale`, and any `instructions` or `answered_questions`.
+- Use only `decision: resume` or `decision: revise_scope`; both mean autonomous work should continue with the operator's guidance.
+- Walk `attention.return_to_autonomous` only after the artifact is accepted.
+- After returning to autonomous, continue using the journey-state persona and legal `mor` commands.
+- Do not encode abandon/discard/duplicate as operator decisions. If the operator answer means the journey should end, return to autonomous and attach the appropriate `triage_decision` or `scoped_plan` closing artifact on the journey dimension.
+
+This attention mechanism is v0-provisional and single-store. Do not depend on it as a permanent cross-record operator queue.

package/templates/contract/personas/plan-reviewer.md

@@ -0,0 +1,20 @@
+# Rigorous plan reviewer persona
+
+You are a Claude Code agent operating from a hydrated Morphisms packet for `journey.plan_review`.
+
+Goal: review whether the scoped plan is safe, evidenced, and executable.
+
+Attention routing:
+- If the packet's `attention_state` is `autonomous_entry` and you need the operator, walk `attention.request_operator_from_entry`.
+- If it is `autonomous` and you need the operator, walk `attention.request_operator`.
+
+Checklist:
+- Compare the `scoped_plan` to the triage decision and investigation report.
+- Attach a fresh `plan_review` after entering `plan_review`; stale reviews from prior rounds cannot legally drive PASS or REVISE.
+- Set `review_round` to the next review attempt number and `reviewed_plan_round` to the scoped plan's `plan_round`.
+- PASS only when the problem, evidence, approach, acceptance criteria, and handoff prompt are coherent enough for a future executor.
+- Attach `plan_review` with `gate: PASS` and `review_outcome: ready_for_execution` before walking `approve_rigorous_plan`.
+- Use `gate: REVISE` with concrete `required_changes` before walking `revise_rigorous_plan`.
+- Ask the operator only for genuine product ambiguity, not for routine review work.
+
+Do not execute the plan or spawn implementation tasks.

package/templates/contract/personas/scoper.md

@@ -0,0 +1,23 @@
+# Issue scoper persona
+
+You are a Claude Code agent operating from a hydrated Morphisms packet for `journey.scoping`.
+
+Goal: produce a scoped front-half output that another agent can execute later.
+
+Attention routing:
+- If the packet's `attention_state` is `autonomous_entry` and you need the operator, walk `attention.request_operator_from_entry`.
+- If it is `autonomous` and you need the operator, walk `attention.request_operator`.
+
+Attach a `scoped_plan` with:
+- `plan_round`: start at `1`; after a rigorous `plan_review` with `gate: REVISE`, attach a new scoped plan with the next round number.
+- `based_on_review_round`: set to the REVISE review round the new plan answers, when applicable.
+- `problem`: the precise user/codebase problem.
+- `evidence`: concise citations or facts from the record and investigation.
+- `approach`: implementation approach at planning depth, not code changes.
+- `acceptance_criteria`: testable bullets.
+- `handoff_prompt`: a pasteable prompt for a future execution agent.
+- `plan_outcome`: `ready_for_execution` or `blocked`.
+
+For quick and standard lanes, a ready or blocked scoped plan can close the journey. For rigorous lanes, submit ready plans to review. The runtime requires the scoped plan to be attached after the latest rigorous REVISE before re-entering review. If blocked, explain the blocker instead of inventing certainty.
+
+Do not create a task store entry or perform the implementation.

package/templates/contract/personas/triager.md

@@ -0,0 +1,22 @@
+# Issue triager persona
+
+You are a Claude Code agent operating from a `mor issue hydrate <id> journey.triage --inline-persona --json` packet.
+
+Goal: decide the smallest honest lane for this issue.
+
+Attention bootstrap:
+- Check the packet's `attention_state` before asking the operator.
+- If it is `autonomous_entry` and you need the operator now, walk `attention.request_operator_from_entry`.
+- If it is `autonomous` and you need the operator, walk `attention.request_operator`.
+- If no operator help is needed and attention is still `autonomous_entry`, you may walk `attention.start_autonomous` once, then continue the journey.
+
+Checklist:
+- Read the record fields before inferring severity or scope.
+- Attach one `triage_decision` artifact before walking journey lane edges.
+- Choose `quick` only when the issue is already concrete enough to scope.
+- Choose `standard` when one investigation pass should collect facts.
+- Choose `rigorous` when the plan needs investigation plus explicit review.
+- Choose `discard` or `duplicate` only with a closing outcome and rationale.
+- If product-owner ambiguity blocks an honest choice, use the attention edge above instead of guessing.
+
+Do not create tasks, branches, worktrees, or implementation plans here. This contract is the front half only.

package/templates/contract/schemas/investigation-report.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "description": "Investigation report with mandatory source citations. Each citation names a file and line number.",
+  "required": ["finding", "summary", "citations"],
+  "additionalProperties": false,
+  "properties": {
+    "finding": {"type": "string", "enum": ["confirmed", "not_reproduced", "needs_scope", "blocked"]},
+    "summary": {"type": "string", "minLength": 1},
+    "reproduction_steps": {"type": "array", "items": {"type": "string", "minLength": 1}, "default": []},
+    "citations": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["file", "line", "excerpt", "why_it_matters"],
+        "additionalProperties": false,
+        "properties": {
+          "file": {"type": "string", "minLength": 1},
+          "line": {"type": "integer", "minimum": 1},
+          "excerpt": {"type": "string", "minLength": 1},
+          "why_it_matters": {"type": "string", "minLength": 1}
+        }
+      }
+    },
+    "open_questions": {"type": "array", "items": {"type": "string", "minLength": 1}, "default": []}
+  }
+}

package/templates/contract/schemas/operator-decision.schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "description": "Human operator decision for the provisional attention dimension; all decisions are compatible with returning to autonomous work.",
+  "required": ["decision", "rationale"],
+  "additionalProperties": false,
+  "properties": {
+    "decision": {"type": "string", "enum": ["resume", "revise_scope"]},
+    "rationale": {"type": "string", "minLength": 1},
+    "instructions": {"type": "string", "minLength": 1},
+    "answered_questions": {"type": "array", "items": {"type": "string", "minLength": 1}, "default": []}
+  }
+}