gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.8b8d129d7

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

@@ -3,7 +3,7 @@
 // Discovery order (D003): preference → task plan verify → package.json scripts.
 // First non-empty source wins.
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { DEFAULT_COMMAND_TIMEOUT_MS } from "./constants.js";
 import { rewriteCommandWithRtk } from "../shared/rtk.js";
@@ -27,7 +27,9 @@ const PACKAGE_SCRIPT_KEYS = ["typecheck", "lint", "test"];
  *   1. Explicit preference commands
  *   2. Task plan verify field (split on &&)
  *   3. package.json scripts (typecheck, lint, test)
- *   4. None found
+ *   4. Python pytest project markers
+ *   5. Dependency-free Node test files
+ *   6. None found
  */
 export function discoverCommands(options) {
     // 1. Preference commands
@@ -72,9 +74,76 @@ export function discoverCommands(options) {
             // Malformed package.json — fall through to "none"
         }
     }
-    // 4. Nothing found
+    const pythonCommand = discoverPythonPytestCommand(options.cwd);
+    if (pythonCommand) {
+        return { commands: [pythonCommand], source: "python-project" };
+    }
+    const nodeTestCommand = discoverNodeTestFileCommand(options.cwd);
+    if (nodeTestCommand) {
+        return { commands: [nodeTestCommand], source: "node-test-file" };
+    }
+    // 6. Nothing found
     return { commands: [], source: "none" };
 }
+function discoverNodeTestFileCommand(cwd) {
+    let entries;
+    try {
+        entries = readdirSync(cwd, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    const testFile = entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .filter((name) => /^test-[A-Za-z0-9._-]+\.js$|^[A-Za-z0-9._-]+\.test\.js$/.test(name))
+        .sort()[0];
+    return testFile ? `node ${testFile}` : null;
+}
+function discoverPythonPytestCommand(cwd) {
+    const hasPythonTestFiles = hasPythonTests(join(cwd, "tests"));
+    const hasPytestConfig = existsSync(join(cwd, "pytest.ini"));
+    const pyprojectPath = join(cwd, "pyproject.toml");
+    const hasPyproject = existsSync(pyprojectPath);
+    if (!hasPythonTestFiles && !hasPytestConfig && !hasPyproject) {
+        return null;
+    }
+    if (hasPytestConfig || hasPythonTestFiles) {
+        return "python3 -m pytest";
+    }
+    try {
+        const pyproject = readFileSync(pyprojectPath, "utf-8");
+        if (pyproject.includes("[tool.pytest]") ||
+            pyproject.includes("[tool.pytest.") ||
+            pyproject.includes("[pytest]") ||
+            pyproject.includes("[tool:pytest]")) {
+            return "python3 -m pytest";
+        }
+    }
+    catch {
+        // Ignore unreadable pyproject.toml and fall through.
+    }
+    return null;
+}
+function hasPythonTests(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory() && hasPythonTests(path)) {
+            return true;
+        }
+        if (entry.isFile() && /^test_.*\.py$|^.*_test\.py$/.test(entry.name)) {
+            return true;
+        }
+    }
+    return false;
+}
 // ─── Failure Context Formatting ──────────────────────────────────────────────
 /** Maximum chars of stderr to include per failed check in failure context. */
 const MAX_STDERR_PER_CHECK = 2_000;
@@ -112,7 +181,7 @@ export function formatFailureContext(result) {
 }
 // ─── Gate Execution ─────────────────────────────────────────────────────────
 /** Characters that indicate shell injection when found in a command string. */
