omegon 0.7.8 → 0.8.1

package/README.md

@@ -42,7 +42,7 @@ omegon      # start Omegon in any project directory
 
 ![Omegon Architecture](docs/img/architecture.png)
 
-Omegon extends `@styrene-lab/pi-coding-agent` with **27 extensions**, **12 skills**, and **4 prompt templates** — loaded automatically on session start.
+Omegon extends `@styrene-lab/pi-coding-agent` with **31 extensions**, **12 skills**, and **4 prompt templates** — loaded automatically on session start.
 
 ### Development Methodology
 
@@ -87,8 +87,10 @@ Structured design exploration with persistent markdown documents — the upstrea
 - **Blocked audit**: `design_tree(action="blocked")` returns all stalled nodes with each blocking dependency's id, title, and status
 - **Priority**: `set_priority` (1 = critical → 5 = trivial) on any node; `ready` auto-sorts by it
 - **Issue types**: `set_issue_type` classifies nodes as `epic | feature | task | bug | chore` — bugs and chores are now first-class tracked work
-- **OpenSpec bridge**: `design_tree_update` with `action: "implement"` scaffolds `openspec/changes/<node-id>/` from a decided node's content; `/cleave` executes it
-- **Full pipeline**: design → decide → implement → `/cleave` → `/assess spec` → archive
+- **Auto-transition**: Adding research or decisions to a `seed` node automatically transitions it to `exploring` and scaffolds the design spec — no manual ceremony
+- **Substance-over-ceremony gates**: `set_status(decided)` checks for open questions and recorded decisions instead of artifact directory existence. Design specs are auto-extracted from doc content and archived
+- **OpenSpec bridge**: `design_tree_update` with `action: "implement"` scaffolds `openspec/changes/<node-id>/` from a decided node's content, auto-checkouts the directive branch, forks a scoped memory mind, and sets design focus; `/cleave` executes it
+- **Full pipeline**: design → decide → implement (auto-checkout + mind fork) → `/cleave` → `/assess spec` → archive (mind merge-back + cleanup)
 
 ### 🧠 Project Memory
 
@@ -98,8 +100,9 @@ Persistent, cross-session knowledge stored in SQLite. Accumulates architectural
 - **Semantic retrieval**: Embedding-based search via Ollama (`qwen3-embedding`), falls back to FTS5 keyword search
 - **Background extraction**: Auto-discovers facts from tool output without interrupting work
 - **Episodic memory**: Generates session narratives at shutdown for "what happened last time" context
+- **Directive minds**: `implement` forks a scoped memory mind from `default`; all fact reads/writes auto-scope to the directive. `archive` ingests discoveries back to `default` and cleans up. Zero-copy fork with parent-chain inheritance — no fact duplication, parent embeddings and edges are reused
 - **Global knowledge base**: Cross-project facts at `~/.pi/memory/global.db`
-- **Git sync**: Exports to JSONL for version-controlled knowledge sharing across machines
+- **Git sync**: Exports to JSONL for version-controlled knowledge sharing across machines; volatile runtime scoring metadata (confidence, reinforcement counts, decay scores) omitted from exports for stable diffs
 
 ![Memory Lifecycle](docs/img/memory-lifecycle.png)
 
@@ -112,6 +115,7 @@ Live status panel showing design tree, OpenSpec changes, cleave dispatch, and gi
 - **Raised mode**: Full-width expanded view (toggle with `/dash`)
   - Git branch tree rooted at repo name, annotated with linked design nodes
   - Two-column split at ≥120 terminal columns: design tree + cleave left, OpenSpec right
+  - Directive indicator: shows `▸ directive: name ✓` (branch match) or `▸ directive: name ⚠ main` (mismatch) when a directive mind is active
   - Context gauge · model · thinking level in shared footer zone
   - No line cap — renders as much content as needed
 - **Keyboard**: `Ctrl+Shift+B` toggles raised/compact

package/extensions/cleave/dispatcher.ts

