omegon 0.7.8 → 0.8.0

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.

package/extensions/openspec/index.ts

@@ -764,6 +764,20 @@ export default function openspecExtension(pi: ExtensionAPI): void {
 						);
 					}
 
+					// Merge directive-scoped memory mind back to default and clean up.
+					// The mind was forked at implement time; ingest merges discoveries
+					// back (deduplicating) and delete removes the scope.
+					// Queue unconditionally — the drain skips gracefully if the mind
+					// doesn't exist (e.g. untracked changes that skipped implement).
+					{
+						const mindName = `directive/${params.change_name}`;
+						(sharedState.mindLifecycleQueue ??= []).push(
+							{ action: "ingest", mind: mindName, targetMind: "default" },
+							{ action: "activate", mind: "default" },
+							{ action: "delete", mind: mindName },
+						);
+					}
+
 					// Auto-delete merged feature branches from transitioned design nodes
 					const allBranches = resolveBoundDesignNodes(cwd, params.change_name)
 						.flatMap((n) => n.branches ?? []);
@@ -1763,6 +1777,17 @@ export default function openspecExtension(pi: ExtensionAPI): void {
 				);
 			}
 
+			// Merge directive-scoped memory mind back to default and clean up.
+			// Queue unconditionally — the drain skips if the mind doesn't exist.
+			{
+				const mindName = `directive/${changeName}`;
+				(sharedState.mindLifecycleQueue ??= []).push(
+					{ action: "ingest", mind: mindName, targetMind: "default" },
+					{ action: "activate", mind: "default" },
+					{ action: "delete", mind: mindName },
+				);
+			}
+
 			// Auto-delete merged feature branches from transitioned design nodes
 			const allBranches = resolveBoundDesignNodes(ctx.cwd, changeName)
 				.flatMap((n) => n.branches ?? []);

package/extensions/project-memory/factstore.ts

