gsd-pi 2.67.0-dev.43b0159 → 2.67.0-dev.4fb8afe

package/src/resources/extensions/gsd/bootstrap/query-tools.ts

@@ -2,8 +2,8 @@
 
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
-
-import { logWarning } from "../workflow-logger.js";
+import { ensureDbOpen } from "./dynamic-tools.js";
+import { executeMilestoneStatus } from "../tools/workflow-tool-executors.js";
 
 export function registerQueryTools(pi: ExtensionAPI): void {
   pi.registerTool({
@@ -21,79 +21,14 @@ export function registerQueryTools(pi: ExtensionAPI): void {
       milestoneId: Type.String({ description: "Milestone ID to query (e.g. M001)" }),
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      try {
-        // Open the DB if not already open — safe for read-only use since
-        // ensureDbOpen() only creates/migrates when .gsd/ has content (#3644).
-        const { ensureDbOpen } = await import("./dynamic-tools.js");
-        const dbAvailable = await ensureDbOpen();
-        const {
-          getMilestone,
-          getSliceStatusSummary,
-          getSliceTaskCounts,
-          _getAdapter,
-        } = await import("../gsd-db.js");
-
-        if (!dbAvailable) {
-          return {
-            content: [{ type: "text" as const, text: "Error: GSD database is not available." }],
-            details: { operation: "milestone_status", error: "db_unavailable" } as any,
-          };
-        }
-
-        // Wrap all reads in a single transaction for snapshot consistency.
-        // SQLite WAL mode guarantees reads within a transaction see a single
-        // consistent snapshot, preventing torn reads from concurrent writes.
-        const adapter = _getAdapter()!;
-        adapter.exec("BEGIN");  // eslint-disable-line -- SQLite exec, not child_process
-        try {
-          const milestone = getMilestone(params.milestoneId);
-          if (!milestone) {
-            adapter.exec("COMMIT");  // eslint-disable-line
-            return {
-              content: [{ type: "text" as const, text: `Milestone ${params.milestoneId} not found in database.` }],
-              details: { operation: "milestone_status", milestoneId: params.milestoneId, found: false } as any,
-            };
-          }
-
-          const sliceStatuses = getSliceStatusSummary(params.milestoneId);
-
-          const slices = sliceStatuses.map((s) => {
-            const counts = getSliceTaskCounts(params.milestoneId, s.id);
-            return {
-              id: s.id,
-              status: s.status,
-              taskCounts: counts,
-            };
-          });
-
-          adapter.exec("COMMIT");  // eslint-disable-line
-
-          const result = {
-            milestoneId: milestone.id,
-            title: milestone.title,
-            status: milestone.status,
-            createdAt: milestone.created_at,
-            completedAt: milestone.completed_at,
-            sliceCount: slices.length,
-            slices,
-          };
-
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
-            details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length } as any,
-          };
-        } catch (txErr) {
-          try { adapter.exec("ROLLBACK"); } catch { /* swallow */ }  // eslint-disable-line
-          throw txErr;
-        }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logWarning("tool", `gsd_milestone_status tool failed: ${msg}`);
+      const dbAvailable = await ensureDbOpen();
+      if (!dbAvailable) {
         return {
-          content: [{ type: "text" as const, text: `Error querying milestone status: ${msg}` }],
-          details: { operation: "milestone_status", error: msg } as any,
+          content: [{ type: "text", text: "Error: GSD database is not available. Cannot read milestone status." }],
+          details: { operation: "milestone_status", error: "db_unavailable" },
         };
       }
+      return executeMilestoneStatus(params);
     },
   });
 }

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -11,6 +11,7 @@ import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
 import { resolveSkillReference } from "../preferences-skills.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
+import { ensureCodebaseMapFresh, readCodebaseMap } from "../codebase-generator.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
 import { getActiveAutoWorktreeContext } from "../auto-worktree.js";
 import { getActiveWorktreeName, getWorktreeOriginalCwd } from "../worktree-command.js";
@@ -128,10 +129,24 @@ export async function buildBeforeAgentStartResult(
   }
 
   let codebaseBlock = "";
+  try {
+    const codebaseOptions = loadedPreferences?.preferences?.codebase
+      ? {
+          excludePatterns: loadedPreferences.preferences.codebase.exclude_patterns,
+          maxFiles: loadedPreferences.preferences.codebase.max_files,
+          collapseThreshold: loadedPreferences.preferences.codebase.collapse_threshold,
+        }
+      : undefined;
+    ensureCodebaseMapFresh(process.cwd(), codebaseOptions);
+  } catch (e) {
+    logWarning("bootstrap", `CODEBASE refresh failed: ${(e as Error).message}`);
+  }
+
   const codebasePath = resolveGsdRootFile(process.cwd(), "CODEBASE");
