gsd-pi 2.81.0-dev.72a81bdf3 → 2.82.0-dev.2841a1e44

package/dist/resources/extensions/gsd/provider-switch-observer.js

@@ -0,0 +1,146 @@
+// GSD-2 — ADR-005 Phase 3b: surface ProviderSwitchReport from pi-ai.
+//
+// pi-ai builds a ProviderSwitchReport on every cross-provider transform but
+// only logs it to stderr when GSD_VERBOSE=1. This module installs a
+// single-subscriber observer that surfaces non-empty reports through GSD's
+// three usual telemetry surfaces:
+//
+//   1. UOK audit event (category model-policy, type provider-switch) — only
+//      when an auto trace is active.
+//   2. Persistent notification (.gsd/notifications.jsonl, severity warning) —
+//      whenever the GSD basePath is known, so users see the loss in the
+//      dashboard / status surface without GSD_VERBOSE.
+//   3. In-memory counter, exposed via getProviderSwitchStats() so any
+//      caller (dashboard, doctor, tests) can read the rollup.
+import { setProviderSwitchObserver } from "@gsd/pi-ai";
+import { autoSession } from "./auto-runtime-state.js";
+import { appendNotification } from "./notification-store.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+const INTERACTIVE_TRACE_KEY = "interactive";
+let installed = false;
+let totalSwitches = 0;
+const totals = {
+    thinkingBlocksDropped: 0,
+    thinkingBlocksDowngraded: 0,
+    toolCallIdsRemapped: 0,
+    syntheticToolResultsInserted: 0,
+    thoughtSignaturesDropped: 0,
+};
+const byTrace = new Map();
+let lastReport = null;
+let lastAt = null;
+/** Format a one-line summary suitable for a notification message. */
+function summarize(report) {
+    const parts = [];
+    if (report.thinkingBlocksDropped > 0)
+        parts.push(`${report.thinkingBlocksDropped} thinking dropped`);
+    if (report.thinkingBlocksDowngraded > 0)
+        parts.push(`${report.thinkingBlocksDowngraded} thinking downgraded`);
+    if (report.toolCallIdsRemapped > 0)
+        parts.push(`${report.toolCallIdsRemapped} tool ids remapped`);
+    if (report.syntheticToolResultsInserted > 0)
+        parts.push(`${report.syntheticToolResultsInserted} synthetic tool results`);
+    if (report.thoughtSignaturesDropped > 0)
+        parts.push(`${report.thoughtSignaturesDropped} thought signatures dropped`);
+    return `Provider switch ${report.fromApi} → ${report.toApi}: ${parts.join(", ")}`;
+}
+function recordReport(report) {
+    const now = new Date().toISOString();
+    totalSwitches += 1;
+    totals.thinkingBlocksDropped += report.thinkingBlocksDropped;
+    totals.thinkingBlocksDowngraded += report.thinkingBlocksDowngraded;
+    totals.toolCallIdsRemapped += report.toolCallIdsRemapped;
+    totals.syntheticToolResultsInserted += report.syntheticToolResultsInserted;
+    totals.thoughtSignaturesDropped += report.thoughtSignaturesDropped;
+    lastReport = report;
+    lastAt = now;
+    const traceKey = autoSession.currentTraceId ?? INTERACTIVE_TRACE_KEY;
+    const existing = byTrace.get(traceKey);
+    if (existing) {
+        existing.switches += 1;
+        existing.lastReport = report;
+        existing.lastAt = now;
+    }
+    else {
+        byTrace.set(traceKey, { switches: 1, lastReport: report, lastAt: now });
+    }
+}
+function emitAudit(report) {
+    const traceId = autoSession.currentTraceId;
+    const basePath = autoSession.basePath;
+    if (!traceId || !basePath)
+        return;
+    try {
+        emitUokAuditEvent(basePath, buildAuditEnvelope({
+            traceId,
+            category: "model-policy",
+            type: "provider-switch",
+            payload: {
+                fromApi: report.fromApi,
+                toApi: report.toApi,
+                thinkingBlocksDropped: report.thinkingBlocksDropped,
+                thinkingBlocksDowngraded: report.thinkingBlocksDowngraded,
+                toolCallIdsRemapped: report.toolCallIdsRemapped,
+                syntheticToolResultsInserted: report.syntheticToolResultsInserted,
+                thoughtSignaturesDropped: report.thoughtSignaturesDropped,
+            },
+        }));
+    }
+    catch {
+        // Audit emission is best-effort. Counter + notification still fire.
+    }
+}
+function emitNotification(report) {
+    try {
+        appendNotification(summarize(report), "warning", "workflow-logger");
+    }
+    catch {
+        // Notification persistence is best-effort.
+    }
+}
+function handleReport(report) {
+    recordReport(report);
+    emitAudit(report);
+    emitNotification(report);
+}
+/**
+ * Install the pi-ai observer. Idempotent — calling more than once is a no-op
+ * after the first install.
+ */
+export function installProviderSwitchObserver() {
+    if (installed)
+        return;
+    setProviderSwitchObserver(handleReport);
+    installed = true;
+}
+/** Uninstall the observer. Intended for tests. */
+export function uninstallProviderSwitchObserver() {
+    setProviderSwitchObserver(undefined);
+    installed = false;
+}
+/** Read-only snapshot of the in-memory rollup. */
+export function getProviderSwitchStats() {
+    const trace = {};
+    for (const [key, value] of byTrace) {
+        trace[key] = { switches: value.switches, lastReport: { ...value.lastReport }, lastAt: value.lastAt };
+    }
+    return {
+        totalSwitches,
+        totals: { ...totals },
+        byTrace: trace,
+        lastReport: lastReport ? { ...lastReport } : null,
+        lastAt,
+    };
+}
+/** Reset the in-memory rollup. Intended for tests. */
+export function _resetProviderSwitchStats() {
+    totalSwitches = 0;
+    totals.thinkingBlocksDropped = 0;
+    totals.thinkingBlocksDowngraded = 0;
+    totals.toolCallIdsRemapped = 0;
+    totals.syntheticToolResultsInserted = 0;
+    totals.thoughtSignaturesDropped = 0;
+    byTrace.clear();
+    lastReport = null;
+    lastAt = null;
+}