@@ -555,10 +555,13 @@ export class FactStore {
     const source = opts.source ?? "manual";
     const content = opts.content.replace(/^-\s*/, "").trim();
 
-    // Dedup check — same mind, same hash, still active
+    // Dedup check — same mind (or parent chain), same hash, still active.
+    // Check the full chain so directive minds don't duplicate parent facts.
+    const chain = this.resolveMindChain(mind);
+    const dedupPlaceholders = chain.map(() => "?").join(", ");
     const existing = this.db.prepare(
-      `SELECT id FROM facts WHERE mind = ? AND content_hash = ? AND status = 'active'`
-    ).get(mind, hash);
+      `SELECT id FROM facts WHERE mind IN (${dedupPlaceholders}) AND content_hash = ? AND status = 'active'`
+    ).get(...chain, hash);
 
     if (existing) {
       // Reinforce the existing fact instead of duplicating
@@ -646,15 +649,19 @@ export class FactStore {
     let added = 0;
     const newFactIds: string[] = [];
 
+    // Resolve chain once for all observe dedup checks (cached, but avoid repeated map/join)
+    const observeChain = this.resolveMindChain(mind);
+    const observePlaceholders = observeChain.map(() => "?").join(", ");
+
     const tx = this.db.transaction(() => {
       for (const action of actions) {
         switch (action.type) {
           case "observe": {
-            // Fact observed in session — reinforce if exists, add if new
+            // Fact observed in session — reinforce if exists (in mind or parent chain), add if new
             const hash = contentHash(action.content ?? "");
             const existing = this.db.prepare(
-              `SELECT id FROM facts WHERE mind = ? AND content_hash = ? AND status = 'active'`
-            ).get(mind, hash);
+              `SELECT id FROM facts WHERE mind IN (${observePlaceholders}) AND content_hash = ? AND status = 'active'`
+            ).get(...observeChain, hash);
 
             if (existing) {
               this.reinforceFact((existing as { id: string }).id);
@@ -743,7 +750,24 @@ export class FactStore {
    * the minimumConfidence threshold is consistent with the confidence computation.
    */
   sweepDecayedFacts(mind: string): number {
-    const facts = this.getActiveFacts(mind);
+    // Only sweep facts directly in this mind, not inherited from parents.
+    // Parent facts are managed by their own mind's sweep cycle.
+    const facts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind = ? AND status = 'active' ORDER BY section, created_at`
+    ).all(mind) as Fact[];
+    // Apply decay (same logic as getActiveFacts)
+    const NO_DECAY_SECTIONS: readonly string[] = ["Specs"];
+    const now = Date.now();
+    for (const fact of facts) {
+      if (NO_DECAY_SECTIONS.includes(fact.section)) {
+        fact.confidence = 1.0;
+      } else {
+        const lastReinforced = new Date(fact.last_reinforced).getTime();
+        const daysSince = (now - lastReinforced) / (1000 * 60 * 60 * 24);
+        const profile = SECTION_DECAY_OVERRIDES[fact.section] ?? this.decayProfile;
+        fact.confidence = computeConfidence(daysSince, fact.reinforcement_count, profile);
+      }
+    }
     let swept = 0;
 
     for (const fact of facts) {
@@ -848,10 +872,12 @@ export class FactStore {
   getActiveEdges(mind?: string): Edge[] {
     let edges: Edge[];
     if (mind) {
+      const chain = this.resolveMindChain(mind);
+      const placeholders = chain.map(() => "?").join(", ");
       edges = this.db.prepare(`
         SELECT * FROM edges
-        WHERE (source_mind = ? OR target_mind = ?) AND status = 'active'
-      `).all(mind, mind) as Edge[];
+        WHERE (source_mind IN (${placeholders}) OR target_mind IN (${placeholders})) AND status = 'active'
+      `).all(...chain, ...chain) as Edge[];
     } else {
       edges = this.db.prepare(
         `SELECT * FROM edges WHERE status = 'active'`
@@ -947,15 +973,65 @@ export class FactStore {
   // Queries
   // ---------------------------------------------------------------------------
 
+  private mindChainCache = new Map<string, string[]>();
+
+  /**
+   * Resolve the mind chain: [mind, parent, grandparent, ...].
+   * Used to include inherited facts from parent minds.
+   * Stops at 'default' or when no parent exists. Max depth 5 to prevent cycles.
+   * Cached per-mind since the parent chain is immutable within a session.
+   */
+  private resolveMindChain(mind: string): string[] {
+    const cached = this.mindChainCache.get(mind);
+    if (cached) return cached;
+
+    const chain: string[] = [mind];
+    let current = mind;
+    for (let i = 0; i < 5; i++) {
+      const rec = this.getMind(current);
+      if (!rec?.parent || rec.parent === current) break;
+      chain.push(rec.parent);
+      current = rec.parent;
+    }
+    this.mindChainCache.set(mind, chain);
+    return chain;
+  }
+
+  /** Clear the mind chain cache (call after mind creation/deletion). */
+  private invalidateMindChainCache(): void {
+    this.mindChainCache.clear();
+  }
+
   /**
    * Get active facts for a mind, with confidence decay applied.
+   * If the mind has a parent, includes inherited parent facts (deduped
+   * by content_hash — child facts shadow parent facts with the same content).
    * Optionally limit to top N by confidence.
    */
   getActiveFacts(mind: string, limit?: number): Fact[] {
-    const facts = this.db.prepare(
-      `SELECT * FROM facts WHERE mind = ? AND status = 'active'
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
+    const allFacts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind IN (${placeholders}) AND status = 'active'
        ORDER BY section, created_at`
-    ).all(mind) as Fact[];
+    ).all(...chain) as Fact[];
+
+    // Deduplicate: child facts shadow parent facts with the same content_hash.
+    // Keep the fact from the earliest mind in the chain (= the child).
+    const seen = new Map<string, number>();
+    const facts: Fact[] = [];
+    for (const fact of allFacts) {
+      const chainIdx = chain.indexOf(fact.mind);
+      const existing = seen.get(fact.content_hash);
+      if (existing !== undefined && existing <= chainIdx) continue; // child already present
+      seen.set(fact.content_hash, chainIdx);
+      // Remove any previously added parent fact with same hash
+      if (existing !== undefined) {
+        const idx = facts.findIndex(f => f.content_hash === fact.content_hash);
+        if (idx !== -1) facts.splice(idx, 1);
+      }
+      facts.push(fact);
+    }
 
     // Apply time-based confidence decay.
     // Specs are exempt (binary exist/not-exist).
@@ -992,9 +1068,25 @@ export class FactStore {
 
   /** Get active facts for a specific section, sorted by confidence descending. */
   getFactsBySection(mind: string, section: string): Fact[] {
-    const facts = this.db.prepare(
-      `SELECT * FROM facts WHERE mind = ? AND section = ? AND status = 'active' ORDER BY created_at`
-    ).all(mind, section) as Fact[];
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
+    const allFacts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind IN (${placeholders}) AND section = ? AND status = 'active' ORDER BY created_at`
+    ).all(...chain, section) as Fact[];
+    // Deduplicate: child facts shadow parent facts with the same content_hash.
+    const seen = new Map<string, number>();
+    const facts: Fact[] = [];
+    for (const f of allFacts) {
+      const chainIdx = chain.indexOf(f.mind);
+      const existing = seen.get(f.content_hash);
+      if (existing !== undefined && existing <= chainIdx) continue;
+      seen.set(f.content_hash, chainIdx);
+      if (existing !== undefined) {
+        const idx = facts.findIndex(ff => ff.content_hash === f.content_hash);
+        if (idx !== -1) facts.splice(idx, 1);
+      }
+      facts.push(f);
+    }
 
     const NO_DECAY_SECTIONS: readonly string[] = ["Specs"];
     const now = Date.now();
@@ -1015,17 +1107,21 @@ export class FactStore {
 
   /** Get the count of active facts per section for a mind. */
   getSectionCounts(mind: string): Map<string, number> {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const rows = this.db.prepare(
-      `SELECT section, COUNT(*) as count FROM facts WHERE mind = ? AND status = 'active' GROUP BY section`
-    ).all(mind) as { section: string; count: number }[];
+      `SELECT section, COUNT(DISTINCT content_hash) as count FROM facts WHERE mind IN (${placeholders}) AND status = 'active' GROUP BY section`
+    ).all(...chain) as { section: string; count: number }[];
     return new Map(rows.map(r => [r.section, r.count]));
   }
 
-  /** Count active facts for a mind */
+  /** Count active facts for a mind (including inherited parent facts) */
   countActiveFacts(mind: string): number {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const row = this.db.prepare(
-      `SELECT COUNT(*) as count FROM facts WHERE mind = ? AND status = 'active'`
-    ).get(mind);
+      `SELECT COUNT(DISTINCT content_hash) as count FROM facts WHERE mind IN (${placeholders}) AND status = 'active'`
+    ).get(...chain);
     return row?.count ?? 0;
   }
 
@@ -1036,11 +1132,13 @@ export class FactStore {
     const pattern = `${escaped}%`;
 
     if (mind) {
+      const chain = this.resolveMindChain(mind);
+      const placeholders = chain.map(() => "?").join(", ");
       return this.db.prepare(`
         SELECT * FROM facts
-        WHERE content LIKE ? ESCAPE '\\' AND mind = ? AND status = 'active'
+        WHERE content LIKE ? ESCAPE '\\' AND mind IN (${placeholders}) AND status = 'active'
         ORDER BY created_at DESC
-      `).all(pattern, mind) as Fact[];
+      `).all(pattern, ...chain) as Fact[];
     }
 
     return this.db.prepare(`
@@ -1057,12 +1155,14 @@ export class FactStore {
 
     try {
       if (mind) {
+        const chain = this.resolveMindChain(mind);
+        const placeholders = chain.map(() => "?").join(", ");
         return this.db.prepare(`
           SELECT f.* FROM facts f
           JOIN facts_fts fts ON f.rowid = fts.rowid
-          WHERE facts_fts MATCH ? AND f.mind = ?
+          WHERE facts_fts MATCH ? AND f.mind IN (${placeholders})
           ORDER BY rank
-        `).all(ftsQuery, mind) as Fact[];
+        `).all(ftsQuery, ...chain) as Fact[];
       }
 
       return this.db.prepare(`
@@ -1084,12 +1184,14 @@ export class FactStore {
 
     try {
       if (mind) {
+        const chain = this.resolveMindChain(mind);
+        const placeholders = chain.map(() => "?").join(", ");
         return this.db.prepare(`
           SELECT f.* FROM facts f
           JOIN facts_fts fts ON f.rowid = fts.rowid
-          WHERE facts_fts MATCH ? AND f.mind = ? AND f.status IN ('archived', 'superseded')
+          WHERE facts_fts MATCH ? AND f.mind IN (${placeholders}) AND f.status IN ('archived', 'superseded')
           ORDER BY f.created_at DESC
-        `).all(ftsQuery, mind) as Fact[];
+        `).all(ftsQuery, ...chain) as Fact[];
       }
 
       return this.db.prepare(`
@@ -1326,6 +1428,7 @@ export class FactStore {
       this.db.prepare(`DELETE FROM minds WHERE name = ?`).run(name);
     });
     tx();
+    this.invalidateMindChainCache();
   }
 
   /** Check if a mind exists */
@@ -1339,32 +1442,28 @@ export class FactStore {
     return mind?.readonly === 1;
   }
 
-  /** Fork a mind — copy all active facts to a new mind */
+  /**
+   * Fork a mind — create a child scope that inherits the parent's facts.
+   *
+   * Lightweight: creates the mind record with `parent` set but copies zero
+   * facts, edges, or embeddings. Query methods (getActiveFacts, vector search)
+   * automatically include parent facts via the parent chain. Only facts
+   * explicitly stored in the child are scoped to it.
+   *
+   * On archive, `ingestMind` copies child-only facts back to the parent.
+   */
   forkMind(sourceName: string, newName: string, description: string): void {
-    const tx = this.db.transaction(() => {
-      this.createMind(newName, description, { parent: sourceName });
-
-      const facts = this.getActiveFacts(sourceName);
-      const now = new Date().toISOString();
-
-      for (const fact of facts) {
-        this.db.prepare(`
-          INSERT INTO facts (id, mind, section, content, status, created_at, created_session,
-                             source, content_hash, confidence, last_reinforced,
-                             reinforcement_count, decay_rate)
-          VALUES (?, ?, ?, ?, 'active', ?, NULL, 'ingest', ?, 1.0, ?, ?, ?)
-        `).run(
-          nanoid(), newName, fact.section, fact.content, now,
-          fact.content_hash, now, fact.reinforcement_count, fact.decay_rate,
-        );
-      }
-    });
-    tx();
+    this.createMind(newName, description, { parent: sourceName });
+    this.invalidateMindChainCache();
   }
 
   /** Ingest facts from one mind into another */
   ingestMind(sourceName: string, targetName: string): { factsIngested: number; duplicatesSkipped: number } {
-    const sourceFacts = this.getActiveFacts(sourceName);
+    // Only ingest facts directly stored in the source mind, not inherited from parents.
+    // Inherited facts already exist in the parent (which is typically the target).
+    const sourceFacts = this.db.prepare(
+      `SELECT * FROM facts WHERE mind = ? AND status = 'active' ORDER BY section, created_at`
+    ).all(sourceName) as Fact[];
     let ingested = 0;
     let skipped = 0;
 
@@ -1750,13 +1849,15 @@ export class FactStore {
     return rows.map(r => r.id);
   }
 
-  /** Count facts with vectors for a mind */
+  /** Count facts with vectors for a mind (including parent chain) */
   countFactVectors(mind: string): number {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const row = this.db.prepare(`
       SELECT COUNT(*) as count FROM facts_vec v
       JOIN facts f ON v.fact_id = f.id
-      WHERE f.mind = ? AND f.status = 'active'
-    `).get(mind);
+      WHERE f.mind IN (${placeholders}) AND f.status = 'active'
+    `).get(...chain);
     return row?.count ?? 0;
   }
 
@@ -1776,13 +1877,15 @@ export class FactStore {
     const minSim = opts?.minSimilarity ?? 0.3;
     const queryDims = queryVec.length;
 
-    // Get all active facts with vectors for this mind
+    // Get all active facts with vectors for this mind (including parent chain)
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     let query = `
       SELECT f.*, v.embedding, v.dims FROM facts f
       JOIN facts_vec v ON f.id = v.fact_id
-      WHERE f.mind = ? AND f.status = 'active'
+      WHERE f.mind IN (${placeholders}) AND f.status = 'active'
     `;
-    const params: any[] = [mind];
+    const params: any[] = [...chain];
 
     if (opts?.section) {
       query += ` AND f.section = ?`;
@@ -1887,12 +1990,14 @@ export class FactStore {
       const ftsQuery = buildSafeFtsQuery(queryText, "OR");
       if (ftsQuery) {
         try {
+          const ftsChain = this.resolveMindChain(mind);
+          const ftsPlaceholders = ftsChain.map(() => "?").join(", ");
           let query = `
             SELECT f.* FROM facts f
             JOIN facts_fts fts ON f.rowid = fts.rowid
-            WHERE facts_fts MATCH ? AND f.mind = ? AND f.status = 'active'
+            WHERE facts_fts MATCH ? AND f.mind IN (${ftsPlaceholders}) AND f.status = 'active'
           `;
-          const params: any[] = [ftsQuery, mind];
+          const params: any[] = [ftsQuery, ...ftsChain];
           if (opts?.section) {
             query += ` AND f.section = ?`;
             params.push(opts.section);
@@ -1980,12 +2085,14 @@ export class FactStore {
     const queryDims = queryVec.length;
     const contentHashVal = contentHash(factContent);
 
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const rows = this.db.prepare(`
       SELECT f.*, v.embedding, v.dims FROM facts f
       JOIN facts_vec v ON f.id = v.fact_id
-      WHERE f.mind = ? AND f.section = ? AND f.status = 'active'
+      WHERE f.mind IN (${placeholders}) AND f.section = ? AND f.status = 'active'
         AND f.content_hash != ?
-    `).all(mind, section, contentHashVal) as (Fact & { embedding: Buffer; dims: number })[];
+    `).all(...chain, section, contentHashVal) as (Fact & { embedding: Buffer; dims: number })[];
 
     const results: (Fact & { similarity: number })[] = [];
 
@@ -2071,9 +2178,11 @@ export class FactStore {
 
   /** Get episodes for a mind, ordered by date descending */
   getEpisodes(mind: string, limit?: number): Episode[] {
-    const sql = `SELECT * FROM episodes WHERE mind = ? ORDER BY date DESC` +
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
+    const sql = `SELECT * FROM episodes WHERE mind IN (${placeholders}) ORDER BY date DESC` +
       (limit ? ` LIMIT ${limit}` : "");
-    return this.db.prepare(sql).all(mind) as Episode[];
+    return this.db.prepare(sql).all(...chain) as Episode[];
   }
 
   /** Get a single episode by ID */
@@ -2119,11 +2228,13 @@ export class FactStore {
     const minSim = opts?.minSimilarity ?? 0.3;
     const queryDims = queryVec.length;
 
+    const chain = this.resolveMindChain(mind);
+    const ePlaceholders = chain.map(() => "?").join(", ");
     const rows = this.db.prepare(`
       SELECT e.*, v.embedding, v.dims FROM episodes e
       JOIN episodes_vec v ON e.id = v.episode_id
-      WHERE e.mind = ?
-    `).all(mind) as (Episode & { embedding: Buffer; dims: number })[];
+      WHERE e.mind IN (${ePlaceholders})
+    `).all(...chain) as (Episode & { embedding: Buffer; dims: number })[];
 
     const results: (Episode & { similarity: number })[] = [];
 
@@ -2145,9 +2256,11 @@ export class FactStore {
 
   /** Count episodes for a mind */
   countEpisodes(mind: string): number {
+    const chain = this.resolveMindChain(mind);
+    const placeholders = chain.map(() => "?").join(", ");
     const row = this.db.prepare(
-      `SELECT COUNT(*) as count FROM episodes WHERE mind = ?`
-    ).get(mind);
+      `SELECT COUNT(*) as count FROM episodes WHERE mind IN (${placeholders})`
+    ).get(...chain);
     return row?.count ?? 0;
   }
 

package/extensions/project-memory/index.ts

@@ -660,6 +660,33 @@ export default function (pi: ExtensionAPI) {
       // Best effort
     }
 
+    // Drain mind lifecycle queue after store is initialized — fork/activate/ingest/delete
+    // requests from implement/archive flows that were queued before store existed.
+    drainMindLifecycleQueue(ctx);
+
+    // --- Branch↔mind consistency check for directive minds ---
+    // If the active mind is a directive mind (starts with 'directive/'),
+    // verify the current git branch matches the expected branch.
+    // Directive mind "directive/X" expects branch "feature/X".
+    const currentMind = activeMind();
+    if (currentMind.startsWith("directive/")) {
+      const directiveSuffix = currentMind.slice("directive/".length);
+      const expectedBranch = `feature/${directiveSuffix}`;
+      try {
+        const branchResult = await pi.exec("git", ["branch", "--show-current"], { timeout: 3_000, cwd: ctx.cwd });
+        const currentBranch = branchResult.stdout.trim();
+        if (currentBranch && currentBranch !== expectedBranch) {
+          pi.sendMessage({
+            customType: "directive-branch-mismatch",
+            content: `⚠️ Active directive mind "${currentMind}" expects branch "${expectedBranch}" but you are on "${currentBranch}". Run \`git checkout ${expectedBranch}\` to resume directive work.`,
+            display: false,
+          });
+        }
+      } catch {
+        // Git not available or not a git repo — skip check silently
+      }
+    }
+
     triggerState = createTriggerState();
     postCompaction = false;
     firstTurn = true;
@@ -1339,6 +1366,7 @@ export default function (pi: ExtensionAPI) {
   // --- Context Injection ---
 
   pi.on("before_agent_start", async (event, ctx) => {
+    drainMindLifecycleQueue(ctx);
     drainLifecycleCandidateQueue(ctx);
     drainFactArchiveQueue();
     if (!store) return;
@@ -1904,6 +1932,66 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  function drainMindLifecycleQueue(ctx: ExtensionContext): void {
+    if (!store) return;
+    const queue = sharedState.mindLifecycleQueue ?? [];
+    if (queue.length === 0) return;
+
+    sharedState.mindLifecycleQueue = [];
+
+    for (const req of queue) {
+      try {
+        switch (req.action) {
+          case "fork": {
+            if (store.mindExists(req.mind)) {
+              // Already forked (e.g. resumed directive) — just skip
+              break;
+            }
+            store.forkMind("default", req.mind, req.description ?? `Directive scope: ${req.mind}`);
+            if (ctx.hasUI) {
+              ctx.ui.notify(`[memory] Forked directive mind '${req.mind}'`, "info");
+            }
+            break;
+          }
+          case "activate": {
+            const target = req.mind === "default" ? null : req.mind;
+            if (target && !store.mindExists(target)) {
+              // Mind doesn't exist (e.g. abandoned before archive) — stay on default
+              break;
+            }
+            store.setActiveMind(target);
+            break;
+          }
+          case "ingest": {
+            const targetMind = req.targetMind ?? "default";
+            if (!store.mindExists(req.mind)) {
+              // Source mind doesn't exist — nothing to ingest
+              break;
+            }
+            const result = store.ingestMind(req.mind, targetMind);
+            if (ctx.hasUI) {
+              ctx.ui.notify(
+                `[memory] Merged '${req.mind}' → '${targetMind}': ${result.factsIngested} ingested, ${result.duplicatesSkipped} deduped`,
+                "info",
+              );
+            }
+            break;
+          }
+          case "delete": {
+            if (req.mind === "default") break; // Safety: never delete default
+            if (!store.mindExists(req.mind)) break;
+            store.deleteMind(req.mind);
+            break;
+          }
+        }
+      } catch (error) {
+        console.error(`[project-memory] Mind lifecycle '${req.action}' failed for '${req.mind}':`, error);
+      }
+    }
+
+    updateStatus(ctx);
+  }
+
   // --- Tools ---
 
   pi.registerTool({
@@ -2908,6 +2996,9 @@ export default function (pi: ExtensionAPI) {
 
     const theme = ctx.ui.theme;
     const mind = activeMind();
+
+    // Publish active mind for dashboard directive indicator
+    sharedState.activeMind = mind === "default" ? null : mind;
     const count = store.countActiveFacts(mind);
 
     // Label + fact count as a single unit: "Memory: 2 facts" or "Memory(mind): 2 facts"

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.7.8",
+	"version": "0.8.0",
 	"description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
 	"bin": {
 		"omegon": "bin/omegon.mjs",