gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.b62439b9f

package/dist/resources/extensions/gsd/auto/workflow-kernel.js

@@ -0,0 +1,263 @@
+// Project/App: GSD-2
+// File Purpose: Pure workflow-loop decisions for auto-mode before side-effect adapters run.
+export function decideWorkflowLoop(input) {
+    if (!input.active) {
+        return {
+            action: "stop",
+            reason: "inactive",
+            message: "Auto-mode is not active.",
+        };
+    }
+    if (input.iteration > input.maxIterations) {
+        return {
+            action: "stop",
+            reason: "max-iterations",
+            message: `Safety: loop exceeded ${input.maxIterations} iterations.`,
+        };
+    }
+    if (!input.hasCommandContext) {
+        return {
+            action: "stop",
+            reason: "missing-command-context",
+            message: "Auto-mode has no command context for dispatch.",
+        };
+    }
+    if (!input.sessionLockValid) {
+        return {
+            action: "stop",
+            reason: "session-lock-lost",
+            message: input.sessionLockReason
+                ? `Session lock lost: ${input.sessionLockReason}.`
+                : "Session lock lost.",
+        };
+    }
+    return { action: "continue" };
+}
+export function decideDispatchClaim(input) {
+    if (input.kind === "skip") {
+        return {
+            action: "skip",
+            reason: input.reason,
+        };
+    }
+    if (input.kind === "opened") {
+        return {
+            action: "run",
+            dispatchId: input.dispatchId,
+        };
+    }
+    return {
+        action: "run",
+        dispatchId: null,
+    };
+}
+export function decideEngineDispatch(input) {
+    if (input.action === "stop") {
+        return {
+            action: "stop",
+            reason: input.reason ?? "Engine stopped",
+        };
+    }
+    if (input.action === "skip") {
+        return { action: "skip" };
+    }
+    return { action: "dispatch" };
+}
+export function decideFinalizeResult(input) {
+    if (input.action === "break") {
+        const reason = input.reason ?? "unknown";
+        return {
+            action: "stop",
+            failureClass: reason === "git-closeout-failure" ? "git" : "closeout",
+            ledgerErrorSummary: `finalize-break:${reason}`,
+            turnError: "finalize-break",
+        };
+    }
+    if (input.action === "continue") {
+        return {
+            action: "retry",
+            ledgerErrorSummary: "finalize-retry",
+        };
+    }
+    return { action: "complete" };
+}
+export function decideEngineReconcile(input) {
+    if (input.outcome === "milestone-complete") {
+        return {
+            action: "complete-workflow",
+            stopReason: "Workflow complete",
+        };
+    }
+    if (input.outcome === "pause") {
+        return { action: "pause" };
+    }
+    if (input.outcome === "stop") {
+        return {
+            action: "stop",
+            reason: input.reason ?? "Engine stopped",
+        };
+    }
+    return { action: "continue" };
+}
+export function decideMemoryPressure(input) {
+    if (!input.pressured) {
+        return { action: "continue" };
+    }
+    const pct = Math.round(input.pct * 100);
+    return {
+        action: "stop",
+        warningMessage: `Memory pressure: ${input.heapMB}MB / ${input.limitMB}MB (${pct}%) — stopping auto-mode to prevent OOM kill`,
+        stopMessage: `Memory pressure: heap at ${input.heapMB}MB / ${input.limitMB}MB (${pct}%). ` +
+            `Stopping gracefully to prevent OOM kill after ${input.iteration} iterations. ` +
+            "Resume with /gsd auto to continue from where you left off.",
+        turnError: "memory-pressure",
+    };
+}
+export function decideMinRequestInterval(input) {
+    if (input.minIntervalMs <= 0 || input.lastRequestTimestamp <= 0) {
+        return { action: "continue" };
+    }
+    const elapsedMs = input.nowMs - input.lastRequestTimestamp;
+    if (elapsedMs >= input.minIntervalMs) {
+        return { action: "continue" };
+    }
+    return {
+        action: "wait",
+        waitMs: input.minIntervalMs - elapsedMs,
+    };
+}
+export function decideCooldownRecovery(input) {
+    if (input.consecutiveCooldowns > input.maxCooldownRetries) {
+        return {
+            action: "stop",
+            notifyMessage: `Auto-mode stopped: ${input.consecutiveCooldowns} consecutive credential cooldowns — ` +
+                "rate limit or quota may be persistently exhausted.",
+            stopMessage: `${input.consecutiveCooldowns} consecutive credential cooldowns exceeded retry budget`,
+        };
+    }
+    const waitMs = input.retryAfterMs !== undefined && input.retryAfterMs > 0 && input.retryAfterMs <= 60_000
+        ? input.retryAfterMs + 500
+        : input.fallbackWaitMs;
+    return {
+        action: "wait",
+        waitMs,
+        notifyMessage: `Credentials in cooldown (${input.consecutiveCooldowns}/${input.maxCooldownRetries}) — ` +
+            `waiting ${Math.round(waitMs / 1000)}s before retrying.`,
+    };
+}
+export function decideIterationErrorRecovery(input) {
+    if (input.consecutiveErrors >= 3) {
+        const errorHistory = input.recentErrorMessages
+            .map((message, index) => `  ${index + 1}. ${message}`)
+            .join("\n");
+        return {
+            action: "stop",
+            notifyMessage: `Auto-mode stopped: ${input.consecutiveErrors} consecutive iteration failures:\n${errorHistory}`,
+            stopMessage: `${input.consecutiveErrors} consecutive iteration failures`,
+            turnStatus: "failed",
+        };
+    }
+    if (input.consecutiveErrors === 2) {
+        return {
+            action: "invalidate-and-retry",
+            notifyMessage: `Iteration error (attempt ${input.consecutiveErrors}): ` +
+                `${input.currentErrorMessage}. Invalidating caches and retrying.`,
+            turnStatus: "retry",
+        };
+    }
+    return {
+        action: "retry",
+        notifyMessage: `Iteration error: ${input.currentErrorMessage}. Retrying.`,
+        turnStatus: "retry",
+    };
+}
+export function decideCustomEngineVerifyRetry(input) {
+    return input.attempts > input.maxRetries
+        ? { action: "recover" }
+        : { action: "retry" };
+}
+export function shouldUseCustomEnginePath(input) {
+    return input.activeEngineId != null
+        && input.activeEngineId !== "dev"
+        && !input.hasSidecarItem
+        && !input.engineBypass;
+}
+export function resolveUnitRequestTimestamp(input) {
+    const requestTimestamp = input.requestDispatchedAt ?? input.unitStartedAt;
+    return typeof requestTimestamp === "number" ? requestTimestamp : undefined;
+}
+export function decideCustomEngineRecovery(input) {
+    const exhaustedTurnError = "custom-engine-verify-retry-exhausted";
+    if (input.outcome === "pause") {
+        return {
+            action: "pause",
+            turnError: input.reason ?? exhaustedTurnError,
+        };
+    }
+    if (input.outcome === "skip") {
+        return {
+            action: "stop",
+            stopMessage: input.reason ??
+                `Custom workflow verification for ${input.unitId} requested skip after retry exhaustion, but the custom engine cannot reconcile skipped steps.`,
+            turnError: exhaustedTurnError,
+        };
+    }
+    const exhaustedReason = `Custom workflow verification for ${input.unitId} requested retry ${input.attempts} times without passing.`;
+    return {
+        action: "stop",
+        stopMessage: input.outcome === "stop" && input.reason ? input.reason : exhaustedReason,
+        turnError: exhaustedTurnError,
+    };
+}
+export function decideInfrastructureError(input) {
+    return {
+        notifyMessage: `Auto-mode stopped: infrastructure error ${input.code} — ${input.errorMessage}`,
+        stopMessage: `Infrastructure error (${input.code}): not recoverable by retry`,
+        turnStatus: "failed",
+        failureClass: "execution",
+    };
+}
+export function decideModelPolicyBlocked(input) {
+    return {
+        notifyMessage: `Auto-mode paused: model-policy denied dispatch for ${input.unitType}/${input.unitId}. ${input.errorMessage}`,
+        journalData: {
+            unitType: input.unitType,
+            unitId: input.unitId,
+            status: "blocked",
+            reason: "model-policy-dispatch-blocked",
+            reasons: input.reasons,
+        },
+        turnStatus: "paused",
+        failureClass: "manual-attention",
+    };
+}
+export function decideDispatchNodeKind(unitType, sidecarKind) {
+    if (sidecarKind === "hook")
+        return "hook";
+    if (sidecarKind === "triage")
+        return "verification";
+    if (sidecarKind === "quick-task")
+        return "team-worker";
+    if (unitType.startsWith("hook/"))
+        return "hook";
+    if (unitType === "reactive-execute")
+        return "subagent";
+    if (unitType === "gate-evaluate"
+        || unitType === "validate-milestone"
+        || unitType === "run-uat"
+        || unitType === "complete-slice") {
+        return "verification";
+    }
+    if (unitType === "replan-slice" || unitType === "reassess-roadmap") {
+        return "reprocess";
+    }
+    return "unit";
+}
+export function formatDispatchExceptionSummary(input) {
+    const message = input.error instanceof Error ? input.error.message : String(input.error);
+    return `exception:${message}`;
+}
+export function formatUnhandledDispatchErrorSummary(input) {
+    const message = input.error instanceof Error ? input.error.message : String(input.error);
+    return `unhandled-error:${message.slice(0, 200)}`;
+}

