@opengsd/gsd-pi 1.1.1-dev.9bb7453 → 1.1.1-dev.9f86580

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

@@ -4,7 +4,7 @@ import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
 import { minimatch } from "minimatch";
 
-import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
+import { GSD_PHASE_SCOPE_DISPLAY_REASON, shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import { getIsolationMode } from "../preferences.js";
 import { compileSubagentPermissionContract, type ToolsPolicy } from "../unit-context-manifest.js";
 import { logWarning } from "../workflow-logger.js";
@@ -772,6 +772,20 @@ function blockReason(unitType: string, mode: string, what: string): string {
   ].join(" ");
 }
 
+function planningBlock(unitType: string, mode: string, what: string): PlanningUnitBlockResult {
+  return {
+    block: true,
+    reason: blockReason(unitType, mode, what),
+    displayReason: GSD_PHASE_SCOPE_DISPLAY_REASON,
+  };
+}
+
+type PlanningUnitBlockResult = {
+  block: boolean;
+  reason?: string;
+  displayReason?: string;
+};
+
 /**
  * Planning-unit tool-policy enforcement. Returns { block } per the policy
  * resolved from the active unit's manifest:
@@ -812,7 +826,7 @@ export function shouldBlockPlanningUnit(
   agentClasses?: readonly string[],
   toolInput?: unknown,
   unitId?: string,
-): { block: boolean; reason?: string } {
+): PlanningUnitBlockResult {
   const tool = canonicalToolName(toolName);
   const autoScopeGuard = shouldBlockAutoUnitToolCall(unitType, toolName, toolInput, unitId);
   if (autoScopeGuard.block) return autoScopeGuard;
@@ -825,10 +839,10 @@ export function shouldBlockPlanningUnit(
     if (PLANNING_SAFE_TOOLS.has(tool)) return { block: false };
     if (tool.startsWith("gsd_")) return { block: false };
     if (PLANNING_WRITE_TOOLS.has(tool) || tool === "bash" || PLANNING_SUBAGENT_TOOLS.has(tool)) {
-      return { block: true, reason: blockReason(unitType, policy.mode, `${tool} is not permitted (read-only)`) };
+      return planningBlock(unitType, policy.mode, `${tool} is not permitted (read-only)`);
     }
     // Unknown tool in read-only mode — block by default.
-    return { block: true, reason: blockReason(unitType, policy.mode, `tool "${tool}" is not on the read-only allowlist`) };
+    return planningBlock(unitType, policy.mode, `tool "${tool}" is not on the read-only allowlist`);
   }
 
   // planning / planning-dispatch / docs / verification modes share the same surface for safe tools, bash, and subagent.
@@ -846,14 +860,11 @@ export function shouldBlockPlanningUnit(
       // instead of silently bypassing the gate.
       if (agentClasses === undefined) {
         warnMissingControlledDispatchAgentClasses(unitType, policy.mode, tool);
-        return {
-          block: true,
-          reason: blockReason(
-            unitType,
-            policy.mode,
-            `subagent dispatch blocked: stale caller did not supply agent identities for "${tool}"; update extractSubagentAgentClasses to handle this input shape`,
-          ),
-        };
+        return planningBlock(
+          unitType,
+          policy.mode,
+          `subagent dispatch blocked: stale caller did not supply agent identities for "${tool}"; update extractSubagentAgentClasses to handle this input shape`,
+        );
       }
       // agentClasses was explicitly provided but resolved to an empty list (for
       // example, a bare tool call with no agent field). Pass through; no agents
@@ -863,57 +874,45 @@ export function shouldBlockPlanningUnit(
       }
       const globallyDisallowed = requested.find(a => !isReadOnlySpecialist(a));
       if (globallyDisallowed) {
-        return {
-          block: true,
-          reason: blockReason(
-            unitType,
-            policy.mode,
-            `subagent dispatch of "${globallyDisallowed}" not permitted; only read-only specialists (${allowedPlanningDispatchAgentsList()}) may be dispatched from ${policy.mode} units`,
-          ),
-        };
+        return planningBlock(
+          unitType,
+          policy.mode,
+          `subagent dispatch of "${globallyDisallowed}" not permitted; only read-only specialists (${allowedPlanningDispatchAgentsList()}) may be dispatched from ${policy.mode} units`,
+        );
       }
       const disallowedByPolicy = requested.find(a => !allowed.has(a));
       if (disallowedByPolicy) {
-        return {
-          block: true,
-          reason: blockReason(
-            unitType,
-            policy.mode,
-            `subagent dispatch of "${disallowedByPolicy}" not permitted by ToolsPolicy.allowedSubagents; permitted agents for this unit: ${allowedSubagents.join(", ")}`,
-          ),
-        };
+        return planningBlock(
+          unitType,
+          policy.mode,
+          `subagent dispatch of "${disallowedByPolicy}" not permitted by ToolsPolicy.allowedSubagents; permitted agents for this unit: ${allowedSubagents.join(", ")}`,
+        );
       }
       return { block: false };
     }
-    return { block: true, reason: blockReason(unitType, policy.mode, `subagent dispatch is not permitted in planning units`) };
+    return planningBlock(unitType, policy.mode, "subagent dispatch is not permitted in planning units");
   }
 
   if (tool === "bash") {
     if (policy.mode === "verification") {
       if (BASH_VERIFICATION_RE.test(pathOrCommand) || BASH_READ_ONLY_RE.test(pathOrCommand)) return { block: false };
-      return {
-        block: true,
-        reason: blockReason(
-          unitType,
-          policy.mode,
-          `bash is restricted to build/test verification commands (npm run build, npm test, etc.); cannot run "${pathOrCommand.slice(0, 80)}${pathOrCommand.length > 80 ? "…" : ""}"`,
-        ),
-      };
-    }
-    if (BASH_READ_ONLY_RE.test(pathOrCommand)) return { block: false };
-    return {
-      block: true,
-      reason: blockReason(
+      return planningBlock(
         unitType,
         policy.mode,
-        `bash is restricted to read-only commands (cat/grep/git log/etc); cannot run "${pathOrCommand.slice(0, 80)}${pathOrCommand.length > 80 ? "…" : ""}"`,
-      ),
-    };
+        `bash is restricted to build/test verification commands (npm run build, npm test, etc.); cannot run "${pathOrCommand.slice(0, 80)}${pathOrCommand.length > 80 ? "…" : ""}"`,
+      );
+    }
+    if (BASH_READ_ONLY_RE.test(pathOrCommand)) return { block: false };
+    return planningBlock(
+      unitType,
+      policy.mode,
+      `bash is restricted to read-only commands (cat/grep/git log/etc); cannot run "${pathOrCommand.slice(0, 80)}${pathOrCommand.length > 80 ? "…" : ""}"`,
+    );
   }
 
   if (PLANNING_WRITE_TOOLS.has(tool)) {
     if (!pathOrCommand) {
-      return { block: true, reason: blockReason(unitType, policy.mode, `${tool} called with empty path`) };
+      return planningBlock(unitType, policy.mode, `${tool} called with empty path`);
     }
     const absPath = isAbsolute(pathOrCommand) ? pathOrCommand : resolve(basePath, pathOrCommand);
 
@@ -925,14 +924,11 @@ export function shouldBlockPlanningUnit(
       return { block: false };
     }
 
-    return {
-      block: true,
-      reason: blockReason(
-        unitType,
-        policy.mode,
-        `cannot ${tool} "${pathOrCommand}" — writes are restricted to .gsd/${policy.mode === "docs" ? " and " + policy.allowedPathGlobs.join(", ") : ""}`,
-      ),
-    };
+    return planningBlock(
+      unitType,
+      policy.mode,
+      `cannot ${tool} "${pathOrCommand}" — writes are restricted to .gsd/${policy.mode === "docs" ? " and " + policy.allowedPathGlobs.join(", ") : ""}`,
+    );
   }
 
   // Unknown tool name — pass through. Other layers (queue, pending-gate,

package/src/resources/extensions/gsd/closeout-consistency-gate.ts

@@ -0,0 +1,137 @@
+// Project/App: gsd-pi
+// File Purpose: Shared DB-backed guard for milestone closeout finalization.
+
+import {
+  getDbPath,
+  getLatestAssessmentByScope,
+  getMilestone,
+  getMilestoneSlices,
+  getPendingGates,
+  getSliceTasks,
+  isDbAvailable,
+  refreshOpenDatabaseFromDisk,
+} from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
+
+export const CLOSEOUT_CONSISTENCY_BLOCKED_REASON = "closeout-consistency-blocked";
+
+export type CloseoutConsistencyFailureReason =
+  | "db-unavailable"
+  | "db-refresh-failed"
+  | "milestone-missing"
+  | "milestone-open"
+  | "validation-not-pass"
+  | "slice-missing"
+  | "slice-open"
+  | "task-open"
+  | "quality-gate-pending";
+
+export type CloseoutConsistencyResult =
+  | { ok: true }
+  | {
+      ok: false;
+      reason: CloseoutConsistencyFailureReason;
+      recoveryReason: typeof CLOSEOUT_CONSISTENCY_BLOCKED_REASON;
+      message: string;
+    };
+
+export interface CloseoutConsistencyOptions {
+  refreshFromDisk?: boolean;
+}
+
+function blocked(reason: CloseoutConsistencyFailureReason, message: string): CloseoutConsistencyResult {
+  return {
+    ok: false,
+    reason,
+    recoveryReason: CLOSEOUT_CONSISTENCY_BLOCKED_REASON,
+    message,
+  };
+}
+
+function isFileBackedDbPath(path: string | null): boolean {
+  return Boolean(path && path !== ":memory:");
+}
+
+export function checkCloseoutConsistencyGate(
+  milestoneId: string,
+  options: CloseoutConsistencyOptions = {},
+): CloseoutConsistencyResult {
+  if (!isDbAvailable()) {
+    return blocked(
+      "db-unavailable",
+      `Closeout consistency blocked for ${milestoneId}: canonical DB is unavailable.`,
+    );
+  }
+
+  if (options.refreshFromDisk && isFileBackedDbPath(getDbPath()) && !refreshOpenDatabaseFromDisk()) {
+    return blocked(
+      "db-refresh-failed",
+      `Closeout consistency blocked for ${milestoneId}: canonical DB refresh failed.`,
+    );
+  }
+
+  const milestone = getMilestone(milestoneId);
+  if (!milestone) {
+    return blocked(
+      "milestone-missing",
+      `Closeout consistency blocked for ${milestoneId}: milestone is missing from canonical DB.`,
+    );
+  }
+  if (!isClosedStatus(milestone.status)) {
+    return blocked(
+      "milestone-open",
+      `Closeout consistency blocked for ${milestoneId}: canonical DB milestone status is "${milestone.status}".`,
+    );
+  }
+
+  if (milestone.status !== "skipped") {
+    const validation = getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    if (validation?.status !== "pass") {
+      return blocked(
+        "validation-not-pass",
+        `Closeout consistency blocked for ${milestoneId}: latest milestone validation is "${validation?.status ?? "absent"}".`,
+      );
+    }
+  }
+
+  const slices = getMilestoneSlices(milestoneId);
+  if (slices.length === 0 && milestone.status !== "skipped") {
+    return blocked(
+      "slice-missing",
+      `Closeout consistency blocked for ${milestoneId}: no slices exist in canonical DB.`,
+    );
+  }
+
+  for (const slice of slices) {
+    if (!isClosedStatus(slice.status)) {
+      return blocked(
+        "slice-open",
+        `Closeout consistency blocked for ${milestoneId}: slice ${slice.id} status is "${slice.status}".`,
+      );
+    }
+
+    for (const task of getSliceTasks(milestoneId, slice.id)) {
+      if (!isClosedStatus(task.status)) {
+        return blocked(
+          "task-open",
+          `Closeout consistency blocked for ${milestoneId}: task ${slice.id}/${task.id} status is "${task.status}".`,
+        );
+      }
+    }
+
+    const pendingGate = getPendingGates(milestoneId, slice.id)[0];
+    if (pendingGate) {
+      return blocked(
+        "quality-gate-pending",
+        `Closeout consistency blocked for ${milestoneId}: quality gate ${pendingGate.gate_id} is still pending for ${slice.id}.`,
+      );
+    }
+  }
+
+  return { ok: true };
+}
+
+export function formatCloseoutConsistencyBlock(result: CloseoutConsistencyResult): string {
+  if (result.ok) return "";
+  return `${result.message} Recovery reason: ${result.recoveryReason}. Resolve the canonical DB state and run /gsd auto to retry.`;
+}

package/src/resources/extensions/gsd/commands/handlers/auto.ts

@@ -209,6 +209,15 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
   if (trimmed === "") {
     if (!(await guardRemoteSession(ctx, pi))) return true;
     const basePath = projectRoot();
+    // Cold start after /quit lands at the project root, not the worktree. If the
+    // active milestone has a live worktree, chdir back into it now so the agent
+    // doesn't have to search for it. Best-effort; resolves to a no-op otherwise.
+    try {
+      const { reenterActiveWorktreeIfNeeded } = await import("../../worktree-reentry.js");
+      await reenterActiveWorktreeIfNeeded(basePath, {
+        notify: (message) => ctx.ui.notify(message, "info"),
+      });
+    } catch { /* non-fatal */ }
     const { hasGsdBootstrapArtifacts } = await import("../../detection.js");
     const { gsdRoot } = await import("../../paths.js");
     if (!hasGsdBootstrapArtifacts(gsdRoot(basePath))) {

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -73,7 +73,7 @@ export function formatMcpInitResult(
     `Config:   ${configPath}`,
     "",
     "MCP-capable clients can now load the GSD workflow and gsd-browser MCP servers from this folder.",
-    "Pi Providers use the managed gsd-browser engine directly; this project config is for External MCP Clients.",
+    "Pi Providers use built-in browser tools directly; this project config is for External MCP Clients.",
     "Restart or reconnect any client that already has this project open.",
   ].join("\n");
 }

