gsd-pi 2.80.0 → 2.81.0-dev.72a81bdf3

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -1,3 +1,4 @@
+// GSD2 - Claude Code CLI provider stream adapter
 /**
  * Stream adapter: bridges the Claude Agent SDK into GSD's streamSimple contract.
  *
@@ -16,6 +17,10 @@ import { dirname, join } from "node:path";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
 import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
 import { showInterviewRound } from "../shared/tui.js";
+/** Resolve the workspace root for local Claude Code process execution. */
+export function resolveClaudeCodeCwd(options) {
+    return options?.cwd && options.cwd.trim().length > 0 ? options.cwd : process.cwd();
+}
 /** Label used for the free-text fallback option in single-choice elicitation questions. */
 const OTHER_OPTION_LABEL = "None of the above";
 /** Regex pattern that identifies field names and descriptions that should be treated as sensitive/secure inputs. */
@@ -261,6 +266,26 @@ function makeErrorMessage(model, errorMsg) {
         timestamp: Date.now(),
     };
 }
+export function isClaudeCodeAbortErrorMessage(message) {
+    if (!message)
+        return false;
+    return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
+}
+function isBareClaudeCodeAbortErrorMessage(message) {
+    if (!message)
+        return false;
+    const normalized = message.trim().replace(/\s+/g, " ").toLowerCase();
+    return normalized === "claude code process aborted by user"
+        || normalized === "request aborted by user"
+        || normalized === "process aborted by user";
+}
+export function resolveClaudeCodeAbortedMessageText(errorMsg, lastTextContent) {
+    const trimmedError = errorMsg.trim();
+    if (trimmedError && !isBareClaudeCodeAbortErrorMessage(trimmedError)) {
+        return trimmedError;
+    }
+    return lastTextContent;
+}
 /**
  * Generator exhaustion without a terminal result means the SDK stream was
  * interrupted mid-turn. Surface it as an error so downstream recovery logic
@@ -1031,8 +1056,9 @@ function mapThinkingLevelToAnthropicEffort(level, modelId) {
  * behaviour pass `permissionMode: "bypassPermissions"` explicitly.
  */
 export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
-    const { reasoning, ...sdkExtraOptions } = extraOptions;
-    const mcpServers = buildWorkflowMcpServers();
+    const { reasoning, cwd, ...sdkExtraOptions } = extraOptions;
+    const sdkCwd = typeof cwd === "string" && cwd.trim().length > 0 ? cwd : process.cwd();
+    const mcpServers = buildWorkflowMcpServers(sdkCwd);
     const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
     // Globally unblock the tools GSD expects Claude Code to run. When the
     // workflow MCP server is available, prefer its `ask_user_questions` tool over