-const SHELL_INJECTION_PATTERN = /[;|`]|\$\(/;
+const SHELL_INJECTION_PATTERN = /[;|`<>]|\$\(/;
 /**
  * Known executable first-tokens that are safe to run.
  * Lowercase commands, common build/test tools, and npm/yarn/pnpm invocations.
@@ -148,6 +217,7 @@ const KNOWN_COMMAND_PREFIXES = new Set([
  * Heuristics (any true → prose-like):
  *   1. First token starts with an uppercase letter and the string has 4+ words
  *   2. String contains commas followed by spaces (prose clause structure)
+ *   3. First token has no ASCII letters or digits and the string has 4+ words
  */
 export function isLikelyCommand(cmd) {
     const trimmed = cmd.trim();
@@ -173,19 +243,48 @@ export function isLikelyCommand(cmd) {
     // First token has uppercase letters and no path separators → prose
     if (/[A-Z]/.test(firstToken) && !firstToken.includes("/"))
         return false;
+    // Non-ASCII prose with multiple words should not be executed as a command.
+    if (!/[A-Za-z0-9]/.test(firstToken) && tokens.length >= 4)
+        return false;
     return true;
 }
 /**
  * Validate a command string for obvious shell injection patterns.
  * Returns the command unchanged if safe, or null if suspicious.
  */
+export function validateVerificationCommand(cmd) {
+    if (SHELL_INJECTION_PATTERN.test(cmd)) {
+        return { ok: false, reason: "contains shell control syntax such as pipes, redirects, semicolons, backticks, or command substitution" };
+    }
+    if (!isLikelyCommand(cmd)) {
+        return { ok: false, reason: "does not look like a runnable command" };
+    }
+    return { ok: true };
+}
 function sanitizeCommand(cmd) {
-    if (SHELL_INJECTION_PATTERN.test(cmd))
-        return null;
-    if (!isLikelyCommand(cmd))
+    const validation = validateVerificationCommand(cmd);
+    if (!validation.ok)
         return null;
     return cmd;
 }
+function mergeDiscoverySource(sources) {
+    if (sources.length === 0)
+        return "none";
+    const first = sources[0];
+    if (sources.every((source) => source === first))
+        return first;
+    const precedence = [
+        "preference",
+        "task-plan",
+        "package-json",
+        "python-project",
+    ];
+    for (const source of precedence) {
+        if (sources.includes(source))
+            return source;
+    }
+    return "none";
+}
 /**
  * Run the verification gate: discover commands, execute each via spawnSync,
  * and return a structured result.
@@ -251,6 +350,42 @@ export function runVerificationGate(options) {
         timestamp,
     };
 }
+export function runVerificationGateForTargets(options) {
+    const timestamp = Date.now();
+    if (options.targets.length === 0) {
+        return {
+            passed: true,
+            checks: [],
+            discoverySource: "none",
+            timestamp,
+        };
+    }
+    const checks = [];
+    const sources = [];
+    let passed = true;
+    for (const target of options.targets) {
+        const result = runVerificationGate({
+            cwd: target.cwd,
+            preferenceCommands: options.preferenceCommands ?? target.preferenceCommands,
+            taskPlanVerify: options.taskPlanVerify,
+            commandTimeoutMs: options.commandTimeoutMs,
+        });
+        passed = passed && result.passed;
+        sources.push(result.discoverySource);
+        for (const check of result.checks) {
+            checks.push({
+                ...check,
+                command: target.id === "project" ? check.command : `[${target.id}] ${check.command}`,
+            });
+        }
+    }
+    return {
+        passed,
+        checks,
+        discoverySource: mergeDiscoverySource(sources),
+        timestamp,
+    };
+}
 // ─── Runtime Error Capture ──────────────────────────────────────────────────
 /** Maximum characters of browser console text to retain per entry. */
 const MAX_BROWSER_TEXT_CHARS = 500;

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/workflow-manifest.js

@@ -83,6 +83,7 @@ export function snapshotState() {
             proof_level: r["proof_level"] ?? "",
             integration_closure: r["integration_closure"] ?? "",
             observability_impact: r["observability_impact"] ?? "",
+            target_repositories: JSON.parse(r["target_repositories"] || "[]"),
             sequence: toNumeric(r["sequence"], 0),
             replan_triggered_at: r["replan_triggered_at"] ?? null,
             is_sketch: toNumeric(r["is_sketch"], 0),
@@ -114,6 +115,7 @@ export function snapshotState() {
             expected_output: JSON.parse(r["expected_output"] || "[]"),
             observability_impact: r["observability_impact"] ?? "",
             full_plan_md: r["full_plan_md"] ?? "",
+            target_repositories: JSON.parse(r["target_repositories"] || "[]"),
             sequence: toNumeric(r["sequence"], 0),
             blocker_source: r["blocker_source"] ?? "",
             escalation_pending: toNumeric(r["escalation_pending"], 0),

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -322,6 +322,16 @@ function hasAskUserQuestionsTool(activeTools) {
         return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === "ask_user_questions";
     });
 }
+function hasRequiredTool(requiredTool, activeTools) {
+    return activeTools.some((toolName) => {
+        if (toolName === requiredTool)
+            return true;
+        if (!toolName.startsWith("mcp__"))
+            return false;
+        const toolSeparator = toolName.indexOf("__", "mcp__".length);
+        return toolSeparator >= 0 && toolName.slice(toolSeparator + 2) === requiredTool;
+    });
+}
 function workflowMcpStructuredQuestionsOptIn(env = process.env) {
     const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS;
     return value === "1" || value === "true";
@@ -352,8 +362,14 @@ export function getWorkflowTransportSupportError(provider, requiredTools, option
     if (!launch) {
         return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: the GSD workflow MCP server is not configured or discoverable. Detected Claude Code model but no workflow MCP. Please run /gsd mcp init . from your project root. You can also configure GSD_WORKFLOW_MCP_COMMAND, build packages/mcp-server/dist/cli.js, or install gsd-mcp-server on PATH.`;
     }
-    const missing = [...new Set(requiredTools)].filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
+    const uniqueRequired = [...new Set(requiredTools)];
+    const missing = (options.activeTools && options.activeTools.length > 0)
+        ? uniqueRequired.filter((tool) => !hasRequiredTool(tool, options.activeTools))
+        : uniqueRequired.filter((tool) => !MCP_WORKFLOW_TOOL_SURFACE.has(tool));
     if (missing.length === 0)
         return null;
+    if (options.activeTools && options.activeTools.length > 0) {
+        return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the active runtime toolset currently exposes only ${options.activeTools.slice().sort().join(", ")}.`;
+    }
     return `Provider ${providerLabel} cannot run ${surface}${unitLabel}: this unit requires ${missing.join(", ")}, but the workflow MCP transport currently exposes only ${Array.from(MCP_WORKFLOW_TOOL_SURFACE).sort().join(", ")}.`;
 }

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -150,11 +150,11 @@ export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
     }
     // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
     const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
-        ? taskRow.key_files.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${taskRow.key_files.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const keyDecisionsYaml = taskRow.key_decisions && taskRow.key_decisions.length > 0
-        ? taskRow.key_decisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${taskRow.key_decisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     // Derive verification_result from evidence if available
     const evidenceList = evidence ?? [];
     const allPassed = evidenceList.length > 0 &&
@@ -182,10 +182,8 @@ export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
 id: ${taskRow.id}
 parent: ${sliceId}
 milestone: ${milestoneId}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 duration: ${taskRow.duration || ""}
 verification_result: ${verificationResult}
 completed_at: ${taskRow.completed_at || ""}

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

@@ -20,6 +20,7 @@ import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { emitJournalEvent } from "./journal.js";
 import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare, } from "./worktree-root.js";
@@ -48,6 +49,11 @@ import { nativeCheckoutBranch } from "./native-git-bridge.js";
 // is the only Module that calls them, and they live alongside the Module's
 // other primitives in `auto-worktree.ts`.
 import { autoWorktreeBranch, createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, getAutoWorktreePath, isInAutoWorktree, teardownAutoWorktree, } from "./auto-worktree.js";
+const recentWorktreeMergeFailures = new Map();
+const MERGE_FAILURE_DEDUPE_MS = 60_000;
+export function resetRecentWorktreeMergeFailuresForTest() {
+    recentWorktreeMergeFailures.clear();
+}
 /**
  * Internal sentinel — thrown by `_mergeBranchMode` when it has already
  * emitted a user-visible error. The outer `mergeAndExit` catches the type
@@ -208,7 +214,7 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
     }
     // Phase B: claim a milestone lease before any worktree mutation. Two
     // workers cannot enter the same milestone concurrently. Best-effort:
-    // skip if no worker registered (single-worker fallback) or DB
+    // warn if no worker registered (single-worker fallback) or skip if DB
     // unavailable; reuse existing lease if we already hold it on this
     // milestone (re-entry within the same session).
     if (s.workerId) {
@@ -288,6 +294,9 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
             }
         }
     }
+    else {
+        logWarning("worktree", `enterMilestone(${milestoneId}) ran before auto worker registration; milestone lease was not claimed.`);
+    }
     // Resolve the project root for worktree operations via shared helper.
     // Handles the case where originalBasePath is falsy and basePath is itself
     // a worktree path — prevents double-nested worktree paths (#3729).
@@ -477,6 +486,28 @@ function rebuildGitService(s, deps) {
     // GitService cast.
     s.gitService = deps.gitServiceFactory(s.basePath);
 }
+function emitWorktreeMergeFailedOnce(basePath, milestoneId, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorCategory = err instanceof Error ? err.name : "Error";
+    const now = Date.now();
+    const key = `${basePath}\0${milestoneId}\0${errorCategory}`;
+    const previous = recentWorktreeMergeFailures.get(key);
+    if (previous && now - previous < MERGE_FAILURE_DEDUPE_MS)
+        return;
+    for (const [candidate, ts] of recentWorktreeMergeFailures) {
+        if (now - ts >= MERGE_FAILURE_DEDUPE_MS) {
+            recentWorktreeMergeFailures.delete(candidate);
+        }
+    }
+    emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: randomUUID(),
+        seq: 0,
+        eventType: "worktree-merge-failed",
+        data: { milestoneId, error: msg },
+    });
+    recentWorktreeMergeFailures.set(key, now);
+}
 // ─── Session-less merge entry (ADR-016 phase 2 / A1) ─────────────────────
 /**
  * Worktree-mode merge body. Session-less — operates on a `MergeContext`.
@@ -590,13 +621,7 @@ function _mergeWorktreeModeImpl(deps, mctx) {
             error: msg,
             fallback: "chdir-to-project-root",
         });
-        emitJournalEvent(originalBasePath || worktreeBasePath, {
-            ts: new Date().toISOString(),
-            flowId: randomUUID(),
-            seq: 0,
-            eventType: "worktree-merge-failed",
-            data: { milestoneId, error: msg },
-        });
+        emitWorktreeMergeFailedOnce(originalBasePath || worktreeBasePath, milestoneId, err);
         // Surface a clear, actionable error. Worktree and milestone branch
         // are intentionally preserved — nothing has been deleted. User can
         // retry /gsd dispatch complete-milestone or merge manually once the
@@ -1198,17 +1223,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();
     }

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

@@ -491,7 +491,7 @@ export function removeWorktree(basePath, name, opts = {}) {
             const nestedGitPath = join(nestedDir, ".git");
             try {
                 rmSync(nestedGitPath, { recursive: true, force: true });
-                logWarning("reconcile", `Removed nested .git directory from scaffolded project to prevent data loss (#2616)`, { worktree: name, nestedRepo: nestedDir });
+                logWarning("reconcile", `Removed nested .git directory from scaffolded project to prevent data loss`, { worktree: name, nestedRepo: nestedDir });
             }
             catch {
                 logWarning("reconcile", `Failed to remove nested .git directory — files may be lost as orphaned gitlink`, { worktree: name, nestedRepo: nestedDir });

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -100,6 +100,34 @@ function forceOverwriteAssessmentsWithVerdict(srcMilestoneDir, dstMilestoneDir)
         logWarning("worktree", `assessment sync failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function syncTopLevelMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir) {
+    if (!existsSync(srcMilestonesDir))
+        return;
+    try {
+        for (const milestoneEntry of readdirSync(srcMilestonesDir, { withFileTypes: true })) {
+            if (!milestoneEntry.isDirectory())
+                continue;
+            const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
+            const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
+            try {
+                mkdirSync(dstMilestoneDir, { recursive: true });
+                for (const fileEntry of readdirSync(srcMilestoneDir, { withFileTypes: true })) {
+                    if (!fileEntry.isFile())
+                        continue;
+                    if (!fileEntry.name.endsWith(".md") && !fileEntry.name.endsWith(".json"))
+                        continue;
+                    safeCopy(join(srcMilestoneDir, fileEntry.name), join(dstMilestoneDir, fileEntry.name), { force: false });
+                }
+            }
+            catch (err) {
+                logWarning("worktree", `milestone top-level artifact sync failed (${milestoneEntry.name}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        logWarning("worktree", `milestone artifact scan failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Root-level .gsd/ files copied from worktree back to project root for
  * post-merge diagnostics. Markdown projections are NOT in this list — DB
@@ -142,6 +170,9 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // by validate-milestone) get clobbered by stale project root copies,
     // causing an infinite re-validation loop (#1886).
     safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId), { force: false });
+    // Additively project missing top-level milestone files for all milestones
+    // so worktree-bound units can verify future-milestone context artifacts.
+    syncTopLevelMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"));
     // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
     // The additive-only copy above preserves worktree-local files, but
     // ASSESSMENT files are special: after run-uat writes a verdict and post-unit