package/src/resources/extensions/gsd/config-overlay.ts

@@ -139,6 +139,7 @@ function collectConfigSections(): ConfigSection[] {
     if (sup.model) supRows.push({ label: "Model", value: sup.model });
     supRows.push({ label: "Soft timeout", value: `${sup.soft_timeout_minutes}m` });
     supRows.push({ label: "Idle timeout", value: `${sup.idle_timeout_minutes}m` });
+    supRows.push({ label: "Stalled tool timeout", value: `${sup.stalled_tool_timeout_minutes}m` });
     supRows.push({ label: "Hard timeout", value: `${sup.hard_timeout_minutes}m` });
     sections.push({ title: "Auto Supervisor", rows: supRows });
   }

package/src/resources/extensions/gsd/context-masker.ts

@@ -5,10 +5,17 @@
  * Reduces context bloat between compactions with zero LLM overhead.
  * Preserves message ordering, roles, and all assistant/user messages.
  *
- * Operates on the pi-ai Message[] format (post-convertToLlm, pre-provider):
+ * Operates on provider payloads after convertToLlm:
+ *
+ * pi-ai Message[] payloads:
  *   - toolResult messages: { role: "toolResult", content: TextContent[] }
  *   - bash results are already converted to: { role: "user", content: [{type:"text",text:"..."}] }
  *     and start with "Ran `" from bashExecutionToText.