@@ -1070,7 +1096,7 @@ export function buildSdkOptions(modelId, prompt, overrides, extraOptions = {}) {
         model: modelId,
         includePartialMessages: true,
         persistSession: true,
-        cwd: process.cwd(),
+        cwd: sdkCwd,
         permissionMode,
         allowDangerouslySkipPermissions: permissionMode === "bypassPermissions",
         settingSources: ["project"],
@@ -1332,12 +1358,14 @@ async function pumpSdkMessages(model, context, options, stream) {
         const queryPrompt = buildSdkQueryPrompt(context, prompt);
         const permissionMode = await resolveClaudePermissionMode();
         const uiContext = options?.extensionUIContext;
+        const cwd = resolveClaudeCodeCwd(options);
         const canUseToolHandler = createClaudeCodeCanUseToolHandler(uiContext);
         // When no UI is available (headless / auto-mode), auto-approve all
         // tool requests. This replaces the old bypassPermissions workaround.
         const canUseToolFallback = canUseToolHandler
             ?? (async (_toolName, _input, opts) => ({ behavior: "allow", toolUseID: opts.toolUseID }));
         const sdkOpts = buildSdkOptions(modelId, prompt, { permissionMode }, {
+            cwd,
             reasoning: options?.reasoning,
             canUseTool: canUseToolFallback,
             ...(uiContext
@@ -1512,6 +1540,15 @@ async function pumpSdkMessages(model, context, options, stream) {
     }
     catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
+        if (options?.signal?.aborted || isClaudeCodeAbortErrorMessage(errorMsg)) {
+            const abortedText = resolveClaudeCodeAbortedMessageText(errorMsg, lastTextContent);
+            stream.push({
+                type: "error",
+                reason: "aborted",
+                error: makeAbortedMessage(modelId, abortedText),
+            });
+            return;
+        }
         stream.push({
             type: "error",
             reason: "error",

package/dist/resources/extensions/github-sync/sync.js

@@ -79,6 +79,9 @@ export async function runGitHubSync(basePath, unitType, unitId) {
         debugLog("github-sync", { error: String(err) });
     }
 }
+export function shouldCreateSlicePrForSyncEvent(unitType, config) {
+    return unitType === "complete-slice" && config.slice_prs !== false;
+}
 // ─── Per-Event Sync Functions ───────────────────────────────────────────────
 async function syncMilestonePlan(basePath, mapping, config, mid) {
     // Skip if already synced
@@ -307,7 +310,7 @@ async function syncSliceComplete(basePath, mapping, config, mid, sid) {
     }
     if (!sliceRecord || sliceRecord.state === "closed")
         return;
-    if (!sliceRecord.prNumber && config.slice_prs !== false) {
+    if (!sliceRecord.prNumber && shouldCreateSlicePrForSyncEvent("complete-slice", config)) {
         await ensureSlicePullRequest(basePath, mapping, mid, sid);
         sliceRecord = getSliceRecord(mapping, mid, sid);
         if (!sliceRecord || !sliceRecord.prNumber)

package/dist/resources/extensions/github-sync/templates.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Markdown formatters for GitHub sync issues, PR bodies, and comments.
 /**
  * Markdown formatters for GitHub issue bodies, PR descriptions,
  * and summary comments.
@@ -5,6 +7,38 @@
  * All functions produce GitHub-flavored markdown strings ready
  * for the `gh` CLI body parameters.
  */
+import { buildPrEvidence } from "../gsd/pr-evidence.js";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+/**
+ * Wrap a string in a CommonMark inline-code span, escaping any embedded
+ * backticks by selecting a fence longer than the longest backtick run inside
+ * the input. If the input begins or ends with a backtick, pad with a single
+ * space inside the fence (CommonMark requirement).
+ *
+ * Empty input returns an empty string (no fence) — there is nothing to render
+ * as code, and emitting an empty pair of backticks would produce literal
+ * backticks in GitHub-flavored markdown.
+ */
+export function inlineCode(s) {
+    if (s.length === 0)
+        return "";
+    let longestRun = 0;
+    let currentRun = 0;
+    for (const ch of s) {
+        if (ch === "`") {
+            currentRun++;
+            if (currentRun > longestRun)
+                longestRun = currentRun;
+        }
+        else {
+            currentRun = 0;
+        }
+    }
+    const fence = "`".repeat(longestRun + 1);
+    const needsPad = s.startsWith("`") || s.endsWith("`");
+    const pad = needsPad ? " " : "";
+    return `${fence}${pad}${s}${pad}${fence}`;
+}
 export function formatMilestoneIssueBody(data) {
     const lines = [];
     lines.push(`# ${data.id}: ${data.title}`);
@@ -36,37 +70,33 @@ export function formatMilestoneIssueBody(data) {
     return lines.join("\n");
 }
 export function formatSlicePRBody(data) {
-    const lines = [];
-    lines.push(`## ${data.id}: ${data.title}`);
-    lines.push("");
-    if (data.goal) {
-        lines.push("### Goal");
-        lines.push(data.goal);
-        lines.push("");
-    }
-    if (data.mustHaves?.length) {
-        lines.push("### Must-Haves");
-        for (const item of data.mustHaves) {
-            lines.push(`- ${item}`);
-        }
-        lines.push("");
-    }
-    if (data.demoCriterion) {
-        lines.push("### Demo Criterion");
-        lines.push(data.demoCriterion);
-        lines.push("");
-    }
-    if (data.tasks?.length) {
-        lines.push("### Tasks");
-        for (const task of data.tasks) {
-            const ref = task.issueNumber ? ` (#${task.issueNumber})` : "";
-            lines.push(`- [ ] ${task.id}: ${task.title}${ref}`);
-        }
-        lines.push("");
-    }
-    lines.push("---");
-    lines.push("*Auto-generated by GSD GitHub Sync*");
-    return lines.join("\n");
+    const summaries = [
+        data.goal ? `### Goal\n${data.goal}` : "",
+        data.mustHaves?.length ? `### Must-Haves\n${data.mustHaves.map((item) => `- ${item}`).join("\n")}` : "",
+        data.demoCriterion ? `### Demo Criterion\n${data.demoCriterion}` : "",
+        data.tasks?.length
+            ? `### Tasks\n${data.tasks.map((task) => {
+                const ref = task.issueNumber ? ` (#${task.issueNumber})` : "";
+                return `- [ ] ${task.id}: ${task.title}${ref}`;
+            }).join("\n")}`
+            : "",
+    ].filter(Boolean);
+    const issueRefs = (data.tasks ?? [])
+        .map((task) => task.issueNumber)
+        .filter((issueNumber) => typeof issueNumber === "number")
+        .map((issueNumber) => `#${issueNumber}`);
+    return buildPrEvidence({
+        milestoneId: data.id,
+        subjectId: data.id,
+        subjectKind: "slice",
+        milestoneTitle: data.title,
+        changeType: "feat",
+        linkedIssue: issueRefs.length > 0 ? `Related issues: ${issueRefs.join(", ")}` : undefined,
+        summaries,
+        testsRun: data.demoCriterion ? [`Demo criterion: ${data.demoCriterion}`] : undefined,
+        rollbackNotes: ["Close this draft slice PR before merge or revert the slice squash commit from the milestone branch."],
+        how: "Generated by GSD GitHub Sync from the slice plan, task issues, and branch mapping.",
+    }).body;
 }
 export function formatTaskIssueBody(data) {
     const lines = [];
@@ -79,7 +109,7 @@ export function formatTaskIssueBody(data) {
     if (data.files?.length) {
         lines.push("### Files");
         for (const file of data.files) {
-            lines.push(`- \`${file}\``);
+            lines.push(`- ${inlineCode(file)}`);
         }
         lines.push("");
     }
@@ -129,52 +159,38 @@ function checkedList(items, emptyLabel) {
     return items.map((item) => `- [ ] ${item}`);
 }
 export function formatSwarmLanePRBody(data) {
-    const lines = [];
     const laneLabel = SWARM_LANE_LABELS[data.lane.id];
-    lines.push("## Swarm lane");
-    lines.push("");
-    lines.push(`**Lane:** \`${laneLabel}\``);
-    lines.push(`**Branch:** \`${data.lane.branch}\``);
-    if (data.lane.owner)
-        lines.push(`**Owner:** ${data.lane.owner}`);
-    if (data.lane.latestCommit)
-        lines.push(`**Latest commit:** \`${data.lane.latestCommit}\``);
-    lines.push("");
-    lines.push("## Impact area");
-    lines.push("");
-    lines.push(data.impactArea);
-    lines.push("");
-    lines.push("## Changed contracts");
-    lines.push(...checkedList(data.lane.changedContracts, "No shared contracts changed"));
-    lines.push("");
-    lines.push("## Transition risks");
-    lines.push(...checkedList(data.transitionRisks, "No transition risks identified"));
-    lines.push("");
-    lines.push("## Rollback plan");
-    lines.push(...checkedList(data.rollbackPlan, "Revert this lane PR"));
-    lines.push("");
-    lines.push("## Test evidence");
-    lines.push(...checkedList(data.lane.testEvidence, "Test evidence pending"));
-    lines.push("");
-    if (data.lane.blockers?.length) {
-        lines.push("## Blockers");
-        for (const blocker of data.lane.blockers)
-            lines.push(`- ${blocker}`);
-        lines.push("");
-    }
-    if (data.linkedIssue) {
-        lines.push(`Closes #${data.linkedIssue}`);
-        lines.push("");
-    }
-    lines.push("---");
-    lines.push("*Auto-generated by GSD GitHub Sync swarm routines*");
-    return lines.join("\n");
+    const summaries = [
+        [
+            "### Swarm lane",
+            `**Lane:** ${inlineCode(laneLabel)}`,
+            `**Branch:** ${inlineCode(data.lane.branch)}`,
+            data.lane.owner ? `**Owner:** ${data.lane.owner}` : "",
+            data.lane.latestCommit ? `**Latest commit:** ${inlineCode(data.lane.latestCommit)}` : "",
+        ].filter(Boolean).join("\n"),
+        `### Impact area\n${data.impactArea}`,
+        `### Changed contracts\n${checkedList(data.lane.changedContracts, "No shared contracts changed").join("\n")}`,
+        `### Transition risks\n${checkedList(data.transitionRisks, "No transition risks identified").join("\n")}`,
+    ].filter(Boolean);
+    return buildPrEvidence({
+        milestoneId: laneLabel,
+        subjectId: laneLabel,
+        subjectKind: "workflow",
+        milestoneTitle: laneLabel,
+        changeType: "refactor",
+        linkedIssue: data.linkedIssue ? `Closes #${data.linkedIssue}` : undefined,
+        summaries,
+        blockers: data.lane.blockers ?? [],
+        testsRun: data.lane.testEvidence,
+        rollbackNotes: data.rollbackPlan,
+        how: "Generated by GSD GitHub Sync swarm routines from lane evidence.",
+    }).body;
 }
 export function formatSwarmReleaseChecklistBody(data) {
     const lines = [];
     lines.push(`# UOK Swarm Release Checklist`);
     lines.push("");
-    lines.push(`**Integration branch:** \`${data.integrationBranch}\``);
+    lines.push(`**Integration branch:** ${inlineCode(data.integrationBranch)}`);
     lines.push("");
     lines.push("## Lane summary");
     lines.push("");
@@ -182,9 +198,9 @@ export function formatSwarmReleaseChecklistBody(data) {
     lines.push("|------|--------|-------|--------|--------|");
     for (const lane of data.lanes) {
         const owner = lane.owner ?? "";
-        const commit = lane.latestCommit ? `\`${lane.latestCommit}\`` : "";
+        const commit = lane.latestCommit ? inlineCode(lane.latestCommit) : "";
         const status = lane.blockers?.length ? "blocked" : "ready";
-        lines.push(`| \`${SWARM_LANE_LABELS[lane.id]}\` | \`${lane.branch}\` | ${owner} | ${commit} | ${status} |`);
+        lines.push(`| ${inlineCode(SWARM_LANE_LABELS[lane.id])} | ${inlineCode(lane.branch)} | ${owner} | ${commit} | ${status} |`);
     }
     lines.push("");
     lines.push("## Required evidence");

package/dist/resources/extensions/gsd/auto/contracts.js

@@ -1 +1,3 @@
+// Project/App: GSD-2
+// File Purpose: Auto Orchestration module interfaces and ADR-015 invariant adapter contracts.
 export {};

package/dist/resources/extensions/gsd/auto/custom-verify-retry-store.js

@@ -0,0 +1,53 @@
+// Project/App: GSD-2
+// File Purpose: Persistence adapter for custom workflow verification retry counts.
+import { readFileSync, mkdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteSync } from "../atomic-write.js";
+import { gsdRoot } from "../paths.js";
+export function customVerifyRetryStateDir(s) {
+    return s.activeRunDir ? join(s.activeRunDir, "runtime") : join(gsdRoot(s.basePath), "runtime");
+}
+export function customVerifyRetryStatePath(s) {
+    return join(customVerifyRetryStateDir(s), "custom-verify-retries.json");
+}
+export function hydrateCustomVerifyRetryCounts(s, deps) {
+    if (s.verificationRetryCount.size > 0) {
+        return s.verificationRetryCount;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(customVerifyRetryStatePath(s), "utf-8"));
+        const counts = raw && typeof raw === "object" && raw.counts && typeof raw.counts === "object"
+            ? raw.counts
+            : {};
+        for (const [key, value] of Object.entries(counts)) {
+            if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+                s.verificationRetryCount.set(key, Math.floor(value));
+            }
+        }
+    }
+    catch (err) {
+        deps.logFailure(err);
+    }
+    return s.verificationRetryCount;
+}
+export function saveCustomVerifyRetryCounts(s, deps) {
+    const retryCounts = s.verificationRetryCount;
+    const filePath = customVerifyRetryStatePath(s);
+    try {
+        if (!retryCounts || retryCounts.size === 0) {
+            unlinkSync(filePath);
+            return;
+        }
+        mkdirSync(customVerifyRetryStateDir(s), { recursive: true });
+        atomicWriteSync(filePath, JSON.stringify({
+            counts: Object.fromEntries(retryCounts),
+            updatedAt: new Date().toISOString(),
+        }) + "\n");
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err ? err.code : undefined;
+        if (code !== "ENOENT") {
+            deps.logFailure(err);
+        }
+    }
+}