package/dist/resources/extensions/gsd/templates/knowledge.md

@@ -1,7 +1,7 @@
 # Project Knowledge
 
-Append-only register of project-specific rules, patterns, and lessons learned.
-Agents read this before every unit. Add entries when you discover something worth remembering.
+Project-specific rules plus projected patterns and lessons learned.
+Rules are maintained in this file. Patterns and lessons are persisted to the memories table and rendered here on the next session-start projection.
 
 ## Rules
 

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Adapts shared GSD workflow handlers for MCP executor calls.
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
@@ -12,6 +14,9 @@ import { handleCompleteSlice } from "./complete-slice.js";
 import { handlePlanMilestone } from "./plan-milestone.js";
 import { handlePlanSlice } from "./plan-slice.js";
 import { handleReplanSlice } from "./replan-slice.js";
+import { handleReopenMilestone } from "./reopen-milestone.js";
+import { handleReopenSlice } from "./reopen-slice.js";
+import { handleReopenTask } from "./reopen-task.js";
 import { handleReassessRoadmap } from "./reassess-roadmap.js";
 import { handleValidateMilestone } from "./validate-milestone.js";
 import { logError, logWarning } from "../workflow-logger.js";
@@ -274,6 +279,120 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
         };
     }
 }
+export async function executeTaskReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen task." }],
+            details: { operation: "reopen_task", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenTask(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening task: ${result.error}` }],
+                details: { operation: "reopen_task", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
+            details: {
+                operation: "reopen_task",
+                taskId: result.taskId,
+                sliceId: result.sliceId,
+                milestoneId: result.milestoneId,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_task tool failed: ${msg}`, { tool: "gsd_task_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening task: ${msg}` }],
+            details: { operation: "reopen_task", error: msg },
+            isError: true,
+        };
+    }
+}
+export async function executeSliceReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen slice." }],
+            details: { operation: "reopen_slice", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenSlice(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening slice: ${result.error}` }],
+                details: { operation: "reopen_slice", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened slice ${result.sliceId} (${result.milestoneId})` }],
+            details: {
+                operation: "reopen_slice",
+                sliceId: result.sliceId,
+                milestoneId: result.milestoneId,
+                tasksReset: result.tasksReset,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_slice tool failed: ${msg}`, { tool: "gsd_slice_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening slice: ${msg}` }],
+            details: { operation: "reopen_slice", error: msg },
+            isError: true,
+        };
+    }
+}
+export async function executeMilestoneReopen(params, basePath = process.cwd()) {
+    const dbAvailable = await ensureDbOpen(basePath);
+    if (!dbAvailable) {
+        return {
+            content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen milestone." }],
+            details: { operation: "reopen_milestone", error: "db_unavailable" },
+            isError: true,
+        };
+    }
+    try {
+        const result = await handleReopenMilestone(params, basePath);
+        if ("error" in result) {
+            return {
+                content: [{ type: "text", text: `Error reopening milestone: ${result.error}` }],
+                details: { operation: "reopen_milestone", error: result.error },
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: `Reopened milestone ${result.milestoneId}` }],
+            details: {
+                operation: "reopen_milestone",
+                milestoneId: result.milestoneId,
+                slicesReset: result.slicesReset,
+                tasksReset: result.tasksReset,
+            },
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logError("tool", `reopen_milestone tool failed: ${msg}`, { tool: "gsd_milestone_reopen", error: String(err) });
+        return {
+            content: [{ type: "text", text: `Error reopening milestone: ${msg}` }],
+            details: { operation: "reopen_milestone", error: msg },
+            isError: true,
+        };
+    }
+}
 export async function executeSliceComplete(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -227,7 +227,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: true,
         preferences: "active-only",
         contextMode: "research",
-        tools: TOOLS_PLANNING,
+        // Multi-slice research dispatches use the research-slice unit contract to
+        // fan out scout subagents that write .gsd research artifacts.
+        tools: TOOLS_PLANNING_DISPATCH_RECON,
         artifacts: {
             inline: ["roadmap", "milestone-research", "dependency-summaries", "templates"],
             excerpt: [],
@@ -384,7 +386,9 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        tools: TOOLS_PLANNING,
+        // Gate evaluation fans out tester-style subagents, which read the slice
+        // plan and report via the DB-backed gate-result tool.
+        tools: TOOLS_PLANNING_DISPATCH_REVIEW,
         artifacts: {
             inline: ["slice-plan", "prior-task-summaries"],
             excerpt: [],
@@ -509,3 +513,22 @@ export const UNIT_MANIFESTS = {
 export function resolveManifest(unitType) {
     return UNIT_MANIFESTS[unitType] ?? null;
 }
+export function compileSubagentPermissionContract(policy) {
+    if (!policy) {
+        return { allowed: false, allowedSubagents: [], toolsMode: "unknown" };
+    }
+    if (policy.mode === "all") {
+        return { allowed: true, allowedSubagents: ["*"], toolsMode: policy.mode };
+    }
+    if (policy.mode === "planning-dispatch") {
+        return {
+            allowed: true,
+            allowedSubagents: [...policy.allowedSubagents],
+            toolsMode: policy.mode,
+        };
+    }
+    return { allowed: false, allowedSubagents: [], toolsMode: policy.mode };
+}
+export function resolveSubagentPermissionContract(unitType) {
+    return compileSubagentPermissionContract(resolveManifest(unitType)?.tools);
+}

package/dist/resources/extensions/gsd/verification-verdict.js

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Host-owned verification verdict policy for auto-mode units.
+export function decideVerificationVerdict(unitType, result) {
+    if (unitType === "execute-task" && result.discoverySource === "none" && result.checks.length === 0) {
+        return {
+            passed: false,
+            reason: "no-host-checks",
+            retryable: false,
+            failureContext: "No runnable host-owned verification command was discovered. Add project verification_commands or a runnable task-plan Verify command before completing this execute-task.",
+        };
+    }
+    if (!result.passed) {
+        return {
+            passed: false,
+            reason: "checks-failed",
+            retryable: true,
+            failureContext: "",
+        };
+    }
+    return {
+        passed: true,
+        reason: "passed",
+        retryable: false,
+        failureContext: "",
+    };
+}

package/dist/resources/extensions/gsd/worktree-lifecycle.js

@@ -1198,17 +1198,36 @@ export class WorktreeLifecycle {
         }
     }
     /**
-     * Restore `s.basePath` to `s.originalBasePath` and rebuild `s.gitService`.
-     * No-op when `originalBasePath` is empty (fresh sessions).
+     * Restore `s.basePath` to `s.originalBasePath`, chdir process cwd, and
+     * rebuild `s.gitService`. No-op when `originalBasePath` is empty (fresh
+     * sessions).
      *
      * Used by error/cleanup paths that need the session to behave as if the
      * worktree was never entered. Does NOT teardown the worktree directory —
      * callers that need teardown go through `exitMilestone({ merge: false })`.
+     *
+     * ADR-016 phase 3 (#5693): chdir lives inside the verb so callers do not
+     * pair `restoreToProjectRoot()` with a redundant `process.chdir`. The
+     * chdir runs BEFORE the throwable work (`rebuildGitService`, cache
+     * invalidation) so that cleanup-path cwd is restored even if the
+     * downstream rebuild throws. The chdir itself is best-effort; failure is
+     * logged via debugLog and swallowed.
      */
     restoreToProjectRoot() {
         if (!this.s.originalBasePath)
             return;
         this.s.basePath = this.s.originalBasePath;
+        try {
+            process.chdir(this.s.basePath);
+        }
+        catch (err) {
+            debugLog("WorktreeLifecycle", {
+                action: "restoreToProjectRoot",
+                result: "chdir-failed",
+                basePath: this.s.basePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
         rebuildGitService(this.s, this.deps);
         invalidateAllCaches();
     }