gsd-pi 2.39.0 → 2.40.0-dev.4a93031

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -0,0 +1,156 @@
+import { join } from "node:path";
+import { isToolCallEventType } from "@gsd/pi-coding-agent";
+import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
+import { buildBeforeAgentStartResult } from "./system-context.js";
+import { handleAgentEnd } from "./agent-end-recovery.js";
+import { isDepthVerified, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite } from "./write-gate.js";
+import { getDiscussionMilestoneId } from "../guided-flow.js";
+import { loadToolApiKeys } from "../commands-config.js";
+import { loadFile, saveFile, formatContinue } from "../files.js";
+import { deriveState } from "../state.js";
+import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart } from "../auto.js";
+import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
+import { saveActivityLog } from "../activity-log.js";
+import { maybeRenderGsdHeader } from "./register-shortcuts.js";
+export function registerHooks(pi) {
+    pi.on("session_start", async (_event, ctx) => {
+        resetWriteGateState();
+        maybeRenderGsdHeader(ctx);
+        loadToolApiKeys();
+        try {
+            const [{ getRemoteConfigStatus }, { getLatestPromptSummary }] = await Promise.all([
+                import("../../remote-questions/config.js"),
+                import("../../remote-questions/status.js"),
+            ]);
+            const status = getRemoteConfigStatus();
+            const latest = getLatestPromptSummary();
+            if (!status.includes("not configured")) {
+                const suffix = latest ? `\nLast remote prompt: ${latest.id} (${latest.status})` : "";
+                ctx.ui.notify(`${status}${suffix}`, status.includes("disabled") ? "warning" : "info");
+            }
+        }
+        catch {
+            // ignore
+        }
+    });
+    pi.on("before_agent_start", async (event, ctx) => {
+        return buildBeforeAgentStartResult(event, ctx);
+    });
+    pi.on("agent_end", async (event, ctx) => {
+        await handleAgentEnd(pi, event, ctx);
+    });
+    pi.on("session_before_compact", async () => {
+        if (isAutoActive() || isAutoPaused()) {
+            return { cancel: true };
+        }
+        const basePath = process.cwd();
+        const state = await deriveState(basePath);
+        if (!state.activeMilestone || !state.activeSlice || !state.activeTask)
+            return;
+        if (state.phase !== "executing")
+            return;
+        const sliceDir = resolveSlicePath(basePath, state.activeMilestone.id, state.activeSlice.id);
+        if (!sliceDir)
+            return;
+        const existingFile = resolveSliceFile(basePath, state.activeMilestone.id, state.activeSlice.id, "CONTINUE");
+        if (existingFile && await loadFile(existingFile))
+            return;
+        const legacyContinue = join(sliceDir, "continue.md");
+        if (await loadFile(legacyContinue))
+            return;
+        const continuePath = join(sliceDir, `${state.activeSlice.id}-CONTINUE.md`);
+        await saveFile(continuePath, formatContinue({
+            frontmatter: {
+                milestone: state.activeMilestone.id,
+                slice: state.activeSlice.id,
+                task: state.activeTask.id,
+                step: 0,
+                totalSteps: 0,
+                status: "compacted",
+                savedAt: new Date().toISOString(),
+            },
+            completedWork: `Task ${state.activeTask.id} (${state.activeTask.title}) was in progress when compaction occurred.`,
+            remainingWork: "Check the task plan for remaining steps.",
+            decisions: "Check task summary files for prior decisions.",
+            context: "Session was auto-compacted by Pi. Resume with /gsd.",
+            nextAction: `Resume task ${state.activeTask.id}: ${state.activeTask.title}.`,
+        }));
+    });
+    pi.on("session_shutdown", async (_event, ctx) => {
+        if (isParallelActive()) {
+            try {
+                await shutdownParallel(process.cwd());
+            }
+            catch {
+                // best-effort
+            }
+        }
+        if (!isAutoActive() && !isAutoPaused())
+            return;
+        const dash = getAutoDashboardData();
+        if (dash.currentUnit) {
+            saveActivityLog(ctx, dash.basePath, dash.currentUnit.type, dash.currentUnit.id);
+        }
+    });
+    pi.on("tool_call", async (event) => {
+        if (!isToolCallEventType("write", event))
+            return;
+        const result = shouldBlockContextWrite(event.toolName, event.input.path, getDiscussionMilestoneId(), isDepthVerified(), isQueuePhaseActive());
+        if (result.block)
+            return result;
+    });
+    pi.on("tool_result", async (event) => {
+        if (event.toolName !== "ask_user_questions")
+            return;
+        const milestoneId = getDiscussionMilestoneId();
+        if (!milestoneId)
+            return;
+        const details = event.details;
+        if (details?.cancelled || !details?.response)
+            return;
+        const questions = event.input?.questions ?? [];
+        for (const question of questions) {
+            if (typeof question.id === "string" && question.id.includes("depth_verification")) {
+                markDepthVerified();
+                break;
+            }
+        }
+        const basePath = process.cwd();
+        const milestoneDir = resolveMilestonePath(basePath, milestoneId);
+        if (!milestoneDir)
+            return;
+        const discussionPath = join(milestoneDir, buildMilestoneFileName(milestoneId, "DISCUSSION"));
+        const timestamp = new Date().toISOString();
+        const lines = [`## Exchange — ${timestamp}`, ""];
+        for (const question of questions) {
+            lines.push(`### ${question.header ?? "Question"}`, "", question.question ?? "");
+            if (Array.isArray(question.options)) {
+                lines.push("");
+                for (const opt of question.options) {
+                    lines.push(`- **${opt.label}** — ${opt.description ?? ""}`);
+                }
+            }
+            const answer = details.response?.answers?.[question.id];
+            if (answer) {
+                lines.push("");
+                const selected = Array.isArray(answer.selected) ? answer.selected.join(", ") : answer.selected;
+                lines.push(`**Selected:** ${selected}`);
+                if (answer.notes) {
+                    lines.push(`**Notes:** ${answer.notes}`);
+                }
+            }
+            lines.push("");
+        }
+        lines.push("---", "");
+        const existing = await loadFile(discussionPath) ?? `# ${milestoneId} Discussion Log\n\n`;
+        await saveFile(discussionPath, existing + lines.join("\n"));
+    });
+    pi.on("tool_execution_start", async (event) => {
+        if (!isAutoActive())
+            return;
+        markToolStart(event.toolCallId);
+    });
+    pi.on("tool_execution_end", async (event) => {
+        markToolEnd(event.toolCallId);
+    });
+}