+ *
+ * OpenAI/Codex Responses payloads:
+ *   - conversation items live in `input`, not `messages`
+ *   - tool results are { type: "function_call_output", output: string | content[] }
+ *   - bash results are user items with input_text content starting with "Ran `"
  */
 
 interface MaskableMessage {
@@ -20,6 +27,37 @@ interface MaskableMessage {
 
 const MASK_PLACEHOLDER = "[result masked — within summarized history]";
 const MASK_CONTENT_BLOCK = [{ type: "text" as const, text: MASK_PLACEHOLDER }];
+const RESPONSES_MASK_CONTENT_BLOCK = [{ type: "input_text" as const, text: MASK_PLACEHOLDER }];
+const TRUNCATION_MARKER = "\n…[truncated]";
+
+type TextLikeBlock = {
+  type?: string;
+  text?: unknown;
+  [key: string]: unknown;
+};
+
+interface ResponsesInputItem {
+  role?: string;
+  type?: string;
+  content?: unknown;
+  output?: unknown;
+  [key: string]: unknown;
+}
+
+function isTextLikeBlock(block: unknown): block is TextLikeBlock {
+  return Boolean(block && typeof block === "object" && "text" in block);
+}
+
+function firstTextFromContent(content: unknown): string | undefined {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return undefined;
+  const first = content.find(isTextLikeBlock);
+  return typeof first?.text === "string" ? first.text : undefined;
+}
+
+function isBashResultText(text: string | undefined): boolean {
+  return typeof text === "string" && text.startsWith("Ran `");
+}
 
 function findTurnBoundary(messages: MaskableMessage[], keepRecentTurns: number): number {
   let turnsSeen = 0;
@@ -43,10 +81,8 @@ function findTurnBoundary(messages: MaskableMessage[], keepRecentTurns: number):
  * The bashExecutionToText format always starts with "Ran `".
  */
 function isBashResultUserMessage(m: MaskableMessage): boolean {
-  if (m.role !== "user" || !Array.isArray(m.content)) return false;
-  const first = m.content[0];
-  return first && typeof first === "object" && "text" in first &&
-    typeof first.text === "string" && first.text.startsWith("Ran `");
+  if (m.role !== "user") return false;
+  return isBashResultText(firstTextFromContent(m.content));
 }
 
 function isMaskableMessage(m: MaskableMessage): boolean {
@@ -72,3 +108,114 @@ export function createObservationMask(keepRecentTurns: number = 8) {
     });
   };
 }
+
+function isResponsesBashResultUserItem(item: ResponsesInputItem): boolean {
+  if (item.role !== "user") return false;
+  return isBashResultText(firstTextFromContent(item.content));
+}
+
+function findResponsesTurnBoundary(items: ResponsesInputItem[], keepRecentTurns: number): number {
+  let turnsSeen = 0;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i];
+    if (item.role === "user" && !isResponsesBashResultUserItem(item)) {
+      turnsSeen++;
+      if (turnsSeen >= keepRecentTurns) return i;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Observation masking for OpenAI/Codex Responses API payloads.
+ *
+ * Responses payloads store the conversation under `input` instead of
+ * `messages`, with tool results as `function_call_output` items. Keep this
+ * separate from createObservationMask so each payload shape stays explicit.
+ */
+export function createResponsesInputObservationMask(keepRecentTurns: number = 8) {
+  return (items: ResponsesInputItem[]): ResponsesInputItem[] => {
+    const boundary = findResponsesTurnBoundary(items, keepRecentTurns);
+    if (boundary === 0) return items;
+
+    return items.map((item, i) => {
+      if (i >= boundary) return item;
+      if (item.type === "function_call_output") {
+        return { ...item, output: MASK_PLACEHOLDER };
+      }
+      if (isResponsesBashResultUserItem(item)) {
+        return { ...item, content: RESPONSES_MASK_CONTENT_BLOCK };
+      }
+      return item;
+    });
+  };
+}
+
+function truncateText(text: string, maxChars: number): string {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + TRUNCATION_MARKER;
+}
+
+function truncateTextBlocks(content: unknown, maxChars: number): unknown {
+  if (typeof content === "string") {
+    return truncateText(content, maxChars);
+  }
+  if (!Array.isArray(content)) return content;
+
+  let remaining = maxChars;
+  let didTruncate = false;
+  const nextBlocks: unknown[] = [];
+
+  for (const block of content) {
+    if (!isTextLikeBlock(block) || typeof block.text !== "string") {
+      nextBlocks.push(block);
+      continue;
+    }
+
+    if (remaining <= 0) {
+      didTruncate = true;
+      continue;
+    }
+
+    const text = block.text;
+    if (text.length <= remaining) {
+      nextBlocks.push(block);
+      remaining -= text.length;
+      continue;
+    }
+
+    nextBlocks.push({ ...block, text: truncateText(text, remaining) });
+    remaining = 0;
+    didTruncate = true;
+  }
+
+  return didTruncate ? nextBlocks : content;
+}
+
+function normalizedMaxChars(maxChars: number): number {
+  return Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : 800;
+}
+
+export function truncateContextResultMessages(messages: MaskableMessage[], maxChars: number = 800): MaskableMessage[] {
+  const limit = normalizedMaxChars(maxChars);
+  return messages.map((message) => {
+    if (!isMaskableMessage(message)) return message;
+    const content = truncateTextBlocks(message.content, limit);
+    return content === message.content ? message : { ...message, content };
+  });
+}
+
+export function truncateResponsesInputResultItems(items: ResponsesInputItem[], maxChars: number = 800): ResponsesInputItem[] {
+  const limit = normalizedMaxChars(maxChars);
+  return items.map((item) => {
+    if (item.type === "function_call_output") {
+      const output = truncateTextBlocks(item.output, limit);
+      return output === item.output ? item : { ...item, output };
+    }
+    if (isResponsesBashResultUserItem(item)) {
+      const content = truncateTextBlocks(item.content, limit);
+      return content === item.content ? item : { ...item, content };
+    }
+    return item;
+  });
+}