@@ -294,7 +294,7 @@ export function buildChildPrompt(
 		"   - Fill in Summary, Artifacts, Decisions Made, Interfaces Published",
 		"3. **Commits**: Commit your work with clear messages. Do not push.",
 		"4. **No side effects**: Do not install global packages or modify system state.",
-		"5. **Verification**: Run tests or checks and report results in the Verification section.",
+		"5. **Testing**: Write tests for new functions and changed behavior in co-located *.test.ts files. Run them and report results in the Verification section. Untested code is incomplete.",
 		`6. **Workspace**: ${workspacePath}`,
 	];
 

package/extensions/cleave/index.ts

@@ -1583,6 +1583,7 @@ export default function cleaveExtension(pi: ExtensionAPI) {
 		promptSnippet:
 			"Assess task complexity for decomposition — returns pattern match, complexity score, and execute/cleave decision",
 		promptGuidelines: [
+			"Every non-trivial code change must include tests in co-located *.test.ts files. Untested code is incomplete — do not commit without tests for new functions and changed behavior.",
 			"Call cleave_assess before starting any multi-system or cross-cutting task to determine if decomposition is needed",
 			"If decision is 'execute', proceed directly. If 'cleave', use /cleave to decompose. If 'needs_assessment', proceed directly — it means no pattern matched but the task is likely simple enough for in-session execution.",
 			"Complexity formula: (1 + systems) × (1 + 0.5 × modifiers). Threshold default: 2.0.",

package/extensions/cleave/workspace.ts

@@ -238,9 +238,10 @@ ${skillSection}${designSection}${guardrailSection ?? ""}
 ## Contract
 
 1. Only work on files within your scope
-2. Update the Result section below when done
-3. Commit your work with clear messages — do not push
-4. If the task is too complex, set status to NEEDS_DECOMPOSITION
+2. Write tests for new functions and changed behavior — co-locate as *.test.ts
+3. Update the Result section below when done
+4. Commit your work with clear messages — do not push
+5. If the task is too complex, set status to NEEDS_DECOMPOSITION
 
 ## Result
 

package/extensions/dashboard/footer.ts

@@ -546,27 +546,33 @@ export class DashboardFooter implements Component {
     // ── Provider / model / thinking line ──────────────────────
     const m = ctx.model;
     if (m) {
-      const multiProvider = this.footerData.getAvailableProviderCount() > 1;
       const pointer = theme.fg("accent", "▸");
-      const dot = theme.fg("dim", "  ·  ");
+      const dot = theme.fg("dim", " · ");
 
+      // Width-aware: narrow cards drop provider prefix, abbreviate thinking
+      const narrow = width < 40;
+      const multiProvider = !narrow && this.footerData.getAvailableProviderCount() > 1;
+
+      // Shorten model ID for display: "claude-opus-4-6" stays, but drop provider/ prefix if present in ID
+      const modelDisplay = m.id.replace(/^.*\//, "");
       const providerModel = multiProvider
-        ? `${pointer} ${theme.fg("muted", m.provider)} ${theme.fg("dim", "/")} ${theme.fg("muted", m.id)}`
-        : `${pointer} ${theme.fg("muted", m.id)}`;
+        ? `${pointer} ${theme.fg("muted", m.provider)}${theme.fg("dim", "/")}${theme.fg("muted", modelDisplay)}`
+        : `${pointer} ${theme.fg("muted", modelDisplay)}`;
 
       const parts: string[] = [providerModel];
 
-      if (m.reasoning) {
+      if (m.reasoning && this.cachedThinkingLevel) {
         const thinkColor: ThemeColor = this.cachedThinkingLevel === "high"    ? "accent"
           : this.cachedThinkingLevel === "medium"   ? "muted"
           : "dim";
         const thinkIcon = this.cachedThinkingLevel === "off"
           ? theme.fg("dim", "○")
           : theme.fg(thinkColor, "◉");
-        parts.push(`${thinkIcon} ${theme.fg(thinkColor, this.cachedThinkingLevel)}`);
+        // Narrow: icon only, no label
+        parts.push(narrow ? thinkIcon : `${thinkIcon} ${theme.fg(thinkColor, this.cachedThinkingLevel)}`);
       }
 
-      if (this.cachedTokens.cost > 0) {
+      if (this.cachedTokens.cost > 0 && !narrow) {
         parts.push(theme.fg("dim", `$${this.cachedTokens.cost.toFixed(3)}`));
       }
 
@@ -592,7 +598,8 @@ export class DashboardFooter implements Component {
 
     if (!metrics && totalFacts === null) return "";
 
-    const sep = theme.fg("dim", "  ·  ");
+    const sep = theme.fg("dim", " · ");
+    const narrow = width < 35;
     const parts: string[] = [];
 
     if (totalFacts !== null) {
@@ -600,17 +607,24 @@ export class DashboardFooter implements Component {
     }
 
     if (metrics) {
+      // Always show injection count and token estimate
       if (metrics.projectFactCount > 0)
         parts.push(theme.fg("dim", "inj ") + theme.fg("muted", String(metrics.projectFactCount)));
-      if (metrics.workingMemoryFactCount > 0)
+      // Show working memory and episodes only when there's room
+      if (!narrow && metrics.workingMemoryFactCount > 0)
         parts.push(theme.fg("dim", "wm ")  + theme.fg("muted", String(metrics.workingMemoryFactCount)));
-      if (metrics.episodeCount > 0)
+      if (!narrow && metrics.episodeCount > 0)
         parts.push(theme.fg("dim", "ep ")  + theme.fg("muted", String(metrics.episodeCount)));
-      if (metrics.globalFactCount > 0)
+      // Drop global count in narrow — least useful
+      if (!narrow && metrics.globalFactCount > 0)
         parts.push(theme.fg("dim", "gl ")  + theme.fg("muted", String(metrics.globalFactCount)));
-      parts.push(theme.fg("dim", `~${metrics.estimatedTokens}`));
+      // Token estimate — always show, use compact format
+      const tokStr = metrics.estimatedTokens >= 1000
+        ? `~${(metrics.estimatedTokens / 1000).toFixed(1)}k`
+        : `~${metrics.estimatedTokens}`;
+      parts.push(theme.fg("dim", tokStr));
     } else {
-      parts.push(theme.fg("dim", "pending injection"));
+      parts.push(theme.fg("dim", "pending"));
     }
 
     return truncateToWidth(`  ${parts.join(sep)}`, width, "…");
@@ -674,6 +688,41 @@ export class DashboardFooter implements Component {
     return lines;
   }
 
+  /**
+   * Derive a short directive label from the active mind name.
+   * "directive/my-feature" → "my-feature", null/default → null.
+   */
+  private getDirectiveLabel(): string | null {
+    const mind = sharedState.activeMind;
+    if (!mind || mind === "default") return null;
+    // Strip common prefixes: "directive/", "mind/"
+    const label = mind.replace(/^(?:directive|mind)\//, "");
+    return label || null;
+  }
+
+  /**
+   * Build directive indicator lines for the model card area.
+   * Shows "▸ directive: my-feature ✓" (branch match) or "▸ directive: my-feature ⚠ main" (mismatch).
+   * Returns empty array when no directive is active.
+   */
+  private buildDirectiveIndicatorLines(width: number): string[] {
+    const label = this.getDirectiveLabel();
+    if (!label) return [];
+    const theme = this.theme;
+    const directive = sharedState.activeDirective;
+    const currentBranch = this.footerData.getGitBranch?.() ?? "";
+
+    let branchBadge = "";
+    if (directive && currentBranch) {
+      branchBadge = currentBranch === directive.branch
+        ? ` ${theme.fg("success", "✓")}`
+        : ` ${theme.fg("error", "⚠")} ${theme.fg("dim", currentBranch)}`;
+    }
+
+    const line = `${theme.fg("warning", "▸")} ${theme.fg("dim", "directive:")} ${theme.fg("warning", label)}${branchBadge}`;
+    return [truncateToWidth(line, width, "…")];
+  }
+
   private buildModelTopologySummaries(): DashboardModelRoleSummary[] {
     const ctx = this.ctxRef;
     const summaries: DashboardModelRoleSummary[] = [];
@@ -751,8 +800,12 @@ export class DashboardFooter implements Component {
             : theme.fg("dim", summary.state));
     const normalized = normalizeLocalModelLabel(summary.model);
     const alias = forceCompact ? "" : (normalized.alias ? theme.fg("dim", `alias ${normalized.alias}`) : "");
-    const roleLabel = forceCompact ? summary.label.slice(0, 1) : summary.label;
-    const primary = `${theme.fg("accent", roleLabel)} ${theme.fg("muted", normalized.canonical)}`;
+    // In very compact mode, drop the role label to give more room to the model name
+    const veryCompact = width < 30;
+    const roleLabel = veryCompact ? "" : (forceCompact ? summary.label.slice(0, 1) : summary.label);
+    const primary = roleLabel
+      ? `${theme.fg("accent", roleLabel)} ${theme.fg("muted", normalized.canonical)}`
+      : theme.fg("muted", normalized.canonical);
     return truncateToWidth(
       composePrimaryMetaLine(
         width,
@@ -790,7 +843,10 @@ export class DashboardFooter implements Component {
         contextCard: this.buildSummaryCard("context", this.buildHudContextLines(Math.max(1, safeWidth - 2)).map((l) => l.trimStart()), safeWidth),
         modelCard: this.buildSummaryCard(
           "models",
-          this.buildModelTopologySummaries().map((s) => this.formatModelTopologyLine(s, Math.max(1, safeWidth - 2), safeWidth < 44)),
+          [
+            ...this.buildDirectiveIndicatorLines(Math.max(1, safeWidth - 2)),
+            ...this.buildModelTopologySummaries().map((s) => this.formatModelTopologyLine(s, Math.max(1, safeWidth - 2), safeWidth < 44)),
+          ],
           safeWidth,
         ),
         memoryCard: this.buildSummaryCard("memory", (() => {
@@ -852,7 +908,10 @@ export class DashboardFooter implements Component {
       contextCard: this.buildSummaryCardForColumn("context", this.buildHudContextLines(Math.max(1, col1W - 2)).map((l) => l.trimStart()), col1W, col1W),
       modelCard: this.buildSummaryCardForColumn(
         "models",
-        this.buildModelTopologySummaries().map((s) => this.formatModelTopologyLine(s, Math.max(1, col2W - 2), col2W < 44)),
+        [
+          ...this.buildDirectiveIndicatorLines(Math.max(1, col2W - 2)),
+          ...this.buildModelTopologySummaries().map((s) => this.formatModelTopologyLine(s, Math.max(1, col2W - 2), col2W < 44)),
+        ],
         col2W,
         col2W,
       ),
@@ -1074,10 +1133,14 @@ export class DashboardFooter implements Component {
       }
     }
 
-    // If no focused node and no implementing nodes, show all nodes (up to MAX_NODES)
+    // If no focused node and no implementing nodes, show actionable nodes only.
+    // Filter out decided/implemented/resolved — those are done; the footer should
+    // surface work in progress, not a historical catalog.
     if (!dt.focusedNode && (!dt.implementingNodes || dt.implementingNodes.length === 0) && dt.nodes) {
+      const TERMINAL_STATUSES = new Set(["decided", "implemented", "resolved"]);
+      const actionable = dt.nodes.filter(n => !TERMINAL_STATUSES.has(n.status));
       const MAX_NODES = 6;
-      for (const n of dt.nodes.slice(0, MAX_NODES)) {
+      for (const n of actionable.slice(0, MAX_NODES)) {
         const icon = this.nodeStatusIcon(n.status);
         const badge = designSpecBadge(n.designSpec, n.assessmentResult, (c, t) => theme.fg(c as any, t));
         const badgeSep = badge ? " " : "";
@@ -1090,9 +1153,9 @@ export class DashboardFooter implements Component {
           [qSuffix + linkSuffix],
         ));
       }
-      if (dt.nodes.length > MAX_NODES) {
+      if (actionable.length > MAX_NODES) {
         lines.push(
-          theme.fg("dim", `  … ${dt.nodes.length - MAX_NODES} more`) +
+          theme.fg("dim", `  … ${actionable.length - MAX_NODES} more`) +
           theme.fg("dim", " — /dashboard to expand"),
         );
       }

package/extensions/design-tree/index.ts

@@ -59,6 +59,7 @@ import {
 	validateNodeId,
 	scaffoldOpenSpecChange,
 	scaffoldDesignOpenSpecChange,
+	extractAndArchiveDesignSpec,
 	mirrorOpenQuestionsToDesignSpec,
 	matchBranchToNode,
 	appendBranch,
@@ -798,31 +799,44 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					}
 					const oldStatus = node.status;
 
-					// Hard gate: set_status(decided) requires archived design spec.
-					// Exception: bug/chore/task nodes with no open questions can skip
-					// the design-phase ceremony — the decision IS the diagnosis.
+					// Gate: set_status(decided) checks substance first, then artifacts.
+					// Substance = open questions resolved, decisions recorded.
+					// Artifacts = design spec archived (auto-created if missing).
 					if (newStatus === "decided") {
+						const openQs = node.open_questions?.length ?? 0;
+
+						// Substance check: open questions must be resolved (fast — no file I/O)
+						if (openQs > 0) {
+							return {
+								content: [{ type: "text", text:
+									`⚠ Cannot decide '${node.title}': ${openQs} open question${openQs > 1 ? "s" : ""} remain\n` +
+									`→ Resolve with add_decision/remove_question, or branch child nodes for exploration` }],
+								details: { id: node.id, blockedBy: "open-questions", openQuestions: openQs },
+								isError: true,
+							};
+						}
+
+						// Substance check: at least one decision recorded (skip for lightweight types)
+						// Parse doc only if we need to check decisions (past the open-questions gate).
+						const sections = getNodeSections(node);
 						const lightweightTypes = new Set(["bug", "chore", "task"]);
 						const isLightweight = node.issue_type && lightweightTypes.has(node.issue_type);
-						const hasOpenQuestions = (node.open_questions?.length ?? 0) > 0;
-
-						// Lightweight nodes: allow decided if no open questions remain,
-						// regardless of design-phase spec state.
-						if (!(isLightweight && !hasOpenQuestions)) {
-							const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
-							if (designSpec.missing) {
-								return {
-									content: [{ type: "text", text: `Cannot mark '${node.title}' decided: scaffold design spec first via set_status(exploring).` }],
-									details: { id: node.id, blockedBy: "design-openspec-missing" },
-									isError: true,
-								};
-							}
-							if (designSpec.active && !designSpec.archived) {
-								return {
-									content: [{ type: "text", text: `Cannot mark '${node.title}' decided: run \`/assess design ${node.id}\` then archive the design change before marking decided.` }],
-									details: { id: node.id, blockedBy: "design-openspec-not-archived" },
-									isError: true,
-								};
+						if (!isLightweight && sections.decisions.length === 0) {
+							return {
+								content: [{ type: "text", text:
+									`⚠ Cannot decide '${node.title}': no decisions recorded\n` +
+									`→ Use add_decision to record at least one design decision before marking decided` }],
+								details: { id: node.id, blockedBy: "no-decisions" },
+								isError: true,
+							};
+						}
+
+						// Artifact check: auto-scaffold + auto-archive if missing
+						const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
+						if (!designSpec.archived) {
+							const extracted = extractAndArchiveDesignSpec(ctx.cwd, node);
+							if (extracted.created) {
+								// Auto-scaffolded — proceed (message appended below)
 							}
 						}
 					}
@@ -945,10 +959,19 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					if (!node) {
 						return { content: [{ type: "text", text: `Node '${params.node_id}' not found` }], details: {}, isError: true };
 					}
-					addResearch(node, params.heading, params.content);
+					// Auto-transition seed → exploring on first substance addition
+					let transitioned = "";
+					let currentNode = node;
+					if (node.status === "seed") {
+						currentNode = setNodeStatus(node, "exploring");
+						tree.nodes.set(currentNode.id, currentNode);
+						scaffoldDesignOpenSpecChange(ctx.cwd, currentNode);
+						transitioned = " (auto-transitioned seed → exploring)";
+					}
+					addResearch(currentNode, params.heading, params.content);
 					emitCurrentState();
 					return {
-						content: [{ type: "text", text: `Added research '${params.heading}' to '${node.title}'` }],
+						content: [{ type: "text", text: `Added research '${params.heading}' to '${node.title}'${transitioned}` }],
 						details: { id: node.id, heading: params.heading },
 					};
 				}
@@ -962,13 +985,20 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					if (!node) {
 						return { content: [{ type: "text", text: `Node '${params.node_id}' not found` }], details: {}, isError: true };
 					}
+					// Auto-transition seed → exploring on first substance addition
+					let currentNode = node;
+					if (node.status === "seed") {
+						currentNode = setNodeStatus(node, "exploring");
+						tree.nodes.set(currentNode.id, currentNode);
+						scaffoldDesignOpenSpecChange(ctx.cwd, currentNode);
+					}
 					const validDecisionStatuses = ["exploring", "decided", "rejected"];
 					const rawDStatus = params.decision_status || "exploring";
 					if (!validDecisionStatuses.includes(rawDStatus)) {
 						return { content: [{ type: "text", text: `Invalid decision_status '${rawDStatus}'. Valid: ${validDecisionStatuses.join(", ")}` }], details: {}, isError: true };
 					}
 					const dStatus = rawDStatus as "exploring" | "decided" | "rejected";
-					addDecision(node, {
+					addDecision(currentNode, {
 						title: params.decision_title,
 						status: dStatus,
 						rationale: params.rationale || "",
@@ -1136,43 +1166,25 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 						return { content: [{ type: "text", text: `Node '${params.node_id}' not found` }], details: {}, isError: true };
 					}
 					if (node.status !== "decided" && node.status !== "resolved") {
+						const openQs = node.open_questions?.length ?? 0;
+						const hint = openQs > 0
+							? `→ Resolve ${openQs} open question${openQs > 1 ? "s" : ""}, then run set_status(decided)`
+							: `→ Run set_status(decided) to advance this node`;
 						return {
-							content: [{
-								type: "text",
-								text: `Node '${node.title}' is '${node.status}', not 'decided' or 'resolved'. ` +
-									`Resolve open questions and set status to 'decided' (or 'resolved') before implementing.`,
-							}],
-							details: {},
+							content: [{ type: "text", text:
+								`⚠ Cannot implement '${node.title}': status is '${node.status}', needs 'decided' or 'resolved'\n${hint}` }],
+							details: { id: node.id, blockedBy: "status", currentStatus: node.status },
 							isError: true,
 						};
 					}
 
-					// Hard gate: design-phase spec must be archived before implementation.
-					// Exception: bug/chore/task nodes that are already decided with no
-					// open questions can proceed directly — they don't need a design-phase
-					// spec because the decision is the bug diagnosis itself.
+					// Design-spec gate: if not yet archived, auto-extract from doc.
+					// The decided gate already handles substance checks — implement
+					// only needs the artifact to exist for audit trail.
 					{
-						const lightweightTypes = new Set(["bug", "chore", "task"]);
-						const isLightweight = node.issue_type && lightweightTypes.has(node.issue_type);
-						const hasOpenQuestions = (node.open_questions?.length ?? 0) > 0;
-						const skipDesignGate = isLightweight && !hasOpenQuestions && (node.status === "decided" || node.status === "resolved");
-
-						if (!skipDesignGate) {
-							const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
-							if (designSpec.missing) {
-								return {
-									content: [{ type: "text", text: "Scaffold design spec first via set_status(exploring)" }],
-									details: { id: node.id, blockedBy: "design-openspec-missing" },
-									isError: true,
-								};
-							}
-							if (designSpec.active && !designSpec.archived) {
-								return {
-									content: [{ type: "text", text: `Cannot implement '${node.title}': archive the design change first (\`/opsx:archive\` on the design change).` }],
-									details: { id: node.id, blockedBy: "design-openspec-not-archived" },
-									isError: true,
-								};
-							}
+						const designSpec = resolveDesignSpecBinding(ctx.cwd, node.id);
+						if (!designSpec.archived) {
+							extractAndArchiveDesignSpec(ctx.cwd, node);
 						}
 					}
 
@@ -1180,6 +1192,25 @@ export default function designTreeExtension(pi: ExtensionAPI): void {
 					reload(ctx.cwd);
 					emitCurrentState();
 
+					// Auto-focus the design node and fork a directive-scoped memory mind
+					// so context injection and fact isolation track the active directive.
+					if (implResult.ok) {
+						// Auto-focus so context injection immediately tracks this node
+						focusedNode = node.id;
+
+						// Publish active directive for session-start and dashboard
+						sharedState.activeDirective = {
+							nodeId: node.id,
+							branch: implResult.branch ?? `feature/${node.id}`,
+						};
+
+						const mindName = `directive/${node.id}`;
+						(sharedState.mindLifecycleQueue ??= []).push(
+							{ action: "fork", mind: mindName, description: `Memory scope for ${implResult.branch ?? node.id}` },
+							{ action: "activate", mind: mindName },
+						);
+					}
+
 					return {
 						content: [{ type: "text", text: implResult.message }],
 						details: implResult.ok

package/extensions/design-tree/tree.ts

@@ -1605,3 +1605,116 @@ export function mirrorOpenQuestionsToDesignSpec(cwd: string, node: DesignNode):
 	const content = buildDesignTasksContent(node, syntheticSections as DocumentSections);
 	fs.writeFileSync(tasksPath, content);
 }
+
+/**
+ * Extract a design-spec artifact from the doc's structured content.
+ * Deterministic: no LLM pass, no placeholders. If the doc has thin content,
+ * the extracted spec reflects that honestly.
+ *
+ * Creates openspec/design/{id}/ with proposal.md, spec.md, and archives it
+ * immediately to openspec/design-archive/{date}-{id}/.
+ *
+ * Returns { created, archived, message }.
+ */
+export function extractAndArchiveDesignSpec(
+	cwd: string,
+	node: DesignNode,
+): { created: boolean; archived: boolean; message: string } {
+	const designDir = path.join(cwd, "openspec", "design", node.id);
+	const archiveBaseDir = path.join(cwd, "openspec", "design-archive");
+
+	// Already archived? Nothing to do.
+	if (fs.existsSync(archiveBaseDir)) {
+		for (const entry of fs.readdirSync(archiveBaseDir, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const match = entry.name.match(/^\d{4}-\d{2}-\d{2}-(.+)$/);
+			if (match && match[1] === node.id) {
+				return { created: false, archived: true, message: "Design spec already archived" };
+			}
+		}
+	}
+
+	let sections: DocumentSections;
+	try {
+		sections = getNodeSections(node);
+	} catch {
+		sections = {
+			overview: "",
+			research: [],
+			decisions: [],
+			openQuestions: node.open_questions ?? [],
+			implementationNotes: { fileScope: [], constraints: [], rawContent: "" },
+			acceptanceCriteria: { scenarios: [], falsifiability: [], constraints: [] },
+			extraSections: [],
+		};
+	}
+
+	// ── Build spec content from doc sections ──────────────────────
+	const specLines: string[] = [
+		`# ${node.title} — Design Spec (extracted)`,
+		"",
+		`> Auto-extracted from docs/${node.id}.md at decide-time.`,
+		"",
+	];
+
+	if (sections.decisions.length > 0) {
+		specLines.push("## Decisions", "");
+		for (const d of sections.decisions) {
+			specLines.push(`### ${d.title} (${d.status})`);
+			if (d.rationale) specLines.push("", d.rationale);
+			specLines.push("");
+		}
+	}
+
+	const ac = sections.acceptanceCriteria;
+	if (ac.scenarios.length > 0 || ac.falsifiability.length > 0 || ac.constraints.length > 0) {
+		specLines.push("## Acceptance Criteria", "");
+		if (ac.scenarios.length > 0) {
+			specLines.push("### Scenarios", "");
+			for (const s of ac.scenarios) specLines.push(`- ${s}`);
+			specLines.push("");
+		}
+		if (ac.falsifiability.length > 0) {
+			specLines.push("### Falsifiability", "");
+			for (const f of ac.falsifiability) specLines.push(`- ${f}`);
+			specLines.push("");
+		}
+		if (ac.constraints.length > 0) {
+			specLines.push("### Constraints", "");
+			for (const c of ac.constraints) specLines.push(`- ${c}`);
+			specLines.push("");
+		}
+	}
+
+	if (sections.research.length > 0) {
+		specLines.push("## Research Summary", "");
+		for (const r of sections.research) {
+			specLines.push(`### ${r.heading}`, "", r.content.slice(0, 500) + (r.content.length > 500 ? "…" : ""), "");
+		}
+	}
+
+	// ── Write to openspec/design/{id}/ ──────────────────────────
+	// Preserve any existing files (e.g. tasks.md from scaffold), overwrite proposal/spec.
+	fs.mkdirSync(designDir, { recursive: true });
+	fs.writeFileSync(
+		path.join(designDir, "proposal.md"),
+		`# ${node.title}\n\n## Intent\n\n${sections.overview?.split("\n").find(l => l.trim()) ?? node.title}\n\nSee [design doc](../../../docs/${node.id}.md).\n`,
+	);
+	fs.writeFileSync(path.join(designDir, "spec.md"), specLines.join("\n"));
+
+	// ── Immediately archive (copy ALL files, not just ours) ──────
+	const today = new Date().toISOString().split("T")[0];
+	const archiveDir = path.join(archiveBaseDir, `${today}-${node.id}`);
+	fs.mkdirSync(archiveDir, { recursive: true });
+
+	for (const file of fs.readdirSync(designDir)) {
+		fs.copyFileSync(path.join(designDir, file), path.join(archiveDir, file));
+	}
+	fs.rmSync(designDir, { recursive: true, force: true });
+
+	return {
+		created: true,
+		archived: true,
+		message: `Extracted design spec from docs/${node.id}.md (${sections.decisions.length} decisions, ${sections.research.length} research sections) → archived to openspec/design-archive/${today}-${node.id}/`,
+	};
+}

package/extensions/lib/shared-state.ts

@@ -135,6 +135,30 @@ interface SharedState {
   /** Set by bootstrap when first-run is detected. Other extensions should suppress
    *  redundant "no providers" warnings when this is true — bootstrap handles guidance. */
   bootstrapPending?: boolean;
+
+  /** Pending mind lifecycle operations from design-tree/openspec for project-memory to process.
+   *  Written by implement/archive flows, consumed by project-memory on next turn. */
+  mindLifecycleQueue?: MindLifecycleRequest[];
+
+  /** Active directive: the design node currently being implemented.
+   *  Set by design_tree_update(implement), read by session-start and dashboard. */
+  activeDirective?: { nodeId: string; branch: string } | null;
+
+  /** Active mind name from factstore. Written by project-memory, read by dashboard.
+   *  null means default mind (no directive active). */
+  activeMind?: string | null;
+}
+
+export type MindLifecycleAction = "fork" | "activate" | "ingest" | "delete";
+
+export interface MindLifecycleRequest {
+  action: MindLifecycleAction;
+  /** Mind name: fork target, activate target, ingest source, or delete target. */
+  mind: string;
+  /** Human-readable description (used by fork). */
+  description?: string;
+  /** Target mind for ingest (defaults to 'default'). */
+  targetMind?: string;
 }
 
 // Initialize once on first import, reuse thereafter via global symbol.