-  if (existsSync(codebasePath)) {
+  const rawCodebase = readCodebaseMap(process.cwd());
+  if (existsSync(codebasePath) && rawCodebase) {
     try {
-      const rawContent = readFileSync(codebasePath, "utf-8").trim();
+      const rawContent = rawCodebase.trim();
       if (rawContent) {
         // Cap injection size to ~2 000 tokens to avoid bloating every request.
         // Full map is always available at .gsd/CODEBASE.md.
@@ -141,7 +156,7 @@ export async function buildBeforeAgentStartResult(
         const content = rawContent.length > MAX_CODEBASE_CHARS
           ? rawContent.slice(0, MAX_CODEBASE_CHARS) + "\n\n*(truncated — see .gsd/CODEBASE.md for full map)*"
           : rawContent;
-        codebaseBlock = `\n\n[PROJECT CODEBASE — File structure and descriptions (generated ${generatedAt}, may be stale — run /gsd codebase update to refresh)]\n\n${content}`;
+        codebaseBlock = `\n\n[PROJECT CODEBASE — File structure and descriptions (generated ${generatedAt}, auto-refreshed when GSD detects tracked file changes; use /gsd codebase stats for status)]\n\n${content}`;
       }
     } catch (e) {
       logWarning("bootstrap", `CODEBASE file read failed: ${(e as Error).message}`);
@@ -494,4 +509,3 @@ export function clearForensicsMarker(basePath: string): void {
     }
   }
 }
-

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -1,3 +1,6 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
 const MILESTONE_CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
 const CONTEXT_MILESTONE_RE = /(?:^|[/\\])(M\d+(?:-[a-z0-9]{6})?)-CONTEXT\.md$/i;
 const DEPTH_VERIFICATION_MILESTONE_RE = /depth_verification[_-](M\d+(?:-[a-z0-9]{6})?)/i;
@@ -65,6 +68,69 @@ const GATE_SAFE_TOOLS = new Set([
   "search_and_read",
 ]);
 
+export interface WriteGateSnapshot {
+  verifiedDepthMilestones: string[];
+  activeQueuePhase: boolean;
+  pendingGateId: string | null;
+}
+
+function shouldPersistWriteGateSnapshot(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.GSD_PERSIST_WRITE_GATE_STATE === "1";
+}
+
+function writeGateSnapshotPath(basePath: string = process.cwd()): string {
+  return join(basePath, ".gsd", "runtime", "write-gate-state.json");
+}
+
+function currentWriteGateSnapshot(): WriteGateSnapshot {
+  return {
+    verifiedDepthMilestones: [...verifiedDepthMilestones].sort(),
+    activeQueuePhase,
+    pendingGateId,
+  };
+}
+
+function persistWriteGateSnapshot(basePath: string = process.cwd()): void {
+  if (!shouldPersistWriteGateSnapshot()) return;
+  const path = writeGateSnapshotPath(basePath);
+  mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+  const tempPath = `${path}.tmp`;
+  writeFileSync(tempPath, JSON.stringify(currentWriteGateSnapshot(), null, 2), "utf-8");
+  renameSync(tempPath, path);
+}
+
+function clearPersistedWriteGateSnapshot(basePath: string = process.cwd()): void {
+  if (!shouldPersistWriteGateSnapshot()) return;
+  const path = writeGateSnapshotPath(basePath);
+  try {
+    unlinkSync(path);
+  } catch {
+    // swallow
+  }
+}
+
+function normalizeWriteGateSnapshot(value: unknown): WriteGateSnapshot {
+  const record = value && typeof value === "object" ? value as Record<string, unknown> : {};
+  const verified = Array.isArray(record.verifiedDepthMilestones)
+    ? record.verifiedDepthMilestones.filter((item): item is string => typeof item === "string")
+    : [];
+  return {
+    verifiedDepthMilestones: [...new Set(verified)].sort(),
+    activeQueuePhase: record.activeQueuePhase === true,
+    pendingGateId: typeof record.pendingGateId === "string" ? record.pendingGateId : null,
+  };
+}
+
+export function loadWriteGateSnapshot(basePath: string = process.cwd()): WriteGateSnapshot {
+  const path = writeGateSnapshotPath(basePath);
+  if (!existsSync(path)) return currentWriteGateSnapshot();
+  try {
+    return normalizeWriteGateSnapshot(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    return currentWriteGateSnapshot();
+  }
+}
+
 export function isDepthVerified(): boolean {
   return verifiedDepthMilestones.size > 0;
 }
@@ -77,28 +143,40 @@ export function isMilestoneDepthVerified(milestoneId: string | null | undefined)
   return verifiedDepthMilestones.has(milestoneId);
 }
 
+export function isMilestoneDepthVerifiedInSnapshot(
+  snapshot: WriteGateSnapshot,
+  milestoneId: string | null | undefined,
+): boolean {
+  if (!milestoneId) return false;
+  return snapshot.verifiedDepthMilestones.includes(milestoneId);
+}
+
 export function isQueuePhaseActive(): boolean {
   return activeQueuePhase;
 }
 
 export function setQueuePhaseActive(active: boolean): void {
   activeQueuePhase = active;
+  persistWriteGateSnapshot();
 }
 
 export function resetWriteGateState(): void {
   verifiedDepthMilestones.clear();
   pendingGateId = null;
+  persistWriteGateSnapshot();
 }
 
 export function clearDiscussionFlowState(): void {
   verifiedDepthMilestones.clear();
   activeQueuePhase = false;
   pendingGateId = null;
+  clearPersistedWriteGateSnapshot();
 }
 
-export function markDepthVerified(milestoneId?: string | null): void {
+export function markDepthVerified(milestoneId?: string | null, basePath: string = process.cwd()): void {
   if (!milestoneId) return;
   verifiedDepthMilestones.add(milestoneId);
+  persistWriteGateSnapshot(basePath);
 }
 
 /**
@@ -130,6 +208,7 @@ function extractContextMilestoneId(inputPath: string): string | null {
  */
 export function setPendingGate(gateId: string): void {
   pendingGateId = gateId;
+  persistWriteGateSnapshot();
 }
 
 /**
@@ -137,6 +216,7 @@ export function setPendingGate(gateId: string): void {
  */
 export function clearPendingGate(): void {
   pendingGateId = null;
+  persistWriteGateSnapshot();
 }
 
 /**
@@ -154,11 +234,20 @@ export function getPendingGate(): string | null {
  * Read-only tools and ask_user_questions itself are always allowed.
  */
 export function shouldBlockPendingGate(
+  toolName: string,
+  milestoneId: string | null,
+  queuePhaseActive?: boolean,
+): { block: boolean; reason?: string } {
+  return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(), toolName, milestoneId, queuePhaseActive);
+}
+
+export function shouldBlockPendingGateInSnapshot(
+  snapshot: WriteGateSnapshot,
   toolName: string,
   _milestoneId: string | null,
   _queuePhaseActive?: boolean,
 ): { block: boolean; reason?: string } {
-  if (!pendingGateId) return { block: false };
+  if (!snapshot.pendingGateId) return { block: false };
 
   if (GATE_SAFE_TOOLS.has(toolName)) return { block: false };
 
@@ -168,7 +257,7 @@ export function shouldBlockPendingGate(
   return {
     block: true,
     reason: [
-      `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+      `HARD BLOCK: Discussion gate "${snapshot.pendingGateId}" has not been confirmed by the user.`,
       `You MUST re-call ask_user_questions with the gate question before making any other tool calls.`,
       `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
       `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
@@ -182,11 +271,20 @@ export function shouldBlockPendingGate(
  * Read-only bash commands are allowed; mutating commands are blocked.
  */
 export function shouldBlockPendingGateBash(
+  command: string,
+  milestoneId: string | null,
+  queuePhaseActive?: boolean,
+): { block: boolean; reason?: string } {
+  return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(), command, milestoneId, queuePhaseActive);
+}
+
+export function shouldBlockPendingGateBashInSnapshot(
+  snapshot: WriteGateSnapshot,
   command: string,
   _milestoneId: string | null,
   _queuePhaseActive?: boolean,
 ): { block: boolean; reason?: string } {
-  if (!pendingGateId) return { block: false };
+  if (!snapshot.pendingGateId) return { block: false };
 
   // Allow read-only bash commands
   if (BASH_READ_ONLY_RE.test(command)) return { block: false };
@@ -194,7 +292,7 @@ export function shouldBlockPendingGateBash(
   return {
     block: true,
     reason: [
-      `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+      `HARD BLOCK: Discussion gate "${snapshot.pendingGateId}" has not been confirmed by the user.`,
       `You MUST re-call ask_user_questions with the gate question before running mutating commands.`,
       `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
       `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
@@ -275,6 +373,15 @@ export function shouldBlockContextArtifactSave(
   artifactType: string,
   milestoneId: string | null,
   sliceId?: string | null,
+): { block: boolean; reason?: string } {
+  return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(), artifactType, milestoneId, sliceId);
+}
+
+export function shouldBlockContextArtifactSaveInSnapshot(
+  snapshot: WriteGateSnapshot,
+  artifactType: string,
+  milestoneId: string | null,
+  sliceId?: string | null,
 ): { block: boolean; reason?: string } {
   if (artifactType !== "CONTEXT") return { block: false };
   if (sliceId) return { block: false };
@@ -287,7 +394,7 @@ export function shouldBlockContextArtifactSave(
       ].join(" "),
     };
   }
-  if (isMilestoneDepthVerified(milestoneId)) return { block: false };
+  if (isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId)) return { block: false };
 
   return {
     block: true,
@@ -317,6 +424,15 @@ export function shouldBlockQueueExecution(
   toolName: string,
   input: string,
   queuePhaseActive: boolean,
+): { block: boolean; reason?: string } {
+  return shouldBlockQueueExecutionInSnapshot(currentWriteGateSnapshot(), toolName, input, queuePhaseActive);
+}
+
+export function shouldBlockQueueExecutionInSnapshot(
+  snapshot: WriteGateSnapshot,
+  toolName: string,
+  input: string,
+  queuePhaseActive: boolean = snapshot.activeQueuePhase,
 ): { block: boolean; reason?: string } {
   if (!queuePhaseActive) return { block: false };