@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/dist/resources/extensions/gsd/auto/workflow-unit-dispatch.js

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Unit dispatch contract adapter for auto-mode loop.
 import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
-import { runUnitPhase } from "./phases.js";
+import { runUnitPhase } from "./unit-phase.js";
 import { decideDispatchNodeKind } from "./workflow-kernel.js";
 export async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem, deps) {
     if (dispatchContract === "legacy-direct") {

package/dist/resources/extensions/gsd/auto/worktree-safety-phase.js

@@ -0,0 +1,125 @@
+// Project/App: gsd-pi
+// File Purpose: Worktree-safety helpers shared across auto-loop phase modules.
+import { classifyProject } from "../detection.js";
+import { resolveEffectiveUnitIsolationMode } from "../preferences.js";
+import { createWorktreeSafetyModule } from "../worktree-safety.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
+import { resolveManifest } from "../unit-context-manifest.js";
+import { debugLog } from "../debug-logger.js";
+import { isSamePathLocal } from "./phase-helpers.js";
+import { hasHeldMilestoneLease, reclaimMissingMilestoneLease } from "./milestone-lease-reclaim.js";
+export function shouldDegradeEmptyWorktreeToProjectRoot(worktreeClassification, projectRootClassification) {
+    return (worktreeClassification.kind === "greenfield" &&
+        projectRootClassification.kind !== "greenfield" &&
+        projectRootClassification.kind !== "invalid-repo");
+}
+export function unitWritesSource(unitType) {
+    if (unitType.startsWith("hook/"))
+        return false;
+    // Backward compatibility: sidecar queues from older builds may persist
+    // prefixed unit types (e.g. "sidecar/quick-task").
+    const normalizedUnitType = unitType.startsWith("sidecar/")
+        ? unitType.slice("sidecar/".length)
+        : unitType;
+    const manifest = resolveManifest(normalizedUnitType);
+    if (!manifest)
+        return null;
+    return manifest.tools.mode === "all" || manifest.tools.mode === "docs";
+}
+export function formatWorktreeSafetyFailure(result) {
+    return `Worktree Safety failed (${result.kind}): ${result.reason} ${result.remediation}`;
+}
+export function formatWorktreeSafetyStopReason(result) {
+    if (result.kind === "empty-worktree-with-project-content") {
+        return `Worktree Safety failed (${result.kind}). Run /gsd doctor fix, then /gsd auto.`;
+    }
+    return `Worktree Safety failed (${result.kind}).`;
+}
+export function resolveEmptyWorktreeWithProjectContent(unitRoot, projectRoot) {
+    if (isSamePathLocal(unitRoot, projectRoot))
+        return false;
+    const worktreeClassification = classifyProject(unitRoot);
+    if (worktreeClassification.kind !== "greenfield")
+        return false;
+    const projectRootClassification = classifyProject(projectRoot);
+    return shouldDegradeEmptyWorktreeToProjectRoot(worktreeClassification, projectRootClassification);
+}
+export async function validateSourceWriteWorktreeSafety(ic, unitType, unitId, milestoneId, phase) {
+    const { ctx, pi, s, deps } = ic;
+    if (!s.basePath)
+        return null;
+    // Custom engine workflows (graph-driven, registered via run dirs) define
+    // their own step ids that are not in the GSD UnitContextManifest. Don't
+    // fail closed for those — the custom engine owns its own dispatch
+    // contract. The fail-closed safety check applies only to built-in GSD
+    // units whose Tool Contract is registered in the manifest. Use a truthy
+    // check so undefined (test sessions that never set the field) routes
+    // through the safety check, matching the regression test contract.
+    if (s.activeEngineId)
+        return null;
+    const writesSource = unitWritesSource(unitType);
+    if (writesSource === null) {
+        const msg = `Worktree Safety failed (missing-tool-contract): missing Tool Contract for ${unitType}. Add a UnitContextManifest entry before dispatching this Unit.`;
+        debugLog("worktreeSafety", {
+            phase,
+            unitType,
+            unitId,
+            milestoneId,
+            result: { ok: false, kind: "missing-tool-contract", reason: msg },
+            basePath: s.basePath,
+        });
+        ctx.ui.notify(msg, "error");
+        await deps.stopAuto(ctx, pi, msg);
+        return { action: "break", reason: "missing-tool-contract" };
+    }
+    if (!writesSource)
+        return null;
+    const projectRoot = s.canonicalProjectRoot ?? resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
+    // A degraded session already fell back to the milestone branch in the
+    // project root — validating against the canonical worktree root there
+    // would fail every dispatch with a false invalid-root. The same applies
+    // to a stranded-recovery session that adopted the milestone branch.
+    const isolationMode = resolveEffectiveUnitIsolationMode(deps.getIsolationMode(projectRoot), s.isolationDegraded, s.strandedRecoveryIsolationMode);
+    reclaimMissingMilestoneLease(s, milestoneId, isolationMode, phase);
+    const safety = createWorktreeSafetyModule();
+    const result = safety.validateUnitRoot({
+        unitType,
+        unitId,
+        writeScope: "source-writing",
+        projectRoot,
+        unitRoot: s.basePath,
+        milestoneId,
+        isolationMode,
+        expectedBranch: isolationMode !== "none" && milestoneId ? deps.autoWorktreeBranch(milestoneId) : null,
+        emptyWorktreeWithProjectContent: resolveEmptyWorktreeWithProjectContent(s.basePath, projectRoot),
+        // The milestone lease coordinates concurrent workers on an isolated
+        // milestone worktree/branch, which is established by enterMilestone in
+        // worktree/branch modes. `none` mode has no per-milestone isolation and
+        // does not reliably claim a lease (e.g. a fresh headless resume of an
+        // already-active milestone never re-enters it), so requiring a held lease
+        // there would falsely fail dispatch. Enforce the lease only in isolated
+        // modes; none-mode safety still validates the unit root.
+        lease: s.workerId
+            ? {
+                required: isolationMode !== "none",
+                held: hasHeldMilestoneLease(s, milestoneId),
+                owner: s.workerId,
+            }
+            : undefined,
+    });
+    if (result.ok)
+        return null;
+    const msg = formatWorktreeSafetyFailure(result);
+    debugLog("worktreeSafety", {
+        phase,
+        unitType,
+        unitId,
+        milestoneId,
+        result,
+        basePath: s.basePath,
+        projectRoot,
+    });
+    ctx.ui.notify(msg, "error");
+    await deps.stopAuto(ctx, pi, formatWorktreeSafetyStopReason(result));
+    return { action: "break", reason: result.kind };
+}

package/dist/resources/extensions/gsd/auto-closeout-messaging.js

@@ -0,0 +1,90 @@
+// Project/App: gsd-pi
+// File Purpose: Rewrite premature unit "complete" chat lines before GSD post-unit verification.
+/**
+ * Auto-mode owns the authoritative "unit complete" signal (finalize/stopAuto).
+ * Agents may still emit legacy closeout lines after completion tools succeed;
+ * rewrite those for transcript clarity until post-unit verification passes.
+ */
+const CLOSEOUT_LINE_REWRITES = [
+    {
+        pattern: /^Milestone\s+(M\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "Milestone $1 closeout submitted.",
+    },
+    {
+        pattern: /^Milestone\s+(M\d+[A-Z0-9-]*)\s+is\s+already\s+complete\.?$/i,
+        replacement: "Milestone $1 closeout already recorded.",
+    },
+    {
+        pattern: /^Slice\s+(S\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "Slice $1 closeout submitted.",
+    },
+    {
+        pattern: /^Task\s+(T\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "Task $1 closeout submitted.",
+    },
+    {
+        pattern: /^UAT\s+(S\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "UAT $1 results submitted.",
+    },
+    {
+        pattern: /^Quick\s+task\s+(\d+)\s+complete\.?$/i,
+        replacement: "Quick task $1 closeout submitted.",
+    },
+    {
+        pattern: /^Triage\s+complete\.?$/i,
+        replacement: "Triage closeout submitted.",
+    },
+];
+export function rewritePrematureCloseoutLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return line;
+    for (const { pattern, replacement } of CLOSEOUT_LINE_REWRITES) {
+        if (pattern.test(trimmed)) {
+            return trimmed.replace(pattern, replacement);
+        }
+    }
+    return line;
+}
+export function rewritePrematureCloseoutText(text) {
+    if (!text)
+        return text;
+    const lines = text.split("\n");
+    let changed = false;
+    const rewritten = lines.map((line) => {
+        const next = rewritePrematureCloseoutLine(line);
+        if (next !== line)
+            changed = true;
+        return next;
+    });
+    return changed ? rewritten.join("\n") : text;
+}
+function rewriteAssistantMessageContent(content) {
+    if (typeof content === "string") {
+        const rewritten = rewritePrematureCloseoutText(content);
+        return rewritten !== content;
+    }
+    if (!Array.isArray(content))
+        return false;
+    let changed = false;
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const part = block;
+        if (part.type !== "text" || typeof part.text !== "string")
+            continue;
+        const rewritten = rewritePrematureCloseoutText(part.text);
+        if (rewritten !== part.text) {
+            part.text = rewritten;
+            changed = true;
+        }
+    }
+    return changed;
+}
+/** Rewrite assistant closeout lines on message_end during auto-mode. */
+export function sanitizePrematureCloseoutMessageEnd(event) {
+    const message = event?.message;
+    if (!message || message.role !== "assistant")
+        return;
+    rewriteAssistantMessageContent(message.content);
+}