package/dist/resources/extensions/gsd/bootstrap/register-shortcuts.js

@@ -0,0 +1,46 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Key, Text } from "@gsd/pi-tui";
+import { GSDDashboardOverlay } from "../dashboard-overlay.js";
+import { shortcutDesc } from "../../shared/mod.js";
+export const GSD_LOGO_LINES = [
+    "   ██████╗ ███████╗██████╗ ",
+    "  ██╔════╝ ██╔════╝██╔══██╗",
+    "  ██║  ███╗███████╗██║  ██║",
+    "  ██║   ██║╚════██║██║  ██║",
+    "  ╚██████╔╝███████║██████╔╝",
+    "   ╚═════╝ ╚══════╝╚═════╝ ",
+];
+export function registerShortcuts(pi) {
+    pi.registerShortcut(Key.ctrlAlt("g"), {
+        description: shortcutDesc("Open GSD dashboard", "/gsd status"),
+        handler: async (ctx) => {
+            if (!existsSync(join(process.cwd(), ".gsd"))) {
+                ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
+                return;
+            }
+            await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done()), {
+                overlay: true,
+                overlayOptions: {
+                    width: "90%",
+                    minWidth: 80,
+                    maxHeight: "92%",
+                    anchor: "center",
+                },
+            });
+        },
+    });
+}
+export function maybeRenderGsdHeader(ctx) {
+    try {
+        const theme = ctx.ui.theme;
+        const version = process.env.GSD_VERSION || "0.0.0";
+        const logoText = GSD_LOGO_LINES.map((line) => theme.fg("accent", line)).join("\n");
+        const titleLine = `  ${theme.bold("Get Shit Done")} ${theme.fg("dim", `v${version}`)}`;
+        const headerContent = `${logoText}\n${titleLine}`;
+        ctx.ui.setHeader((_ui, _theme) => new Text(headerContent, 1, 0));
+    }
+    catch {
+        // no TUI
+    }
+}

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -0,0 +1,300 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { debugTime } from "../debug-logger.js";
+import { loadPrompt } from "../prompt-loader.js";
+import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
+import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
+import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
+import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-command.js";
+import { deriveState } from "../state.js";
+import { formatOverridesSection, loadActiveOverrides, loadFile, parseContinue, parseSummary } from "../files.js";
+import { toPosixPath } from "../../shared/mod.js";
+import { markCmuxPromptShown, shouldPromptToEnableCmux } from "../../cmux/index.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+function warnDeprecatedAgentInstructions() {
+    const paths = [
+        join(gsdHome, "agent-instructions.md"),
+        join(process.cwd(), ".gsd", "agent-instructions.md"),
+    ];
+    for (const path of paths) {
+        if (existsSync(path)) {
+            console.warn(`[GSD] DEPRECATED: ${path} is no longer loaded. ` +
+                `Migrate your instructions to AGENTS.md (or CLAUDE.md) in the same directory. ` +
+                `See https://github.com/gsd-build/GSD-2/issues/1492`);
+        }
+    }
+}
+export async function buildBeforeAgentStartResult(event, ctx) {
+    if (!existsSync(join(process.cwd(), ".gsd")))
+        return undefined;
+    const stopContextTimer = debugTime("context-inject");
+    const systemContent = loadPrompt("system");
+    const loadedPreferences = loadEffectiveGSDPreferences();
+    if (shouldPromptToEnableCmux(loadedPreferences?.preferences)) {
+        markCmuxPromptShown();
+        ctx.ui.notify("cmux detected. Run /gsd cmux on to enable sidebar metadata, notifications, and visual subagent splits for this project.", "info");
+    }
+    let preferenceBlock = "";
+    if (loadedPreferences) {
+        const cwd = process.cwd();
+        const report = resolveAllSkillReferences(loadedPreferences.preferences, cwd);
+        preferenceBlock = `\n\n${renderPreferencesForSystemPrompt(loadedPreferences.preferences, report.resolutions)}`;
+        if (report.warnings.length > 0) {
+            ctx.ui.notify(`GSD skill preferences: ${report.warnings.length} unresolved skill${report.warnings.length === 1 ? "" : "s"}: ${report.warnings.join(", ")}`, "warning");
+        }
+    }
+    let knowledgeBlock = "";
+    const knowledgePath = resolveGsdRootFile(process.cwd(), "KNOWLEDGE");
+    if (existsSync(knowledgePath)) {
+        try {
+            const content = readFileSync(knowledgePath, "utf-8").trim();
+            if (content) {
+                knowledgeBlock = `\n\n[PROJECT KNOWLEDGE — Rules, patterns, and lessons learned]\n\n${content}`;
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    let memoryBlock = "";
+    try {
+        const { formatMemoriesForPrompt, getActiveMemoriesRanked } = await import("../memory-store.js");
+        const memories = getActiveMemoriesRanked(30);
+        if (memories.length > 0) {
+            const formatted = formatMemoriesForPrompt(memories, 2000);
+            if (formatted) {
+                memoryBlock = `\n\n${formatted}`;
+            }
+        }
+    }
+    catch {
+        // non-fatal
+    }
+    let newSkillsBlock = "";
+    if (hasSkillSnapshot()) {
+        const newSkills = detectNewSkills();
+        if (newSkills.length > 0) {
+            newSkillsBlock = formatSkillsXml(newSkills);
+        }
+    }
+    warnDeprecatedAgentInstructions();
+    const injection = await buildGuidedExecuteContextInjection(event.prompt, process.cwd());
+    const worktreeBlock = buildWorktreeContextBlock();
+    const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}`;
+    stopContextTimer({
+        systemPromptSize: fullSystem.length,
+        injectionSize: injection?.length ?? 0,
+        hasPreferences: preferenceBlock.length > 0,
+        hasNewSkills: newSkillsBlock.length > 0,
+    });
+    return {
+        systemPrompt: fullSystem,
+        ...(injection
+            ? {
+                message: {
+                    customType: "gsd-guided-context",
+                    content: injection,
+                    display: false,
+                },
+            }
+            : {}),
+    };
+}
+function buildWorktreeContextBlock() {
+    const worktreeName = getActiveWorktreeName();
+    const worktreeMainCwd = getWorktreeOriginalCwd();
+    const autoWorktree = getActiveAutoWorktreeContext();
+    if (worktreeName && worktreeMainCwd) {
+        return [
+            "",
+            "",
+            "[WORKTREE CONTEXT — OVERRIDES CURRENT WORKING DIRECTORY ABOVE]",
+            `IMPORTANT: Ignore the "Current working directory" shown earlier in this prompt.`,
+            `The actual current working directory is: ${toPosixPath(process.cwd())}`,
+            "",
+            `You are working inside a GSD worktree.`,
+            `- Worktree name: ${worktreeName}`,
+            `- Worktree path (this is the real cwd): ${toPosixPath(process.cwd())}`,
+            `- Main project: ${toPosixPath(worktreeMainCwd)}`,
+            `- Branch: worktree/${worktreeName}`,
+            "",
+            "All file operations, bash commands, and GSD state resolve against the worktree path above.",
+            "Use /worktree merge to merge changes back. Use /worktree return to switch back to the main tree.",
+        ].join("\n");
+    }
+    if (autoWorktree) {
+        return [
+            "",
+            "",
+            "[WORKTREE CONTEXT — OVERRIDES CURRENT WORKING DIRECTORY ABOVE]",
+            `IMPORTANT: Ignore the "Current working directory" shown earlier in this prompt.`,
+            `The actual current working directory is: ${toPosixPath(process.cwd())}`,
+            "",
+            "You are working inside a GSD auto-worktree.",
+            `- Milestone worktree: ${autoWorktree.worktreeName}`,
+            `- Worktree path (this is the real cwd): ${toPosixPath(process.cwd())}`,
+            `- Main project: ${toPosixPath(autoWorktree.originalBase)}`,
+            `- Branch: ${autoWorktree.branch}`,
+            "",
+            "All file operations, bash commands, and GSD state resolve against the worktree path above.",
+            "Write every .gsd artifact in the worktree path above, never in the main project tree.",
+        ].join("\n");
+    }
+    return "";
+}
+async function buildGuidedExecuteContextInjection(prompt, basePath) {
+    const executeMatch = prompt.match(/Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
+    if (executeMatch) {
+        const [, taskId, taskTitle, sliceId, milestoneId] = executeMatch;
+        return buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, taskId, taskTitle);
+    }
+    const resumeMatch = prompt.match(/Resume interrupted work\.[\s\S]*?slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
+    if (resumeMatch) {
+        const [, sliceId, milestoneId] = resumeMatch;
+        const state = await deriveState(basePath);
+        if (state.activeMilestone?.id === milestoneId && state.activeSlice?.id === sliceId && state.activeTask) {
+            return buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, state.activeTask.id, state.activeTask.title);
+        }
+    }
+    return null;
+}
+async function buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, taskId, taskTitle) {
+    const taskPlanPath = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "PLAN");
+    const taskPlanRelPath = relTaskFile(basePath, milestoneId, sliceId, taskId, "PLAN");
+    const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
+    const taskPlanInline = taskPlanContent
+        ? ["## Inlined Task Plan (authoritative local execution contract)", `Source: \`${taskPlanRelPath}\``, "", taskPlanContent.trim()].join("\n")
+        : ["## Inlined Task Plan (authoritative local execution contract)", `Task plan not found at dispatch time. Read \`${taskPlanRelPath}\` before executing.`].join("\n");
+    const slicePlanPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN");
+    const slicePlanRelPath = relSliceFile(basePath, milestoneId, sliceId, "PLAN");
+    const slicePlanContent = slicePlanPath ? await loadFile(slicePlanPath) : null;
+    const slicePlanExcerpt = extractSliceExecutionExcerpt(slicePlanContent, slicePlanRelPath);
+    const priorTaskLines = await buildCarryForwardLines(basePath, milestoneId, sliceId, taskId);
+    const resumeSection = await buildResumeSection(basePath, milestoneId, sliceId);
+    const activeOverrides = await loadActiveOverrides(basePath);
+    const overridesSection = formatOverridesSection(activeOverrides);
+    return [
+        "[GSD Guided Execute Context]",
+        "Use this injected context as startup context for guided task execution. Treat the inlined task plan as the authoritative local execution contract. Use source artifacts to verify details and run checks.",
+        overridesSection, "",
+        "",
+        resumeSection,
+        "",
+        "## Carry-Forward Context",
+        ...priorTaskLines,
+        "",
+        taskPlanInline,
+        "",
+        slicePlanExcerpt,
+        "",
+        "## Backing Source Artifacts",
+        `- Slice plan: \`${slicePlanRelPath}\``,
+        `- Task plan source: \`${taskPlanRelPath}\``,
+    ].join("\n");
+}
+async function buildCarryForwardLines(basePath, milestoneId, sliceId, taskId) {
+    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (!tasksDir)
+        return ["- No prior task summaries in this slice."];
+    const currentNum = parseInt(taskId.replace(/^T/, ""), 10);
+    const sliceRel = relSlicePath(basePath, milestoneId, sliceId);
+    const summaryFiles = resolveTaskFiles(tasksDir, "SUMMARY")
+        .filter((file) => parseInt(file.replace(/^T/, ""), 10) < currentNum)
+        .sort();
+    if (summaryFiles.length === 0)
+        return ["- No prior task summaries in this slice."];
+    return Promise.all(summaryFiles.map(async (file) => {
+        const absPath = join(tasksDir, file);
+        const content = await loadFile(absPath);
+        const relPath = `${sliceRel}/tasks/${file}`;
+        if (!content)
+            return `- \`${relPath}\``;
+        const summary = parseSummary(content);
+        const provided = summary.frontmatter.provides.slice(0, 2).join("; ");
+        const decisions = summary.frontmatter.key_decisions.slice(0, 2).join("; ");
+        const patterns = summary.frontmatter.patterns_established.slice(0, 2).join("; ");
+        const diagnostics = extractMarkdownSection(content, "Diagnostics");
+        const parts = [summary.title || relPath];
+        if (summary.oneLiner)
+            parts.push(summary.oneLiner);
+        if (provided)
+            parts.push(`provides: ${provided}`);
+        if (decisions)
+            parts.push(`decisions: ${decisions}`);
+        if (patterns)
+            parts.push(`patterns: ${patterns}`);
+        if (diagnostics)
+            parts.push(`diagnostics: ${oneLine(diagnostics)}`);
+        return `- \`${relPath}\` — ${parts.join(" | ")}`;
+    }));
+}
+async function buildResumeSection(basePath, milestoneId, sliceId) {
+    const continueFile = resolveSliceFile(basePath, milestoneId, sliceId, "CONTINUE");
+    const legacyDir = resolveSlicePath(basePath, milestoneId, sliceId);
+    const legacyPath = legacyDir ? join(legacyDir, "continue.md") : null;
+    const continueContent = continueFile ? await loadFile(continueFile) : null;
+    const legacyContent = !continueContent && legacyPath ? await loadFile(legacyPath) : null;
+    const resolvedContent = continueContent ?? legacyContent;
+    const resolvedRelPath = continueContent
+        ? relSliceFile(basePath, milestoneId, sliceId, "CONTINUE")
+        : (legacyPath ? `${relSlicePath(basePath, milestoneId, sliceId)}/continue.md` : null);
+    if (!resolvedContent || !resolvedRelPath) {
+        return ["## Resume State", "- No continue file present. Start from the top of the task plan."].join("\n");
+    }
+    const cont = parseContinue(resolvedContent);
+    const lines = [
+        "## Resume State",
+        `Source: \`${resolvedRelPath}\``,
+        `- Status: ${cont.frontmatter.status || "in_progress"}`,
+    ];
+    if (cont.frontmatter.step && cont.frontmatter.totalSteps) {
+        lines.push(`- Progress: step ${cont.frontmatter.step} of ${cont.frontmatter.totalSteps}`);
+    }
+    if (cont.completedWork)
+        lines.push(`- Completed: ${oneLine(cont.completedWork)}`);
+    if (cont.remainingWork)
+        lines.push(`- Remaining: ${oneLine(cont.remainingWork)}`);
+    if (cont.decisions)
+        lines.push(`- Decisions: ${oneLine(cont.decisions)}`);
+    if (cont.nextAction)
+        lines.push(`- Next action: ${oneLine(cont.nextAction)}`);
+    return lines.join("\n");
+}
+function extractSliceExecutionExcerpt(content, relPath) {
+    if (!content) {
+        return ["## Slice Plan Excerpt", `Slice plan not found at dispatch time. Read \`${relPath}\` before running slice-level verification.`].join("\n");
+    }
+    const lines = content.split("\n");
+    const goalLine = lines.find((line) => line.startsWith("**Goal:**"))?.trim();
+    const demoLine = lines.find((line) => line.startsWith("**Demo:**"))?.trim();
+    const verification = extractMarkdownSection(content, "Verification");
+    const observability = extractMarkdownSection(content, "Observability / Diagnostics");
+    const parts = ["## Slice Plan Excerpt", `Source: \`${relPath}\``];
+    if (goalLine)
+        parts.push(goalLine);
+    if (demoLine)
+        parts.push(demoLine);
+    if (verification)
+        parts.push("", "### Slice Verification", verification.trim());
+    if (observability)
+        parts.push("", "### Slice Observability / Diagnostics", observability.trim());
+    return parts.join("\n");
+}
+function extractMarkdownSection(content, heading) {
+    const match = new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m").exec(content);
+    if (!match)
+        return null;
+    const start = match.index + match[0].length;
+    const rest = content.slice(start);
+    const nextHeading = rest.match(/^##\s+/m);
+    const end = nextHeading?.index ?? rest.length;
+    return rest.slice(0, end).trim();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -0,0 +1,38 @@
+const MILESTONE_CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
+let depthVerificationDone = false;
+let activeQueuePhase = false;
+export function isDepthVerified() {
+    return depthVerificationDone;
+}
+export function isQueuePhaseActive() {
+    return activeQueuePhase;
+}
+export function setQueuePhaseActive(active) {
+    activeQueuePhase = active;
+}
+export function resetWriteGateState() {
+    depthVerificationDone = false;
+}
+export function clearDiscussionFlowState() {
+    depthVerificationDone = false;
+    activeQueuePhase = false;
+}
+export function markDepthVerified() {
+    depthVerificationDone = true;
+}
+export function shouldBlockContextWrite(toolName, inputPath, milestoneId, depthVerified, queuePhaseActive) {
+    if (toolName !== "write")
+        return { block: false };
+    const inDiscussion = milestoneId !== null;
+    const inQueue = queuePhaseActive ?? false;
+    if (!inDiscussion && !inQueue)
+        return { block: false };
+    if (!MILESTONE_CONTEXT_RE.test(inputPath))
+        return { block: false };
+    if (depthVerified)
+        return { block: false };
+    return {
+        block: true,
+        reason: `Blocked: Cannot write to milestone CONTEXT.md during discussion phase without depth verification. Call ask_user_questions with question id "depth_verification" first to confirm discussion depth before writing context.`,
+    };
+}