@event4u/agent-config 6.1.0 → 7.0.0

package/dist/agent-src/commands/agent-status.md

@@ -70,10 +70,10 @@ implementation: [`scripts/cost/track.mjs`](../../scripts/cost/track.mjs).
 
 Run two read-only Python helpers (stdlib-only, no-op safe if JSONL missing):
 
-- `python3 scripts/telegraph_stats.py --format json` — per-session +
+- `./scripts-run src/scripts/telegraph_stats --format json` — per-session +
   per-conversation + lifetime telegraph delta. Honors suspended
   multiplier (see [`docs/contracts/telegraph-telemetry.md`](../docs/contracts/telegraph-telemetry.md)) — delta reads `0` while suspended; display version + ACTIVE/SUSPENDED state regardless.
-- `python3 scripts/cost_by_conversation.py --format json` — per-conversation
+- `./scripts-run src/scripts/cost_by_conversation --format json` — per-conversation
   total cost + model breakdown for current conversation, sourced
   from same `agents/cost-tracking/sessions.jsonl` ledger.
 

package/dist/agent-src/commands/agents/audit.md

@@ -89,7 +89,7 @@ Surface candidates with explicit justification. Never auto-apply.
 Run the linter and inspect output:
 
 ```bash
-python3 scripts/lint_agents_md.py
+./scripts-run src/scripts/lint_agents_md
 wc -c AGENTS.md
 ```
 
@@ -105,7 +105,7 @@ Failures route to `/agents optimize` — this command does **not** edit.
 ### 5. Check docs sync + stale references
 
 ```bash
-python3 scripts/check_references.py
+./scripts-run src/scripts/check_references
 ```
 
 Confirm counts/lists in `.augment/contexts/augment-infrastructure.md` and
@@ -114,7 +114,7 @@ Confirm counts/lists in `.augment/contexts/augment-infrastructure.md` and
 ### 6. Run skill linter
 
 ```bash
-python3 scripts/skill_linter.py --all --pairs --duplicates 2>&1 | grep "Summary:"
+./scripts-run src/scripts/skill_linter --all --pairs --duplicates 2>&1 | grep "Summary:"
 ```
 
 Report FAIL/WARN counts. Don't fix here — delegate to `skill-reviewer` or

package/dist/agent-src/commands/agents/init.md

@@ -157,7 +157,7 @@ module-aware skills (road-to-configurable-modules Phase B). Skips
 silently when the helper finds no candidates.
 
 ```bash
-python3 scripts/propose_modules_config.py --json
+./scripts-run src/scripts/propose_modules_config --json
 ```
 
 If the JSON `candidates` array is non-empty, render the proposed

package/dist/agent-src/commands/agents/optimize.md

@@ -63,8 +63,8 @@ ask:
 ```bash
 target="<path-to-AGENTS.md>"
 wc -c "$target"
-python3 scripts/lint_agents_md.py 2>&1 | grep -A1 "$target" || \
-  python3 scripts/lint_agents_md.py
+./scripts-run src/scripts/lint_agents_md 2>&1 | grep -A1 "$target" || \
+  ./scripts-run src/scripts/lint_agents_md
 ```
 
 Record: total chars, gap to FAIL/WARN cap, pointer-ratio output,
@@ -151,8 +151,8 @@ as a finding in the step-7 numbered options instead of editing here.
 ### 9. Verify before claiming done
 
 ```bash
-python3 scripts/lint_agents_md.py
-python3 scripts/check_references.py
+./scripts-run src/scripts/lint_agents_md
+./scripts-run src/scripts/check_references
 ```
 
 Both green = the refactor is finished. Surface fresh output in the

package/dist/agent-src/commands/analyze/decision.md