package/dist/resources/extensions/gsd/auto/workflow-memory-pressure.js

@@ -0,0 +1,36 @@
+// Project/App: GSD-2
+// File Purpose: Memory-pressure measurement adapter for auto-mode loop.
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const DEFAULT_MEMORY_PRESSURE_THRESHOLD = 0.85;
+const DEFAULT_HEAP_LIMIT_MB = 4096;
+function defaultHeapLimitBytes() {
+    const v8 = require("node:v8");
+    const limit = v8.getHeapStatistics?.().heap_size_limit;
+    if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) {
+        throw new Error("V8 heap limit unavailable");
+    }
+    return limit;
+}
+export function measureMemoryPressure(options) {
+    const threshold = options?.threshold ?? DEFAULT_MEMORY_PRESSURE_THRESHOLD;
+    const fallbackLimitMB = options?.fallbackLimitMB ?? DEFAULT_HEAP_LIMIT_MB;
+    const memoryUsage = options?.deps?.memoryUsage ?? (() => process.memoryUsage());
+    const heapLimitBytes = options?.deps?.heapLimitBytes ?? defaultHeapLimitBytes;
+    const mem = memoryUsage();
+    const heapMB = Math.round(mem.heapUsed / 1024 / 1024);
+    let limitMB = fallbackLimitMB;
+    try {
+        limitMB = Math.round(heapLimitBytes() / 1024 / 1024);
+    }
+    catch {
+        limitMB = fallbackLimitMB;
+    }
+    const pct = heapMB / limitMB;
+    return {
+        pressured: pct > threshold,
+        heapMB,
+        limitMB,
+        pct,
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-phase-reporter.js

@@ -0,0 +1,9 @@
+// Project/App: GSD-2
+// File Purpose: Thin adapter for auto-mode UOK phase-result reporting.
+export function createWorkflowPhaseReporter(input) {
+    return {
+        report(phase, action, data) {
+            input.observer?.onPhaseResult(phase, action, data);
+        },
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-session-lock.js

@@ -0,0 +1,35 @@
+// Project/App: GSD-2
+// File Purpose: Session-lock validation adapter for auto-mode loop.
+import { decideWorkflowLoop, } from "./workflow-kernel.js";
+export function validateWorkflowSessionLock(input) {
+    const sessionLockBase = input.deps.lockBase();
+    if (!sessionLockBase)
+        return { action: "continue" };
+    const lockStatus = input.deps.validateSessionLock(sessionLockBase);
+    const detail = lockStatus.failureReason ?? "unknown";
+    const lockDecision = decideWorkflowLoop({
+        active: input.active,
+        iteration: input.iteration,
+        maxIterations: input.maxIterations,
+        hasCommandContext: true,
+        sessionLockValid: lockStatus.valid,
+        sessionLockReason: detail,
+    });
+    if (lockDecision.action !== "stop" || lockDecision.reason !== "session-lock-lost") {
+        return { action: "continue" };
+    }
+    input.deps.logInvalidSessionLock({
+        reason: detail,
+        existingPid: lockStatus.existingPid,
+        expectedPid: lockStatus.expectedPid,
+    });
+    input.deps.handleLostSessionLock(lockStatus);
+    input.deps.logSessionLockExit({
+        reason: lockDecision.reason,
+        detail,
+    });
+    return {
+        action: "stop",
+        reason: lockDecision.reason,
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-sidecar-iteration.js

@@ -0,0 +1,24 @@
+// Project/App: GSD-2
+// File Purpose: Sidecar iteration-data adapter for auto-mode loop.
+export async function buildSidecarIterationData(input) {
+    const sidecarState = await input.deriveState(input.canonicalProjectRoot);
+    input.logPostDerive({
+        site: "sidecar",
+        basePath: input.basePath,
+        canonicalProjectRoot: input.canonicalProjectRoot,
+        derivedPhase: sidecarState.phase,
+        activeUnit: sidecarState.activeTask?.id ?? sidecarState.activeSlice?.id ?? sidecarState.activeMilestone?.id,
+    });
+    return {
+        unitType: input.sidecarItem.unitType,
+        unitId: input.sidecarItem.unitId,
+        prompt: input.sidecarItem.prompt,
+        finalPrompt: input.sidecarItem.prompt,
+        pauseAfterUatDispatch: false,
+        state: sidecarState,
+        mid: sidecarState.activeMilestone?.id,
+        midTitle: sidecarState.activeMilestone?.title,
+        isRetry: false,
+        previousTier: undefined,
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-sidecar-queue.js

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Sidecar queue scheduling and dequeue adapter for auto-mode loop.
+export async function dequeueSidecarItem(input) {
+    if (input.queue.length === 0)
+        return undefined;
+    if (input.executionGraphEnabled && input.queue.length > 1) {
+        try {
+            const scheduledQueue = await input.scheduleQueue(input.queue);
+            input.queue.splice(0, input.queue.length, ...scheduledQueue);
+        }
+        catch (err) {
+            input.warnSchedulingFailure(err instanceof Error ? err.message : String(err));
+        }
+    }
+    const sidecarItem = input.queue.shift();
+    if (!sidecarItem)
+        return undefined;
+    const payload = {
+        kind: sidecarItem.kind,
+        unitType: sidecarItem.unitType,
+        unitId: sidecarItem.unitId,
+    };
+    input.logDequeue(payload);
+    input.emitDequeue(payload);
+    return sidecarItem;
+}

package/dist/resources/extensions/gsd/auto/workflow-turn-reporter.js

@@ -0,0 +1,36 @@
+// Project/App: GSD-2
+// File Purpose: Thin adapter for workflow turn observer reporting.
+export function createWorkflowTurnReporter(input) {
+    let finished = false;
+    const now = input.now ?? (() => new Date().toISOString());
+    return {
+        start() {
+            input.observer?.onTurnStart({
+                traceId: input.traceId,
+                turnId: input.turnId,
+                iteration: input.iteration,
+                basePath: input.basePath,
+                startedAt: input.startedAt,
+            });
+        },
+        finish(finishInput) {
+            if (finished)
+                return;
+            finished = true;
+            input.observer?.onTurnResult({
+                traceId: input.traceId,
+                turnId: input.turnId,
+                iteration: input.iteration,
+                unitType: finishInput.unitType,
+                unitId: finishInput.unitId,
+                status: finishInput.status,
+                failureClass: finishInput.failureClass ?? "none",
+                phaseResults: [],
+                error: finishInput.error,
+                startedAt: input.startedAt,
+                finishedAt: now(),
+            });
+            input.clearCurrentTurn();
+        },
+    };
+}

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

@@ -0,0 +1,44 @@
+// Project/App: GSD-2
+// File Purpose: Unit dispatch contract adapter for auto-mode loop.
+import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
+import { runUnitPhase } from "./phases.js";
+import { decideDispatchNodeKind } from "./workflow-kernel.js";
+export async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem, deps) {
+    if (dispatchContract === "legacy-direct") {
+        return deps.runUnitPhase(ic, iterData, loopState, sidecarItem);
+    }
+    const scheduler = deps.createScheduler();
+    let outcome = null;
+    const executeNode = async () => {
+        outcome = await deps.runUnitPhase(ic, iterData, loopState, sidecarItem);
+    };
+    const kinds = [
+        "unit",
+        "hook",
+        "subagent",
+        "team-worker",
+        "verification",
+        "reprocess",
+    ];
+    for (const kind of kinds)
+        scheduler.registerHandler(kind, executeNode);
+    const nodeId = `dispatch:${ic.iteration}:${iterData.unitType}:${iterData.unitId}`;
+    await scheduler.run([
+        {
+            id: nodeId,
+            kind: decideDispatchNodeKind(iterData.unitType, sidecarItem?.kind),
+            dependsOn: [],
+            metadata: {
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            },
+        },
+    ], { parallel: false, maxWorkers: 1 });
+    return outcome ?? { action: "break", reason: "scheduler-dispatch-missing-result" };
+}
+export function createExecutionGraphUnitDispatchDeps() {
+    return {
+        runUnitPhase: async (...args) => runUnitPhase(...args),
+        createScheduler: () => new ExecutionGraphScheduler(),
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-worker-heartbeat.js

@@ -0,0 +1,15 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort worker heartbeat adapter for auto-mode loop.
+export function maintainWorkerHeartbeat(session, deps) {
+    if (!session.workerId)
+        return;
+    try {
+        deps.heartbeatAutoWorker(session.workerId);
+        if (session.currentMilestoneId && session.milestoneLeaseToken) {
+            deps.refreshMilestoneLease(session.workerId, session.currentMilestoneId, session.milestoneLeaseToken);
+        }
+    }
+    catch (err) {
+        deps.logHeartbeatFailure(err);
+    }
+}

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

@@ -461,6 +461,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         ? { id: uatTargetSliceId, title: state.activeSlice?.title ?? "" }
         : state.activeSlice;
     const task = state.activeTask;
+    if (mid) {
+        updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+    }
     // Cache git branch at widget creation time (not per render)
     let cachedBranch = null;
     try {