gsd-pi 2.71.0-dev.e17e0ce → 2.72.0-dev.3118184

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -61,6 +61,9 @@ export function parseDoctorArgs(args) {
     const requestedScope = mode === "doctor" ? parts[0] : parts[1];
     return { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope };
 }
+export function isDoctorHealActionable(issue) {
+    return issue.fixable && issue.severity !== "info";
+}
 export async function handleDoctor(args, ctx, pi) {
     const { jsonMode, dryRun, fixFlag, includeBuild, includeTests, mode, requestedScope } = parseDoctorArgs(args);
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
@@ -88,7 +91,7 @@ export async function handleDoctor(args, ctx, pi) {
             scope: effectiveScope,
             includeWarnings: true,
         });
-        const actionable = unresolved.filter(issue => issue.severity === "error");
+        const actionable = unresolved.filter(isDoctorHealActionable);
         if (actionable.length === 0) {
             ctx.ui.notify("Doctor heal found nothing actionable to hand off to the LLM.", "info");
             return;

package/dist/resources/extensions/gsd/context-injector.js

@@ -14,7 +14,7 @@
  */
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, sep } from "node:path";
-import { readFrozenDefinition } from "./custom-workflow-engine.js";
+import { readFrozenDefinition } from "./definition-io.js";
 /** Maximum characters per artifact to prevent context window blowout. */
 const MAX_CONTEXT_CHARS = 10_000;
 /**

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -13,17 +13,13 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { parse } from "yaml";
 import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
+import { readFrozenDefinition } from "./definition-io.js";
 import { parseUnitId } from "./unit-id.js";
 import { withFileLock } from "./file-lock.js";
-/** Read and parse the frozen DEFINITION.yaml from a run directory. */
-export function readFrozenDefinition(runDir) {
-    const defPath = join(runDir, "DEFINITION.yaml");
-    const raw = readFileSync(defPath, "utf-8");
-    return parse(raw, { schema: "core" });
-}
+// Re-export for downstream consumers
+export { readFrozenDefinition } from "./definition-io.js";
 export class CustomWorkflowEngine {
     engineId = "custom";
     runDir;

package/dist/resources/extensions/gsd/definition-io.js

@@ -0,0 +1,15 @@
+/**
+ * definition-io.ts — Read frozen DEFINITION.yaml from a run directory.
+ *
+ * Extracted from custom-workflow-engine.ts to break the circular dependency
+ * between context-injector.ts and custom-workflow-engine.ts.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "yaml";
+/** Read and parse the frozen DEFINITION.yaml from a run directory. */
+export function readFrozenDefinition(runDir) {
+    const defPath = join(runDir, "DEFINITION.yaml");
+    const raw = readFileSync(defPath, "utf-8");
+    return parse(raw, { schema: "core" });
+}

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -102,6 +102,10 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
             }
         }
         else {
+            const milestoneUsesExplicitDeps = slices.some((slice) => slice.depends.length > 0);
+            if (milestoneUsesExplicitDeps) {
+                return null;
+            }
             // Positional fallback is only a heuristic for legacy slices with no
             // declared dependencies. Skip any earlier slice that depends on the
             // target, directly or transitively, or we can deadlock a valid zero-dep

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

@@ -147,10 +147,33 @@ const PROVIDER_ROUTES = {
     openai: ["github-copilot", "openai-codex"],
     google: ["google-gemini-cli"],
 };
+/**
+ * Providers that use external CLI authentication (not API keys).
+ * These are always considered "ok" — the host CLI handles auth.
+ */
+const CLI_AUTH_PROVIDERS = new Set([
+    "claude-code",
+    "openai-codex",
+    "google-gemini-cli",
+    "google-antigravity",
+]);
 function checkLlmProviders() {
     const required = collectConfiguredModelProviders();
     const results = [];
     for (const providerId of required) {
+        // CLI-authenticated providers don't need API keys — skip key check
+        if (CLI_AUTH_PROVIDERS.has(providerId)) {
+            const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
+            results.push({
+                name: providerId,
+                label: info?.label ?? providerId,
+                category: "llm",
+                status: "ok",
+                message: `${info?.label ?? providerId} — CLI auth (no key needed)`,
+                required: true,
+            });
+            continue;
+        }
         const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
         const label = providerId === "anthropic-vertex"
             ? "Anthropic Vertex"

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -277,13 +277,16 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
         if (existsSync(gitignorePath) && nativeIsRepo(basePath)) {
             const content = readFileSync(gitignorePath, "utf-8");
             const existingLines = new Set(content.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#")));
-            // Check for critical runtime patterns that must be present
+            // Check for critical runtime patterns that must be present.
+            // NOTE: GSD_RUNTIME_PATTERNS in gitignore.ts is the canonical source of truth.
+            // This is a minimal subset for the doctor check.
             const criticalPatterns = [
                 ".gsd/activity/",
                 ".gsd/runtime/",
                 ".gsd/auto.lock",
-                ".gsd/gsd.db",
-                ".gsd/completed-units.json",
+                ".gsd/gsd.db*",
+                ".gsd/completed-units*.json",
+                ".gsd/event-log.jsonl",
             ];
             // If blanket .gsd/ or .gsd is present, all patterns are covered
             const hasBlanketIgnore = existingLines.has(".gsd/") || existingLines.has(".gsd");

package/dist/resources/extensions/gsd/error-classifier.js

@@ -20,6 +20,9 @@ export function resetRetryState(state) {
 // ── Classification ──────────────────────────────────────────────────────────
 const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i;
 const RATE_LIMIT_RE = /rate.?limit|too many requests|429/i;
+// OpenRouter affordability-style quota errors should be treated as transient
+// so core retry logic can lower maxTokens and continue in-session.
+const AFFORDABILITY_RE = /requires more credits|can only afford|insufficient credits|not enough credits|fewer max_tokens/i;
 const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i;
 const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
@@ -42,7 +45,7 @@ const RESET_DELAY_RE = /reset in (\d+)s/i;
  */
 export function classifyError(errorMsg, retryAfterMs) {
     const isPermanent = PERMANENT_RE.test(errorMsg);
-    const isRateLimit = RATE_LIMIT_RE.test(errorMsg);
+    const isRateLimit = RATE_LIMIT_RE.test(errorMsg) || AFFORDABILITY_RE.test(errorMsg);
     // 1. Permanent — but rate limit takes precedence
     if (isPermanent && !isRateLimit) {
         return { kind: "permanent" };

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

@@ -0,0 +1,208 @@
+/**
+ * GSD Gate Registry — single source of truth for quality-gate ownership.
+ *
+ * Each gate declares which workflow turn owns it, the scope at which it is
+ * persisted in the `quality_gates` table, and the question/guidance text used
+ * in the prompt that turn sends. The registry replaces the ad-hoc
+ * `GATE_QUESTIONS` table that used to live in `auto-prompts.ts`, and every
+ * layer of the prompt system (prompt builders, dispatch rules, state
+ * derivation, tool handlers) consults it so a pending gate can never be
+ * silently dropped.
+ *
+ * Design notes:
+ *   - `GATE_REGISTRY` is exhaustiveness-checked against `GateId` via
+ *     `satisfies Record<GateId, GateDefinition>`, so adding a new GateId
+ *     without a registry entry is a compile error.
+ *   - `getGatesForTurn(turn)` returns the definitions a turn owns.
+ *   - `assertGateCoverage(pending, turn)` throws a GSDError if the pending
+ *     list for a turn contains unknown gates, or if any gate owned by the
+ *     turn is missing from the pending list.
+ */
+import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
+export const GATE_REGISTRY = {
+    Q3: {
+        id: "Q3",
+        scope: "slice",
+        ownerTurn: "gate-evaluate",
+        question: "How can this be exploited?",
+        guidance: [
+            "Identify abuse scenarios: parameter tampering, replay attacks, privilege escalation.",
+            "Map data exposure risks: PII, tokens, secrets accessible through this slice.",
+            "Define input trust boundaries: untrusted user input reaching DB, API, or filesystem.",
+            "If none apply, return verdict 'omitted' with rationale explaining why.",
+        ].join("\n"),
+        promptSection: "Abuse Surface",
+    },
+    Q4: {
+        id: "Q4",
+        scope: "slice",
+        ownerTurn: "gate-evaluate",
+        question: "What existing promises does this break?",
+        guidance: [
+            "List which existing requirements (R001, R003, etc.) are touched by this slice.",
+            "Identify what must be re-tested after shipping.",
+            "Flag decisions that should be revisited given the new scope.",
+            "If no existing requirements are affected, return verdict 'omitted'.",
+        ].join("\n"),
+        promptSection: "Broken Promises",
+    },
+    Q5: {
+        id: "Q5",
+        scope: "task",
+        ownerTurn: "execute-task",
+        question: "What breaks when dependencies fail?",
+        guidance: [
+            "Enumerate the task's external dependencies (APIs, filesystem, network, subprocesses).",
+            "Describe the failure path for each: timeout, malformed response, connection loss.",
+            "Verify the implementation handles each failure or explicitly bubbles the error.",
+            "Return verdict 'omitted' only if the task has no external dependencies.",
+        ].join("\n"),
+        promptSection: "Failure Modes",
+    },
+    Q6: {
+        id: "Q6",
+        scope: "task",
+        ownerTurn: "execute-task",
+        question: "What is the 10x load breakpoint?",
+        guidance: [
+            "Identify the resource that saturates first at 10x the expected load.",
+            "Describe the protection applied (pool sizing, rate limiting, pagination, caching).",
+            "Return verdict 'omitted' if the task has no runtime load dimension.",
+        ].join("\n"),
+        promptSection: "Load Profile",
+    },
+    Q7: {
+        id: "Q7",
+        scope: "task",
+        ownerTurn: "execute-task",
+        question: "What negative tests protect this task?",
+        guidance: [
+            "List malformed inputs, error paths, and boundary conditions the tests cover.",
+            "Point to the specific test files or cases that assert each negative scenario.",
+            "Return verdict 'omitted' only if the task has no meaningful negative surface.",
+        ].join("\n"),
+        promptSection: "Negative Tests",
+    },
+    Q8: {
+        id: "Q8",
+        scope: "slice",
+        ownerTurn: "complete-slice",
+        question: "How will ops know this slice is healthy or broken?",
+        guidance: [
+            "Describe the health signal (metric, log line, dashboard) that proves the slice works.",
+            "Describe the failure signal that triggers an alert or paging.",
+            "Document the recovery procedure and any monitoring gaps.",
+            "Return verdict 'omitted' only for slices with no runtime behavior at all.",
+        ].join("\n"),
+        promptSection: "Operational Readiness",
+    },
+    MV01: {
+        id: "MV01",
+        scope: "milestone",
+        ownerTurn: "validate-milestone",
+        question: "Is every success criterion in the milestone roadmap satisfied?",
+        guidance: [
+            "Walk the success-criteria checklist from the milestone roadmap.",
+            "For each criterion, point to the slice / assessment / verification evidence that proves it.",
+            "Return verdict 'flag' if any criterion is unmet or unverifiable.",
+        ].join("\n"),
+        promptSection: "Success Criteria Checklist",
+    },
+    MV02: {
+        id: "MV02",
+        scope: "milestone",
+        ownerTurn: "validate-milestone",
+        question: "Does every slice have a SUMMARY.md and a passing assessment?",
+        guidance: [
+            "Confirm every slice listed in the roadmap has a SUMMARY.md.",
+            "Confirm each slice has an ASSESSMENT verdict of 'pass' (or justified 'omitted').",
+            "Flag missing artifacts and slices with outstanding follow-ups or known limitations.",
+        ].join("\n"),
+        promptSection: "Slice Delivery Audit",
+    },
+    MV03: {
+        id: "MV03",
+        scope: "milestone",
+        ownerTurn: "validate-milestone",
+        question: "Do the slices integrate end-to-end?",
+        guidance: [
+            "Trace at least one cross-slice flow proving the pieces compose.",
+            "Flag gaps where two slices were built in isolation with no integration evidence.",
+        ].join("\n"),
+        promptSection: "Cross-Slice Integration",
+    },
+    MV04: {
+        id: "MV04",
+        scope: "milestone",
+        ownerTurn: "validate-milestone",
+        question: "Are all touched requirements covered and still coherent?",
+        guidance: [
+            "For each requirement advanced, validated, surfaced, or invalidated across the milestone's slices, confirm the milestone-level evidence matches.",
+            "Flag requirements that slices claim to advance but no artifact proves.",
+        ].join("\n"),
+        promptSection: "Requirement Coverage",
+    },
+};
+/** Stable ordered lists per owner turn — iteration order matches declaration. */
+const ORDERED_GATES = Object.values(GATE_REGISTRY);
+/** Return every gate owned by a turn, in stable declaration order. */
+export function getGatesForTurn(turn) {
+    return ORDERED_GATES.filter((g) => g.ownerTurn === turn);
+}
+/** Return the set of gate ids a turn owns. */
+export function getGateIdsForTurn(turn) {
+    return new Set(getGatesForTurn(turn).map((g) => g.id));
+}
+/** Look up a definition by gate id, or undefined if unknown. */
+export function getGateDefinition(id) {
+    return GATE_REGISTRY[id];
+}
+/** Look up the owner turn for a gate id. Throws if the gate is unknown. */
+export function getOwnerTurn(id) {
+    const def = GATE_REGISTRY[id];
+    if (!def) {
+        throw new GSDError(GSD_PARSE_ERROR, `gate-registry: unknown gate id "${id}"`);
+    }
+    return def.ownerTurn;
+}
+/**
+ * Assert that the pending gate rows for a turn match what the registry says
+ * the turn owns. Fails loudly rather than silently skipping.
+ *
+ * - Every row in `pending` must have a definition whose `ownerTurn` matches `turn`.
+ *   (The caller is responsible for scoping the pending list — e.g. filtering
+ *   by slice scope before passing it in.)
+ * - `options.requireAll` (default true): every gate the turn owns must appear
+ *   in `pending`. Set to false for turns like `execute-task` that only need
+ *   coverage for the subset of gates that were seeded (e.g. tasks with no
+ *   external dependencies have no Q5 row).
+ */
+export function assertGateCoverage(pending, turn, options = {}) {
+    const requireAll = options.requireAll ?? true;
+    const expected = getGateIdsForTurn(turn);
+    const pendingIds = new Set(pending.map((g) => g.gate_id));
+    const unknown = [];
+    for (const id of pendingIds) {
+        const def = getGateDefinition(id);
+        if (!def) {
+            unknown.push(id);
+            continue;
+        }
+        if (def.ownerTurn !== turn) {
+            unknown.push(`${id} (owned by ${def.ownerTurn}, not ${turn})`);
+        }
+    }
+    if (unknown.length > 0) {
+        throw new GSDError(GSD_PARSE_ERROR, `assertGateCoverage: turn "${turn}" received pending gates it does not own: ${unknown.join(", ")}`);
+    }
+    if (requireAll) {
+        const missing = [];
+        for (const id of expected) {
+            if (!pendingIds.has(id))
+                missing.push(id);
+        }
+        if (missing.length > 0) {
+            throw new GSDError(GSD_PARSE_ERROR, `assertGateCoverage: turn "${turn}" is missing required gates: ${missing.join(", ")}`);
+        }
+    }
+}

package/dist/resources/extensions/gsd/git-service.js

@@ -78,22 +78,25 @@ export class MergeConflictError extends GSDError {
 /**
  * GSD runtime paths that should be excluded from smart staging.
  * These are transient/generated artifacts that should never be committed.
- * Matches the union of SKIP_PATHS + SKIP_EXACT in worktree-manager.ts
- * and the first 7 entries in gitignore.ts BASELINE_PATTERNS.
+ *
+ * NOTE: GSD_RUNTIME_PATTERNS in gitignore.ts is the canonical source of truth.
+ * This array must stay synchronized with it.
  */
 export const RUNTIME_EXCLUSION_PATHS = [
     ".gsd/activity/",
+    ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",
+    ".gsd/parallel/",
     ".gsd/auto.lock",
     ".gsd/metrics.json",
-    ".gsd/completed-units.json",
+    ".gsd/completed-units*.json", // covers completed-units.json and archived completed-units-{MID}.json
+    ".gsd/state-manifest.json",
     ".gsd/STATE.md",
-    ".gsd/gsd.db",
-    ".gsd/gsd.db-shm", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/gsd.db-wal", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/journal/", // daily-rotated JSONL event journal (#2296)
-    ".gsd/doctor-history.jsonl", // doctor run history (#2296)
+    ".gsd/gsd.db*",
+    ".gsd/journal/",
+    ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
 ];
 // ─── Integration Branch Metadata ───────────────────────────────────────────

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

@@ -13,6 +13,12 @@ import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 /**
  * GSD runtime patterns for git index cleanup.
+ *
+ * CANONICAL SOURCE OF TRUTH: This array is the authoritative list of runtime
+ * ignore patterns. Other modules (RUNTIME_EXCLUSION_PATHS in git-service.ts,
+ * SKIP_* arrays in worktree-manager.ts, criticalPatterns in doctor-runtime-checks.ts)
+ * must stay synchronized with this list.
+ *
  * With external state (symlink), these are a no-op in most cases,
  * but retained for backwards compatibility during migration.
  */
@@ -24,13 +30,13 @@ const GSD_RUNTIME_PATTERNS = [
     ".gsd/parallel/",
     ".gsd/auto.lock",
     ".gsd/metrics.json",
-    ".gsd/completed-units.json",
+    ".gsd/completed-units*.json", // covers completed-units.json and archived completed-units-{MID}.json
+    ".gsd/state-manifest.json",
     ".gsd/STATE.md",
-    ".gsd/gsd.db",
-    ".gsd/gsd.db-shm", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/gsd.db-wal", // SQLite WAL sidecar — always created alongside gsd.db (#2296)
-    ".gsd/journal/", // daily-rotated JSONL event journal (#2296)
-    ".gsd/doctor-history.jsonl", // doctor run history (#2296)
+    ".gsd/gsd.db*",
+    ".gsd/journal/",
+    ".gsd/doctor-history.jsonl",
+    ".gsd/event-log.jsonl",
     ".gsd/DISCUSSION-MANIFEST.json",
     ".gsd/milestones/**/*-CONTINUE.md",
     ".gsd/milestones/**/continue.md",

package/dist/resources/extensions/gsd/gsd-db.js

@@ -8,6 +8,7 @@ import { createRequire } from "node:module";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
+import { getGateIdsForTurn } from "./gate-registry.js";
 import { logError, logWarning } from "./workflow-logger.js";
 const _require = createRequire(import.meta.url);
 let providerName = null;
@@ -120,6 +121,25 @@ function openRawDb(path) {
     return new Database(path);
 }
 const SCHEMA_VERSION = 14;
+function indexExists(db, name) {
+    return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
+}
+function dedupeVerificationEvidenceRows(db) {
+    db.exec(`
+    DELETE FROM verification_evidence
+    WHERE rowid NOT IN (
+      SELECT MIN(rowid)
+      FROM verification_evidence
+      GROUP BY task_id, slice_id, milestone_id, command, verdict
+    )
+  `);
+}
+function ensureVerificationEvidenceDedupIndex(db) {
+    if (indexExists(db, "idx_verification_evidence_dedup"))
+        return;
+    dedupeVerificationEvidenceRows(db);
+    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
+}
 function initSchema(db, fileBacked) {
     if (fileBacked)
         db.exec("PRAGMA journal_mode=WAL");
@@ -131,7 +151,7 @@ function initSchema(db, fileBacked) {
         db.exec("PRAGMA auto_vacuum = INCREMENTAL");
     if (fileBacked)
         db.exec("PRAGMA cache_size = -8000"); // 8 MB page cache
-    if (fileBacked)
+    if (fileBacked && process.platform !== "darwin")
         db.exec("PRAGMA mmap_size = 67108864"); // 64 MB mmap
     db.exec("PRAGMA temp_store = MEMORY");
     db.exec("PRAGMA foreign_keys = ON");
@@ -357,7 +377,7 @@ function initSchema(db, fileBacked) {
         db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
-        db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
+        ensureVerificationEvidenceDedupIndex(db);
         // v14 index — slice dependency lookups
         db.exec("CREATE INDEX IF NOT EXISTS idx_slice_deps_target ON slice_dependencies(milestone_id, depends_on_slice_id)");
         db.exec(`CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL`);
@@ -667,7 +687,7 @@ function migrateSchema(db) {
             db.exec("CREATE INDEX IF NOT EXISTS idx_milestones_status ON milestones(status)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_quality_gates_pending ON quality_gates(milestone_id, slice_id, status)");
             db.exec("CREATE INDEX IF NOT EXISTS idx_verification_evidence_task ON verification_evidence(milestone_id, slice_id, task_id)");
-            db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_evidence_dedup ON verification_evidence(task_id, slice_id, milestone_id, command, verdict)");
+            ensureVerificationEvidenceDedupIndex(db);
             db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
                 ":version": 13,
                 ":applied_at": new Date().toISOString(),
@@ -799,6 +819,7 @@ export function closeDatabase() {
         currentDb = null;
         currentPath = null;
         currentPid = 0;
+        _dbOpenAttempted = false;
     }
 }
 /** Run a full VACUUM — call sparingly (e.g. after milestone completion). */
@@ -1332,6 +1353,29 @@ export function setSliceSummaryMd(milestoneId, sliceId, summaryMd, uatMd) {
     currentDb.prepare(`UPDATE slices SET full_summary_md = :summary_md, full_uat_md = :uat_md WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": milestoneId, ":sid": sliceId, ":summary_md": summaryMd, ":uat_md": uatMd });
 }
 function rowToTask(row) {
+    const parseTaskArray = (value) => {
+        if (Array.isArray(value)) {
+            return value.filter((entry) => typeof entry === "string");
+        }
+        if (typeof value !== "string")
+            return [];
+        const trimmed = value.trim();
+        if (!trimmed)
+            return [];
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed.filter((entry) => typeof entry === "string");
+            }
+            if (typeof parsed === "string" && parsed.trim()) {
+                return [parsed.trim()];
+            }
+        }
+        catch {
+            // Older/corrupt DB rows may contain raw comma-separated paths instead of JSON arrays.
+        }
+        return trimmed.split(",").map((entry) => entry.trim()).filter(Boolean);
+    };
     return {
         milestone_id: row["milestone_id"],
         slice_id: row["slice_id"],
@@ -1351,10 +1395,10 @@ function rowToTask(row) {
         full_summary_md: row["full_summary_md"],
         description: row["description"] ?? "",
         estimate: row["estimate"] ?? "",
-        files: JSON.parse(row["files"] || "[]"),
+        files: parseTaskArray(row["files"]),
         verify: row["verify"] ?? "",
-        inputs: JSON.parse(row["inputs"] || "[]"),
-        expected_output: JSON.parse(row["expected_output"] || "[]"),
+        inputs: parseTaskArray(row["inputs"]),
+        expected_output: parseTaskArray(row["expected_output"]),
         observability_impact: row["observability_impact"] ?? "",
         full_plan_md: row["full_plan_md"] ?? "",
         sequence: row["sequence"] ?? 0,
@@ -1927,3 +1971,43 @@ export function getPendingSliceGateCount(milestoneId, sliceId) {
      WHERE milestone_id = :mid AND slice_id = :sid AND scope = 'slice' AND status = 'pending'`).get({ ":mid": milestoneId, ":sid": sliceId });
     return row ? row["cnt"] : 0;
 }
+/**
+ * Return pending gate rows owned by a specific workflow turn.
+ *
+ * Unlike `getPendingGates(..., scope)`, this filters by the registry's
+ * `ownerTurn` metadata so callers can distinguish Q3/Q4 (owned by
+ * gate-evaluate) from Q8 (owned by complete-slice) even though both are
+ * scope:"slice". Pass `taskId` to narrow task-scoped results to one task.
+ */
+export function getPendingGatesForTurn(milestoneId, sliceId, turn, taskId) {
+    if (!currentDb)
+        return [];
+    const ids = getGateIdsForTurn(turn);
+    if (ids.size === 0)
+        return [];
+    const idList = [...ids];
+    const placeholders = idList.map((_, i) => `:gid${i}`).join(",");
+    const params = {
+        ":mid": milestoneId,
+        ":sid": sliceId,
+    };
+    idList.forEach((id, i) => {
+        params[`:gid${i}`] = id;
+    });
+    let sql = `SELECT * FROM quality_gates
+     WHERE milestone_id = :mid AND slice_id = :sid
+       AND status = 'pending'
+       AND gate_id IN (${placeholders})`;
+    if (taskId !== undefined) {
+        sql += ` AND task_id = :tid`;
+        params[":tid"] = taskId;
+    }
+    return currentDb.prepare(sql).all(params).map(rowToGate);
+}
+/**
+ * Count pending gates for a turn. Convenience wrapper used by state
+ * derivation to decide whether a phase transition should pause.
+ */
+export function getPendingGateCountForTurn(milestoneId, sliceId, turn) {
+    return getPendingGatesForTurn(milestoneId, sliceId, turn).length;
+}

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

@@ -26,6 +26,8 @@ export const PROVIDER_REGISTRY = [
     { id: "custom-openai", label: "Custom (OpenAI-compat)", category: "llm", envVar: "CUSTOM_OPENAI_API_KEY" },
     { id: "cerebras", label: "Cerebras", category: "llm", envVar: "CEREBRAS_API_KEY" },
     { id: "azure-openai-responses", label: "Azure OpenAI", category: "llm", envVar: "AZURE_OPENAI_API_KEY" },
+    { id: "alibaba-coding-plan", label: "Alibaba Coding Plan", category: "llm", envVar: "ALIBABA_API_KEY", dashboardUrl: "bailian.console.aliyun.com" },
+    { id: "alibaba-dashscope", label: "Alibaba DashScope", category: "llm", envVar: "DASHSCOPE_API_KEY", dashboardUrl: "dashscope.console.aliyun.com" },
     // Tool Keys
     { id: "context7", label: "Context7 Docs", category: "tool", envVar: "CONTEXT7_API_KEY", dashboardUrl: "context7.com/dashboard" },
     { id: "jina", label: "Jina Page Extract", category: "tool", envVar: "JINA_API_KEY", dashboardUrl: "jina.ai/api" },

package/dist/resources/extensions/gsd/milestone-validation-gates.js

@@ -6,17 +6,12 @@
  * records in the DB. This module inserts milestone-level validation gates
  * that correspond to the validation checks performed.
  *
- * Gate IDs for milestone validation:
- *   MV01 — Success criteria checklist
- *   MV02 — Slice delivery audit
- *   MV03 — Cross-slice integration
- *   MV04 — Requirement coverage
- *
- * These use the existing quality_gates table with scope "milestone".
+ * Gate IDs for milestone validation (MV01–MV04) are sourced from the
+ * gate registry so the definitions stay in lockstep with prompt builders,
+ * dispatch rules, and state derivation. See gate-registry.ts.
  */
 import { _getAdapter } from "./gsd-db.js";
-/** Milestone validation gate IDs. */
-const MILESTONE_GATE_IDS = ["MV01", "MV02", "MV03", "MV04"];
+import { getGatesForTurn } from "./gate-registry.js";
 /**
  * Insert milestone-level quality_gates records for a validation run.
  *
@@ -24,21 +19,25 @@ const MILESTONE_GATE_IDS = ["MV01", "MV02", "MV03", "MV04"];
  * from the overall milestone validation verdict. Individual gate-level
  * verdicts are not available (the handler receives a single verdict),
  * so all gates share the overall verdict.
+ *
+ * Gate IDs come from the registry — adding/removing an MV-scoped gate
+ * in gate-registry.ts automatically flows through here.
  */
 export function insertMilestoneValidationGates(milestoneId, sliceId, verdict, evaluatedAt) {
     const db = _getAdapter();
     if (!db)
         return;
     const gateVerdict = verdict === "pass" ? "pass" : "flag";
-    for (const gateId of MILESTONE_GATE_IDS) {
+    const milestoneGates = getGatesForTurn("validate-milestone");
+    for (const def of milestoneGates) {
         db.prepare(`INSERT OR REPLACE INTO quality_gates
        (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
        VALUES (:mid, :sid, :gid, 'milestone', '', 'complete', :verdict, :rationale, '', :evaluated_at)`).run({
             ":mid": milestoneId,
             ":sid": sliceId,
-            ":gid": gateId,
+            ":gid": def.id,
             ":verdict": gateVerdict,
-            ":rationale": `Milestone validation verdict: ${verdict}`,
+            ":rationale": `${def.promptSection} — milestone validation verdict: ${verdict}`,
             ":evaluated_at": evaluatedAt,
         });
     }