@@ -0,0 +1,108 @@
+---
+model_tier: inherit
+name: analyze-decision
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: decision
+skills: [decision-review]
+description: Audit a past architectural decision — restate what was chosen and why, compare original assumptions against reality now, produce a verdict (still valid / needs amendment / superseded).
+suggestion:
+  eligible: true
+  trigger_description: "decision review, ADR review, did this hold up, rückblick Architektur, past decision"
+  trigger_context: "user wants to audit a past architectural decision or ADR for continued validity"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:decision
+
+Past-decision audit sub-command in the `/analyze` cluster.
+Loads and runs the
+[`decision-review`](../../../../skills/decision-review/SKILL.md) skill.
+
+## Instructions
+
+### 1. Identify the decision
+
+Ask the user (in their language) for:
+
+- The ADR identifier (e.g. `ADR-042`) or informal name.
+- The path to the ADR file, or the slug to look up in `docs/decisions/`
+  or `docs/adrs/`.
+
+If the user names the decision informally, check the index before
+reading the full file.
+
+### 2. Run the decision-review skill
+
+Delegate to
+[`decision-review`](../../../../skills/decision-review/SKILL.md) verbatim:
+
+1. **Locate and read the full ADR** before proceeding.
+2. **Restate** — chosen option, context then, assumptions, alternatives
+   rejected.
+3. **Compare to reality now** — for each assumption: held / broke /
+   unknown, with evidence. List new information not available at
+   decision time.
+4. **Verdict** — one of three:
+   - *Still valid* — document the validation date.
+   - *Needs amendment* — core decision stands; recommend specific
+     amendment.
+   - *Superseded* — name the successor option; recommend
+     `decision-record` + `adr-create` as the forward path.
+
+Hindsight discipline: judge each assumption against the information
+available at the time it was made, not against the outcome alone.
+
+### 3. Memory write-back (dedup-first)
+
+Before drafting a new candidate, call `retrieve()` over the same
+key-space (decision area, affected paths) per
+[`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md):
+
+- **Match found** → propose a `frequency` / `supersedes` update.
+- **No match** → draft a new `historical-patterns` candidate:
+
+```jsonc
+{
+  "type":              "historical-patterns",
+  "summary":           "<one-line pattern: what held or broke>",
+  "evidence_paths":    ["docs/decisions/ADR-NNN-<slug>.md"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+Surface the candidate and ask:
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+If the candidate fails the admission gate (< 2 distinct evidence paths
+AND < 3 future decisions in `decision_surface`), surface the gap and
+suggest deferring or strengthening evidence before proposing.
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote — `/memory propose` is the intake.
+- Do NOT re-litigate a decision confirmed still valid — acknowledge it,
+  note the validation date, stop.
+- Do NOT issue a "superseded" verdict without naming the successor
+  option and recommending the forward path to `decision-record` +
+  `adr-create`.
+
+## See also
+
+- [`decision-review`](../../../../skills/decision-review/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze`](../command.md) — cluster orchestrator

package/dist/agent-src/commands/analyze/incident.md

@@ -0,0 +1,120 @@
+---
+model_tier: inherit
+name: analyze-incident
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: incident
+skills: [incident-commander, root-cause-frameworks, blameless-post-mortem]
+description: Full incident flow — incident-commander coordination, then RCA via root-cause-frameworks, then a blame-free write-up via blameless-post-mortem, ending with an incident-learnings candidate.
+suggestion:
+  eligible: true
+  trigger_description: "production is down, active incident, Vorfall, Prod ist down, full incident analysis"
+  trigger_context: "user is managing or reviewing a production incident end-to-end"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:incident
+
+Full incident sub-command in the `/analyze` cluster.
+Chains three skills:
+
+1. [`incident-commander`](../../../../skills/incident-commander/SKILL.md) — live coordination.
+2. [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md) — RCA after mitigation.
+3. [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md) — write-up + memory candidate.
+
+## Instructions
+
+### Phase 1 — Live incident coordination
+
+Load
+[`incident-commander`](../../../../skills/incident-commander/SKILL.md)
+and follow its procedure verbatim:
+
+- Open an incident log, assign roles, establish communication cadence.
+- Drive mitigation loop until impact is contained.
+- Capture a timeline as the incident progresses.
+- Write a partial post-mortem skeleton when mitigation is confirmed
+  (title, severity, timeline, impact — root cause can be TBD).
+
+**Handoff trigger:** mitigation confirmed → proceed to Phase 2.
+Per
+[`analysis-memory-loop.md § 5`](../../../../docs/contracts/analysis-memory-loop.md),
+the skeleton is acceptable input with open root-cause items.
+
+### Phase 2 — Root-cause analysis
+
+Load
+[`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+and run the appropriate framework (5-whys, fishbone, fault-tree, or
+STAMP/STPA) against the captured timeline:
+
+- Return ranked root-cause candidates with confidence levels.
+- Present candidates to the user — not a forced verdict.
+- If root cause remains unresolved, mark the skeleton `status: draft`.
+  Do not block on an unresolved RCA.
+
+### Phase 3 — Post-mortem write-up + memory candidate
+
+Load
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+and produce the full write-up:
+
+1. **Summary** — what failed, impact, duration.
+2. **Timeline** — chronological bullets from Phase 1.
+3. **Root cause** — confirmed or `status: draft`.
+4. **Contributing factors** — systemic, not individual.
+5. **Corrective actions** — numbered, owned, time-boxed.
+6. **What went well** — working safeguards.
+
+#### Memory write-back
+
+Dedup pre-check: call `retrieve()` over the same key-space (incident
+type, affected paths) per
+[`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md):
+
+- **Match found** → propose a `frequency` / `supersedes` update.
+- **No match** → draft a new `incident-learnings` candidate:
+
+```jsonc
+{
+  "type":              "incident-learnings",
+  "summary":           "<one-line pattern learned>",
+  "evidence_paths":    ["<path/to/post-mortem>", "<path/to/timeline>"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+Surface the draft and ask:
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote — `/memory propose` is the intake.
+- Do NOT block on incomplete root cause — the skeleton from Phase 1 is
+  sufficient to enter Phase 3; mark `status: draft` if unresolved.
+- Systems and processes only — never name individuals.
+- Do NOT chain back to `/analyze:postmortem` — this command IS the
+  full incident flow end-to-end.
+
+## See also
+
+- [`incident-commander`](../../../../skills/incident-commander/SKILL.md)
+- [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+- [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze:postmortem`](../postmortem/command.md) — post-incident write-up only (no live coordination)
+- [`/analyze`](../command.md) — cluster orchestrator

package/dist/agent-src/commands/analyze/near-miss.md

@@ -0,0 +1,113 @@
+---
+model_tier: inherit
+name: analyze-near-miss
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: near-miss
+skills: [blameless-post-mortem]
+description: Blame-free near-miss analysis — same post-mortem flow as analyze:postmortem but framed around a close call that did not result in a production incident.
+suggestion:
+  eligible: true
+  trigger_description: "near-miss, almost failed, beinahe-Vorfall, close call, we almost had an outage"
+  trigger_context: "user wants to analyse a close call or near-miss event that did not produce a full incident"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:near-miss
+
+Near-miss analysis sub-command in the `/analyze` cluster.
+Uses the
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+skill with a near-miss framing — same structure as
+[`analyze:postmortem`](../postmortem/command.md) but the emphasis is
+on *what prevented actual impact* and *what systemic changes prevent
+recurrence*, not on cataloguing damage.
+
+## Instructions
+
+### 1. Gather the near-miss context
+
+Ask the user (in their language) for:
+
+- Event summary — what happened, what was at risk, what contained it.
+- Timeline bullets (what occurred, in what order).
+- Known trigger or suspected root cause (may be empty).
+- What safeguard, luck, or human action prevented full impact.
+
+Accept incomplete information; the write-up may include open items
+with `status: draft`.
+
+### 2. Retrieve prior incident-learnings
+
+Before drafting, call `retrieve()` over the same key-space (affected
+system, incident type, decision area) per
+[`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md):
+
+- **Stale entries** (age > `review_after_days`) are in `skipped` —
+  surface them; do not silently use them.
+- **Match found** → propose a `frequency` / `supersedes` update.
+- **No match** → proceed to draft a new candidate in Step 4.
+
+### 3. Write the near-miss document
+
+Following
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md),
+produce a write-up covering:
+
+1. **Summary** — what was at risk, what contained it.
+2. **Timeline** — chronological bullets.
+3. **Trigger / contributing factors** — systemic, not individual.
+4. **What prevented impact** — named safeguard, human catch, timing.
+5. **Corrective actions** — numbered, owned, time-boxed.
+6. **What went well** — preserve the working safeguards.
+
+Emphasise the containing mechanism over the potential damage — the goal
+is to reinforce what worked and close the gap that allowed the close
+call.
+
+### 4. Draft the memory candidate
+
+Per
+[`analysis-memory-loop.md § 1`](../../../../docs/contracts/analysis-memory-loop.md),
+draft an `incident-learnings` candidate via `/memory propose`:
+
+```jsonc
+{
+  "type":              "incident-learnings",
+  "summary":           "<one-line pattern: near-miss type + containing mechanism>",
+  "evidence_paths":    ["<path/to/near-miss-doc>"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+### 5. Surface the candidate to the user
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote — `/memory propose` is the intake.
+- Do NOT block on incomplete root cause — accept skeletons.
+- Systems and processes only — never name individuals.
+- Frame the write-up around the containing mechanism, not the
+  potential damage.
+
+## See also
+
+- [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze:postmortem`](../postmortem/command.md) — same flow, full incident
+- [`/analyze`](../command.md) — cluster orchestrator

package/dist/agent-src/commands/analyze/postmortem.md

@@ -0,0 +1,130 @@
+---
+model_tier: inherit
+name: analyze-postmortem
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: postmortem
+skills: [blameless-post-mortem, root-cause-frameworks]
+description: Blame-free post-mortem after a resolved incident — consume the incident-commander skeleton, derive root cause, write corrective actions, draft an incident-learnings memory candidate.
+suggestion:
+  eligible: true
+  trigger_description: "post-mortem, Nachbesprechung, incident review, was ist schiefgelaufen"
+  trigger_context: "incident or outage is resolved and a structured write-up is needed"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:postmortem
+
+Blame-free post-mortem sub-command in the `/analyze` cluster.
+Loads and runs the
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+skill, supported by
+[`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md).
+
+## Instructions
+
+### 1. Gather the incident context
+
+Ask the user (in their language) for what is known:
+
+- Incident summary (title, affected system, start/end time, severity).
+- Timeline bullet points (what happened, when).
+- Known or suspected root cause (may be empty — that is fine; the
+  skill will derive it in Step 3).
+- Any existing `incident-commander` skeleton to consume.
+
+Accept an incomplete skeleton per
+[`analysis-memory-loop.md § 5`](../../../../docs/contracts/analysis-memory-loop.md):
+a missing root cause is normal, not a blocker.
+
+### 2. Retrieve prior incident-learnings
+
+Before drafting, call `retrieve()` over the same key-space (incident
+type, affected paths, decision areas) per
+[`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md).
+
+- **Stale entries** (age > `review_after_days`) appear in `skipped`
+  — surface them to the user, do not silently use them.
+- **Match found** → note the existing entry; propose a `frequency` or
+  `supersedes` update instead of a new candidate.
+- **No match** → proceed to draft a new candidate in Step 5.
+
+### 3. Derive or confirm root cause
+
+Load [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+and run the appropriate framework (5-whys chain, fishbone, fault-tree,
+or STAMP/STPA) against the timeline. The skill returns ranked
+candidates with confidence levels — not a forced verdict. Present the
+top candidates to the user.
+
+If root cause remains unresolved after the pass, mark the post-mortem
+`status: draft`; do not block or stall.
+
+### 4. Write the post-mortem document
+
+Following
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md),
+produce a structured write-up covering:
+
+1. **Summary** — what failed, impact, duration.
+2. **Timeline** — chronological bullets.
+3. **Root cause** — confirmed or `status: draft` if unresolved.
+4. **Contributing factors** — systemic, not individual.
+5. **Corrective actions** — numbered, owned, time-boxed.
+6. **What went well** — preserve working safeguards.
+
+Systems and processes are examined — never individuals.
+
+### 5. Draft the memory candidate
+
+Per
+[`analysis-memory-loop.md § 1`](../../../../docs/contracts/analysis-memory-loop.md),
+draft an `incident-learnings` candidate using `/memory propose`:
+
+```jsonc
+{
+  "type":              "incident-learnings",
+  "summary":           "<one-line pattern learned>",
+  "evidence_paths":    ["<path/to/post-mortem>", "<path/to/timeline>"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+If the post-mortem is `status: draft`, include the open question in
+`summary` (e.g. `"root cause TBD — <symptom>"`).
+
+Dedup check from Step 2 determines whether to propose a new entry or
+update an existing one.
+
+### 6. Surface the candidate to the user
+
+Present the draft candidate and ask:
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote to curated memory — `/memory propose` is the
+  intake; `/memory promote` requires the human to run the admission gate.
+- Do NOT block on an incomplete root cause — accept any skeleton.
+- Systems and processes only — never name individuals.
+
+## See also
+
+- [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+- [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze`](../command.md) — cluster orchestrator

package/dist/agent-src/commands/analyze/premortem.md

@@ -0,0 +1,104 @@
+---
+model_tier: inherit
+name: analyze-premortem
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: premortem
+skills: [premortem]
+description: Forward-looking imagined-failure analysis before committing to a heavy or irreversible plan — enumerate failure stories, score each mode, derive early-warning signals and guardrails.
+suggestion:
+  eligible: true
+  trigger_description: "premortem, what if this fails, imagine failure, stress-test this plan, what could go wrong"
+  trigger_context: "user wants to anticipate failure modes before committing to a plan"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:premortem
+
+Forward-looking imagined-failure sub-command in the `/analyze` cluster.
+Loads and runs the
+[`premortem`](../../../../skills/premortem/SKILL.md) skill.
+
+## Instructions
+
+### 1. Gather the plan to stress-test
+
+Ask the user (in their language) for:
+
+- A one-sentence summary of the plan: *"We are doing X for outcome Y,
+  touching Z."*
+- The prospective-failure horizon (default: 6 months post-launch).
+- Any known constraints, irreversibilities, or high-coordination
+  surfaces worth front-loading.
+
+If the plan cannot be summarised in one sentence, stop and ask for
+scope clarification before proceeding. An un-summarisable plan is not
+reviewable.
+
+### 2. Run the premortem skill
+
+Delegate to
+[`premortem`](../../../../skills/premortem/SKILL.md) verbatim:
+
+1. **Set the prospective-failure frame** — "Assume total failure at
+   horizon H. What went wrong?"
+2. **Enumerate failure stories** — cover people, process, technical,
+   external, and timing angles. Each story is a short narrative in past
+   tense. Invoke `adversarial-review` to attack the plan's assumptions.
+   Invoke `risk-officer` to assign L × I scores — do not re-implement
+   L × I inline.
+3. **Derive early-warning signals and preventive guardrails** — one
+   observable signal and one actionable guardrail per top failure mode.
+   If no practical guardrail exists, mark it `accept` with rationale.
+
+### 3. Optional memory write-back
+
+If the analysis surfaces a pattern worth preserving for future plans:
+
+1. Dedup pre-check: call `retrieve()` over the same key-space (plan
+   type, affected paths, decision area) per
+   [`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md).
+   - **Match found** → propose a `frequency` / `supersedes` update.
+   - **No match** → draft a new `historical-patterns` candidate.
+
+2. Draft the candidate:
+
+```jsonc
+{
+  "type":              "historical-patterns",
+  "summary":           "<one-line pattern: failure mode to watch for>",
+  "evidence_paths":    ["<path/to/plan-doc>"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+3. Surface the candidate to the user and ask:
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote — `/memory propose` is the intake.
+- Do NOT re-implement L × I scoring — delegate to `risk-officer`.
+- Failure stories must be grounded in the actual plan's structure —
+  no invented strawmen.
+- Label all scenarios as prospective (imagined future), not predictions.
+
+## See also
+
+- [`premortem`](../../../../skills/premortem/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze`](../command.md) — cluster orchestrator