@opengsd/gsd-pi 1.6.0 → 1.7.0-dev.30c4ec2f

package/README.md

@@ -28,16 +28,12 @@ See [CHANGELOG.md](./CHANGELOG.md) for release-by-release fixes and [Legacy Rele
 ## Latest Release Highlights
 
 <!-- release-highlights:start -->
-Latest release: **v1.6.0**
-
-- **skills:** Load .claude/skills into the catalog (mirror Claude Code).
-- **gsd:** Extract uat dispatch discovery.
-- **daemon:** Split orchestrator agent loop.
-- **daemon:** Extract orchestrator tool execution.
-- **uok:** Scope audit degradation to kernel workspace.
-- **browser-tools:** Abort pending daemon starts on close.
-- **browser-tools:** Guard managed daemon connection lifecycle.
-- **worktree:** Centralize changed scan.
+Latest release: **v1.7.0**
+
+- **cloud:** Add device-flow login to daemon + @opengsd/gsd-cloud agent (#1278).
+- **issue:** [Bug]: Unattended `gsd headless auto` has no resumer for the parallel/slice_parallel worker pause signal → terminal exit 10 after the first unit.
+- **issue:** Complete-slice's reopen reason never reaches the re-dispatched execute-task (follow-up to #1225).
+- **issue:** [Feature Request]: gsd-browser daemon has no automatic teardown — orphaned Chrome process survives session/task completion.
 
 <!-- release-highlights:end -->
 

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-d89940a8e727f2ea
+f38cd5787a6340c5

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -31,7 +31,7 @@ import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, getMilestoneSlices, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
 import { getWorkflowDatabasePath, refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { renderPlanCheckboxes, renderRoadmapFromDb, roadmapRenderMarksSliceDone } from "./markdown-renderer.js";
-import { consumeSignal } from "./session-status-io.js";
+import { awaitWorkerResume, consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, consumeHookFailure, isRetryPending, consumeRetryTrigger, consumeGateBlock, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
@@ -1051,8 +1051,24 @@ export async function postUnitPreVerification(pctx, opts) {
                 return "dispatched";
             }
             if (signal.signal === "pause") {
-                await pauseAuto(ctx, pi);
-                return "dispatched";
+                // A worker `pause` is a *temporary* coordination request: the docs
+                // contract (docs/user-docs/parallel-orchestration.md) is "finish current
+                // unit, wait" followed by a matching `resume`. Only the interactive
+                // dashboard runtime owns a resumer — unattended `gsd headless auto` does
+                // not — so a terminal pauseAuto() here strands the worker at exit 10
+                // (BLOCKED) after its first unit, with nothing able to lift it (#1273).
+                // Wait for the coordinator to resume (or stop) us instead. If no resumer
+                // lifts the pause within the window, degrade to in-process serialization
+                // and continue the dispatch loop rather than halting the run forever.
+                const resumeOutcome = await awaitWorkerResume(s.basePath, milestoneLock);
+                if (resumeOutcome === "stop") {
+                    await stopAuto(ctx, pi);
+                    return "dispatched";
+                }
+                if (resumeOutcome === "timeout") {
+                    logWarning("parallel", `pause signal for ${milestoneLock} was not resumed (no headless resumer, #1273); continuing dispatch`);
+                }
+                // "resume" or "timeout": fall through and continue post-unit processing.
             }
         }
     }

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -2299,6 +2299,26 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     trackPromptContext(contextTelemetry, "runtime", runtimeContext ? "inline" : "skipped", runtimeContext, runtimeContext ? undefined : "missing");
     let phaseAnchorSection = planAnchor ? formatAnchorForPrompt(planAnchor) : "";
     trackPromptContext(contextTelemetry, "plan-anchor", phaseAnchorSection ? "inline" : "skipped", phaseAnchorSection, phaseAnchorSection ? undefined : "missing");
+    // #1272: inject a pending reopen reason into this task's prompt. When a gate
+    // (e.g. complete-slice's full-suite run) reopened the task via gsd_task_reopen
+    // with a diagnosis, surface it here so the re-dispatched executor fixes the
+    // regression instead of re-running the original (green) scoped verify. Claim
+    // is one-shot (artifact deleted on read). Not feature-gated — a reopened task
+    // must always know why. Prepended so it sits above the plan anchor.
+    try {
+        const { claimReopenReasonForInjection } = await import("./reopen-reason.js");
+        const reopenClaimed = claimReopenReasonForInjection(base, mid, sid, tid);
+        if (reopenClaimed) {
+            const block = reopenClaimed.injectionBlock + "\n\n---\n\n";
+            phaseAnchorSection = phaseAnchorSection
+                ? `${block}${phaseAnchorSection}`
+                : block;
+            trackPromptContext(contextTelemetry, "reopen-reason", "inline", reopenClaimed.injectionBlock);
+        }
+    }
+    catch (reopenErr) {
+        logWarning("prompt", `reopen reason injection failed: ${reopenErr.message}`);
+    }
     // ADR-011 Phase 2: inject any resolved-but-unapplied escalation override
     // into this task's prompt. Claim is atomic via DB UPDATE WHERE IS NULL, so
     // if a parallel build already injected it, we skip. Feature-gated by

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

@@ -58,6 +58,7 @@ import { isInAutoWorktree } from "./auto-worktree-entry.js";
 import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { checkResourcesStale } from "./auto-worktree-resource-version.js";
 import { escapeStaleWorktree } from "./auto-worktree-runtime-cleanup.js";
+import { teardownWarmedBrowserDaemons } from "./browser-daemon-auto-prep.js";
 import { teardownAutoWorktree } from "./auto-worktree-teardown.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
@@ -1003,6 +1004,17 @@ export async function cleanupAfterLoopExit(ctx) {
         /* best-effort — mirror stopAuto cleanup */
         logWarning("session", `lock cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
+    // Symmetric teardown for the browser-UAT warm-up preflight (#1259): stop any
+    // gsd-browser daemon this session started so the Chrome process does not
+    // linger after the loop exits. Re-warms on the next browser-backed run-uat.
+    try {
+        for (const { projectRoot, error } of teardownWarmedBrowserDaemons()) {
+            logWarning("session", `gsd-browser daemon stop failed for ${projectRoot}: ${error}`, { file: "auto.ts" });
+        }
+    }
+    catch (err) {
+        logWarning("session", `browser daemon teardown failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
+    }
     // A transient provider-error pause intentionally leaves the paused badge
     // visible so the user still has a resumable auto-mode signal on screen.
     if (!s.paused) {

package/dist/resources/extensions/gsd/browser-daemon-auto-prep.js

@@ -1,9 +1,16 @@
 import { execFileSync } from "node:child_process";
 import { resolve } from "node:path";
 import { resolveAmbientBrowserEngineResolution, resolveBrowserEngineResolution, } from "../browser-tools/engine/selection.js";
-import { resolveGsdBrowserCliAvailability, resolveGsdBrowserDaemonStartInvocation, } from "../shared/gsd-browser-cli.js";
+import { resolveGsdBrowserCliAvailability, resolveGsdBrowserDaemonStartInvocation, resolveGsdBrowserDaemonStopInvocation, } from "../shared/gsd-browser-cli.js";
 import { uatTypeIncludesBrowser } from "./uat-policy.js";
 const DEFAULT_DAEMON_START_TIMEOUT_MS = 30_000;
+const DEFAULT_DAEMON_STOP_TIMEOUT_MS = 15_000;
+/**
+ * Project roots whose gsd-browser daemon this process warmed via
+ * {@link prepareBrowserDaemonForUat}. Teardown only stops daemons we actually
+ * started, so non-browser auto-mode sessions never spawn a stray `daemon stop`.
+ */
+const warmedDaemonProjectRoots = new Set();
 function isEnvDisabled(value) {
     if (!value)
         return false;
@@ -77,7 +84,66 @@ export function prepareBrowserDaemonForUat(ctx) {
     if (!shouldWarmBrowserDaemonForUat(ctx))
         return null;
     const result = ensureBrowserDaemonStarted(ctx.projectRoot, { env: ctx.env });
-    if (result.ok)
+    if (result.ok) {
+        warmedDaemonProjectRoots.add(resolve(ctx.projectRoot));
         return null;
+    }
     return `Cannot dispatch browser-backed run-uat: gsd-browser daemon failed to start (${result.error}). Ensure Chrome/Chromium is installed, run \`gsd-browser daemon health\` with the project session flags from .mcp.json, or set GSD_BROWSER_PATH to a Chromium binary.`;
 }
+/**
+ * Best-effort stop of a gsd-browser session daemon warmed for browser UAT.
+ * Mirrors {@link ensureBrowserDaemonStarted}; returns the failure detail rather
+ * than throwing so teardown can stay non-fatal.
+ */
+export function stopBrowserDaemon(projectRoot, options = {}) {
+    const env = options.env ?? process.env;
+    const availability = resolveGsdBrowserCliAvailability(env);
+    if (!availability.available) {
+        return { ok: false, error: availability.detail };
+    }
+    let invocation;
+    try {
+        invocation = resolveGsdBrowserDaemonStopInvocation(projectRoot, env);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    try {
+        execFileSync(invocation.command, invocation.args, {
+            cwd: invocation.cwd,
+            env: { ...process.env, ...env, ...(invocation.env ?? {}) },
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: options.timeoutMs ?? DEFAULT_DAEMON_STOP_TIMEOUT_MS,
+            encoding: "utf-8",
+        });
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Tear down every gsd-browser daemon this process warmed for browser UAT,
+ * clearing the tracked set. Called on auto-mode loop exit so the Chrome process
+ * does not survive session/task completion (mirrors the warm-up preflight).
+ * Best-effort: returns the project roots whose stop failed for logging.
+ */
+export function teardownWarmedBrowserDaemons(options = {}) {
+    if (warmedDaemonProjectRoots.size === 0)
+        return [];
+    const failures = [];
+    for (const projectRoot of warmedDaemonProjectRoots) {
+        const result = stopBrowserDaemon(projectRoot, { env: options.env });
+        if (!result.ok) {
+            failures.push({ projectRoot, error: result.error });
+        }
+    }
+    warmedDaemonProjectRoots.clear();
+    return failures;
+}

package/dist/resources/extensions/gsd/doctor-history.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { saveFile } from "./files.js";
+import { gsdRoot } from "./paths.js";
+function buildDoctorHistorySummary(report, errorCount, warningCount, issueDetails) {
+    const summaryParts = [];
+    if (report.ok) {
+        summaryParts.push("Clean");
+    }
+    else {
+        const counts = [];
+        if (errorCount > 0)
+            counts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
+        if (warningCount > 0)
+            counts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
+        summaryParts.push(counts.join(", "));
+    }
+    if (report.fixesApplied.length > 0) {
+        summaryParts.push(`${report.fixesApplied.length} fixed`);
+    }
+    if (issueDetails && issueDetails.length > 0) {
+        const topIssue = issueDetails.find(i => i.severity === "error") ?? issueDetails[0];
+        summaryParts.push(topIssue.message);
+    }
+    return summaryParts.join(" · ");
+}
+export async function appendDoctorHistory(basePath, report) {
+    try {
+        const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+        const errorCount = report.issues.filter(i => i.severity === "error").length;
+        const warningCount = report.issues.filter(i => i.severity === "warning").length;
+        const issueDetails = report.issues
+            .filter(i => i.severity === "error" || i.severity === "warning")
+            .slice(0, 10) // cap to keep JSONL lines bounded
+            .map(i => ({ severity: i.severity, code: i.code, message: i.message, unitId: i.unitId }));
+        const entry = JSON.stringify({
+            ts: new Date().toISOString(),
+            ok: report.ok,
+            errors: errorCount,
+            warnings: warningCount,
+            fixes: report.fixesApplied.length,
+            codes: [...new Set(report.issues.map(i => i.code))],
+            issues: issueDetails.length > 0 ? issueDetails : undefined,
+            fixDescriptions: report.fixesApplied.length > 0 ? report.fixesApplied : undefined,
+            scope: report.scope,
+            summary: buildDoctorHistorySummary(report, errorCount, warningCount, issueDetails),
+        });
+        const existing = existsSync(historyPath) ? readFileSync(historyPath, "utf-8") : "";
+        await saveFile(historyPath, existing + entry + "\n");
+    }
+    catch { /* non-fatal */ }
+}
+/** Read the last N doctor history entries. Returns most-recent-first. */
+export async function readDoctorHistory(basePath, lastN = 50) {
+    try {
+        const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+        if (!existsSync(historyPath))
+            return [];
+        const lines = readFileSync(historyPath, "utf-8").split("\n").filter(l => l.trim());
+        return lines.slice(-lastN).reverse().map(l => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}