@opengsd/gsd-pi 1.0.2-dev.e70300c → 1.0.2-dev.fb7ddf1

package/dist/resources/extensions/gsd/state-reconciliation/drift/artifact-db.js

@@ -0,0 +1,351 @@
+// Project/App: gsd-pi
+// File Purpose: Fail-closed reconciliation guards for DB/artifact and slice-id drift.
+import { existsSync, lstatSync, mkdirSync, readdirSync, renameSync, rmSync, } from "node:fs";
+import { basename, join } from "node:path";
+import { _getAdapter, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, } from "../../gsd-db.js";
+import { clearParseCache } from "../../files.js";
+import { clearPathCache, gsdProjectionRoot, resolveMilestonePath, resolveSliceFile, resolveTaskFile, } from "../../paths.js";
+import { isClosedStatus } from "../../status-guards.js";
+import { invalidateStateCache } from "../../state.js";
+import { isAfter, latestExplicitReopenAt } from "../../milestone-reopen-events.js";
+function safeListArtifactRows(milestoneId) {
+    const adapter = _getAdapter();
+    if (!adapter)
+        return [];
+    try {
+        return adapter
+            .prepare(`SELECT path, artifact_type, milestone_id, slice_id, task_id, imported_at
+         FROM artifacts
+         WHERE milestone_id = :mid
+         ORDER BY imported_at, path`)
+            .all({ ":mid": milestoneId });
+    }
+    catch {
+        return [];
+    }
+}
+function latestCompletedMilestoneDispatch(milestoneId) {
+    const adapter = _getAdapter();
+    if (!adapter)
+        return null;
+    try {
+        const row = adapter
+            .prepare(`SELECT started_at, ended_at
+         FROM unit_dispatches
+         WHERE milestone_id = :mid
+           AND unit_type = 'complete-milestone'
+           AND unit_id = :mid
+           AND status = 'completed'
+         ORDER BY COALESCE(ended_at, started_at) DESC, id DESC
+         LIMIT 1`)
+            .get({ ":mid": milestoneId });
+        return row ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function hasExplicitReopenAfter(basePath, milestoneId, completedDispatchAt) {
+    const reopenAt = latestExplicitReopenAt(basePath, milestoneId);
+    if (!reopenAt)
+        return false;
+    if (!completedDispatchAt)
+        return true;
+    return Date.parse(reopenAt) > Date.parse(completedDispatchAt);
+}
+function addUniqueDrift(drifts, seen, drift) {
+    const key = [
+        drift.milestoneId,
+        drift.sliceId ?? "",
+        drift.taskId ?? "",
+        drift.artifactType,
+        drift.artifactPath ?? "",
+        drift.reason,
+    ].join("|");
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    drifts.push(drift);
+}
+function detectArtifactDbStatusDriftForMilestone(basePath, milestoneId) {
+    const milestone = getAllMilestones().find((m) => m.id === milestoneId);
+    if (!milestone || isClosedStatus(milestone.status))
+        return [];
+    const latestReopen = latestExplicitReopenAt(basePath, milestoneId);
+    const artifacts = safeListArtifactRows(milestoneId).filter((row) => isAfter(row.imported_at, latestReopen));
+    const bySlice = new Map(getMilestoneSlices(milestoneId).map((slice) => [slice.id, slice]));
+    const drifts = [];
+    const seen = new Set();
+    for (const slice of bySlice.values()) {
+        if (!isClosedStatus(slice.status)) {
+            const diskSummary = resolveSliceFile(basePath, milestoneId, slice.id, "SUMMARY");
+            if (diskSummary && existsSync(diskSummary)) {
+                addUniqueDrift(drifts, seen, {
+                    kind: "artifact-db-status-divergence",
+                    milestoneId,
+                    sliceId: slice.id,
+                    artifactType: "SUMMARY",
+                    artifactPath: diskSummary,
+                    dbStatus: slice.status,
+                    reason: `slice ${slice.id} has SUMMARY on disk while DB status is ${slice.status}`,
+                });
+            }
+        }
+        const tasks = getSliceTasks(milestoneId, slice.id);
+        const taskById = new Map(tasks.map((task) => [task.id, task]));
+        const summaryRows = artifacts.filter((row) => row.artifact_type === "SUMMARY" &&
+            row.slice_id === slice.id &&
+            row.task_id);
+        if (tasks.length === 0 && summaryRows.length > 0) {
+            addUniqueDrift(drifts, seen, {
+                kind: "artifact-db-status-divergence",
+                milestoneId,
+                sliceId: slice.id,
+                artifactType: "SUMMARY",
+                artifactPath: summaryRows[0]?.path,
+                dbStatus: "no-db-tasks",
+                reason: `slice ${slice.id} has task SUMMARY artifacts but no DB tasks`,
+            });
+        }
+        for (const row of summaryRows) {
+            const task = row.task_id ? taskById.get(row.task_id) : null;
+            if (!task) {
+                if (tasks.length > 0) {
+                    addUniqueDrift(drifts, seen, {
+                        kind: "artifact-db-status-divergence",
+                        milestoneId,
+                        sliceId: slice.id,
+                        taskId: row.task_id ?? undefined,
+                        artifactType: "SUMMARY",
+                        artifactPath: row.path,
+                        dbStatus: "missing-db-task",
+                        reason: `task ${slice.id}/${row.task_id} has SUMMARY artifact but no DB task`,
+                    });
+                }
+                continue;
+            }
+            if (isClosedStatus(task.status))
+                continue;
+            addUniqueDrift(drifts, seen, {
+                kind: "artifact-db-status-divergence",
+                milestoneId,
+                sliceId: slice.id,
+                taskId: row.task_id ?? undefined,
+                artifactType: "SUMMARY",
+                artifactPath: row.path,
+                dbStatus: task.status,
+                reason: `task ${slice.id}/${row.task_id} has SUMMARY artifact while DB status is ${task.status}`,
+            });
+        }
+        for (const task of tasks) {
+            if (isClosedStatus(task.status))
+                continue;
+            const diskTaskSummary = resolveTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY");
+            if (!diskTaskSummary || !existsSync(diskTaskSummary))
+                continue;
+            addUniqueDrift(drifts, seen, {
+                kind: "artifact-db-status-divergence",
+                milestoneId,
+                sliceId: slice.id,
+                taskId: task.id,
+                artifactType: "SUMMARY",
+                artifactPath: diskTaskSummary,
+                dbStatus: task.status,
+                reason: `task ${slice.id}/${task.id} has SUMMARY on disk while DB status is ${task.status}`,
+            });
+        }
+    }
+    for (const row of artifacts) {
+        if (row.artifact_type !== "SUMMARY" || !row.slice_id || row.task_id)
+            continue;
+        const slice = bySlice.get(row.slice_id);
+        if (!slice || isClosedStatus(slice.status))
+            continue;
+        addUniqueDrift(drifts, seen, {
+            kind: "artifact-db-status-divergence",
+            milestoneId,
+            sliceId: row.slice_id,
+            artifactType: "SUMMARY",
+            artifactPath: row.path,
+            dbStatus: slice.status,
+            reason: `slice ${row.slice_id} has SUMMARY artifact while DB status is ${slice.status}`,
+        });
+    }
+    return drifts;
+}
+function classifyDiskOnlySliceDir(sliceDir) {
+    let sawScaffold = false;
+    const stack = [sliceDir];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return "block-meaningful";
+        }
+        if (entries.length === 0 && dir !== sliceDir) {
+            sawScaffold = true;
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry === ".DS_Store")
+                continue;
+            const full = join(dir, entry);
+            let stat;
+            try {
+                stat = lstatSync(full);
+            }
+            catch {
+                return "block-meaningful";
+            }
+            if (stat.isDirectory()) {
+                sawScaffold = true;
+                stack.push(full);
+                continue;
+            }
+            if (stat.isFile() && stat.size === 0) {
+                sawScaffold = true;
+                continue;
+            }
+            return "block-meaningful";
+        }
+    }
+    return sawScaffold ? "quarantine-scaffold" : "delete-empty";
+}
+function detectDiskSliceIdDivergenceForMilestone(basePath, milestoneId) {
+    const milestonePath = resolveMilestonePath(basePath, milestoneId);
+    if (!milestonePath)
+        return [];
+    const slicesDir = join(milestonePath, "slices");
+    if (!existsSync(slicesDir))
+        return [];
+    const knownSliceIds = new Set(getMilestoneSlices(milestoneId).map((slice) => slice.id));
+    const drifts = [];
+    for (const entry of readdirSync(slicesDir)) {
+        const sliceDir = join(slicesDir, entry);
+        try {
+            if (!lstatSync(sliceDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (entry === "parallel-research")
+            continue;
+        if (knownSliceIds.has(entry))
+            continue;
+        const disposition = classifyDiskOnlySliceDir(sliceDir);
+        drifts.push({
+            kind: "disk-slice-id-divergence",
+            milestoneId,
+            sliceId: entry,
+            sliceDir,
+            disposition,
+            reason: disposition === "block-meaningful"
+                ? `disk-only slice directory ${entry} contains meaningful files and is not in the DB`
+                : `disk-only slice directory ${entry} is not in the DB`,
+        });
+    }
+    return drifts;
+}
+export function detectArtifactDbDrift(_state, ctx) {
+    if (!isDbAvailable())
+        return [];
+    const drifts = [];
+    for (const milestone of getAllMilestones()) {
+        if (isClosedStatus(milestone.status))
+            continue;
+        const completedDispatch = latestCompletedMilestoneDispatch(milestone.id);
+        const completedAt = completedDispatch?.ended_at ?? completedDispatch?.started_at ?? null;
+        if (completedDispatch &&
+            !hasExplicitReopenAfter(ctx.basePath, milestone.id, completedAt)) {
+            drifts.push({
+                kind: "completed-milestone-reopened",
+                milestoneId: milestone.id,
+                dbStatus: milestone.status,
+                completedDispatchAt: completedAt,
+            });
+        }
+        drifts.push(...detectArtifactDbStatusDriftForMilestone(ctx.basePath, milestone.id));
+        drifts.push(...detectDiskSliceIdDivergenceForMilestone(ctx.basePath, milestone.id));
+    }
+    return drifts;
+}
+function quarantineSliceDir(record, basePath) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const quarantineDir = join(gsdProjectionRoot(basePath), "quarantine", "milestones", record.milestoneId, "slices");
+    mkdirSync(quarantineDir, { recursive: true });
+    const target = join(quarantineDir, `${basename(record.sliceDir)}-${stamp}`);
+    renameSync(record.sliceDir, target);
+}
+function diskSliceIdDivergenceGuidance(record) {
+    const quarantineExample = `.gsd/quarantine/milestones/${record.milestoneId}/slices/${record.sliceId}-manual-review`;
+    return (`Slice ID drift in ${record.milestoneId}: ${record.reason}. ` +
+        "Runtime will not import disk-only slice IDs into the DB. " +
+        `Review ${record.sliceDir}. ` +
+        `If ${record.sliceId} is stale, move or delete that directory; to preserve it, move it under ${quarantineExample}. ` +
+        "If it contains work to keep, copy or merge that content into a DB-backed slice, or explicitly recreate the slice through GSD planning, then remove the disk-only directory. " +
+        `After repair, run /gsd doctor ${record.milestoneId}, then resume with /gsd next or /gsd auto.`);
+}
+export function repairArtifactDbDrift(record, ctx) {
+    if (record.kind === "disk-slice-id-divergence") {
+        if (record.disposition === "delete-empty") {
+            rmSync(record.sliceDir, { recursive: true, force: true });
+        }
+        else if (record.disposition === "quarantine-scaffold") {
+            quarantineSliceDir(record, ctx.basePath);
+        }
+        else {
+            throw new Error(diskSliceIdDivergenceGuidance(record));
+        }
+        clearPathCache();
+        clearParseCache();
+        invalidateStateCache();
+        return;
+    }
+    if (record.kind === "completed-milestone-reopened") {
+        throw new Error(`Milestone ${record.milestoneId} has completed complete-milestone dispatch history` +
+            ` (${record.completedDispatchAt ?? "time unknown"}) but the DB status is ${record.dbStatus}. ` +
+            "Refusing to plan it again without an explicit reopen or recovery.");
+    }
+    throw new Error(`Artifact/DB status drift in ${record.milestoneId}` +
+        `${record.sliceId ? `/${record.sliceId}` : ""}` +
+        `${record.taskId ? `/${record.taskId}` : ""}: ${record.reason}. ` +
+        "Runtime will not silently import completion artifacts into DB state; run explicit recovery/repair after review.");
+}
+export function describeArtifactDbDriftBlocker(record) {
+    if (record.kind === "disk-slice-id-divergence") {
+        if (record.disposition !== "block-meaningful")
+            return null;
+        return diskSliceIdDivergenceGuidance(record);
+    }
+    if (record.kind === "completed-milestone-reopened") {
+        return (`Milestone ${record.milestoneId} has completed complete-milestone dispatch history` +
+            ` (${record.completedDispatchAt ?? "time unknown"}) but the DB status is ${record.dbStatus}. ` +
+            "Refusing to plan it again without an explicit reopen or recovery.");
+    }
+    return (`Artifact/DB status drift in ${record.milestoneId}` +
+        `${record.sliceId ? `/${record.sliceId}` : ""}` +
+        `${record.taskId ? `/${record.taskId}` : ""}: ${record.reason}. ` +
+        "Runtime will not silently import completion artifacts into DB state; run explicit recovery/repair after review.");
+}
+export const diskSliceIdDivergenceHandler = {
+    kind: "disk-slice-id-divergence",
+    detect: (state, ctx) => detectArtifactDbDrift(state, ctx).filter((record) => record.kind === "disk-slice-id-divergence"),
+    blocker: describeArtifactDbDriftBlocker,
+    repair: repairArtifactDbDrift,
+};
+export const artifactDbStatusDivergenceHandler = {
+    kind: "artifact-db-status-divergence",
+    detect: (state, ctx) => detectArtifactDbDrift(state, ctx).filter((record) => record.kind === "artifact-db-status-divergence"),
+    blocker: describeArtifactDbDriftBlocker,
+    repair: repairArtifactDbDrift,
+};
+export const completedMilestoneReopenedHandler = {
+    kind: "completed-milestone-reopened",
+    detect: (state, ctx) => detectArtifactDbDrift(state, ctx).filter((record) => record.kind === "completed-milestone-reopened"),
+    blocker: describeArtifactDbDriftBlocker,
+    repair: repairArtifactDbDrift,
+};

package/dist/resources/extensions/gsd/state-reconciliation/index.js

@@ -42,6 +42,8 @@ export async function reconcileBeforeDispatch(basePath, deps = defaultDeps) {
             };
         }
         const failures = [];
+        const blockers = [];
+        let repairedThisPass = false;
         for (const record of drift) {
             const handler = registry.find((h) => h.kind === record.kind);
             if (!handler) {
@@ -51,14 +53,33 @@ export async function reconcileBeforeDispatch(basePath, deps = defaultDeps) {
                 });
                 continue;
             }
+            const blocker = handler.blocker ? await handler.blocker(record, ctx) : null;
+            if (blocker) {
+                blockers.push(blocker);
+                continue;
+            }
             try {
                 await handler.repair(record, ctx);
                 repaired.push(record);
+                repairedThisPass = true;
             }
             catch (cause) {
                 failures.push({ drift: record, cause });
             }
         }
+        if (blockers.length > 0) {
+            let blockerState = stateSnapshot;
+            if (repairedThisPass) {
+                deps.invalidateStateCache();
+                blockerState = await deps.deriveState(basePath, deps.deriveStateOptions);
+            }
+            return {
+                ok: true,
+                stateSnapshot: blockerState,
+                repaired,
+                blockers: [...new Set([...(blockerState.blockers ?? []), ...blockers])],
+            };
+        }
         if (failures.length > 0) {
             throw new ReconciliationFailedError({ failures, pass });
         }
@@ -70,6 +91,26 @@ export async function reconcileBeforeDispatch(basePath, deps = defaultDeps) {
     const finalCtx = { basePath, state: finalState };
     const persistent = await detectAllDrift(finalState, finalCtx, registry);
     if (persistent.length > 0) {
+        const blockers = [];
+        const unblockedPersistent = [];
+        for (const record of persistent) {
+            const handler = registry.find((h) => h.kind === record.kind);
+            const blocker = handler?.blocker ? await handler.blocker(record, finalCtx) : null;
+            if (blocker) {
+                blockers.push(blocker);
+            }
+            else {
+                unblockedPersistent.push(record);
+            }
+        }
+        if (blockers.length > 0 && unblockedPersistent.length === 0) {
+            return {
+                ok: true,
+                stateSnapshot: finalState,
+                repaired,
+                blockers: [...new Set([...(finalState.blockers ?? []), ...blockers])],
+            };
+        }
         throw new ReconciliationFailedError({ persistentDrift: persistent });
     }
     return {

package/dist/resources/extensions/gsd/state-reconciliation/registry.js

@@ -2,6 +2,7 @@
 // File Purpose: ADR-017 drift handler registry. Single source of truth for
 // the catalog. Tests can override per-call via ReconciliationDeps.registry.
 import { completionTimestampHandler } from "./drift/completion.js";
+import { artifactDbStatusDivergenceHandler, completedMilestoneReopenedHandler, diskSliceIdDivergenceHandler, } from "./drift/artifact-db.js";
 import { mergeStateHandler } from "./drift/merge-state.js";
 import { unregisteredMilestoneHandler } from "./drift/project-md.js";
 import { roadmapDivergenceHandler } from "./drift/roadmap.js";
@@ -19,6 +20,9 @@ export const DRIFT_REGISTRY = [
     staleRenderHandler,
     staleWorkerHandler,
     unregisteredMilestoneHandler,
+    diskSliceIdDivergenceHandler,
     roadmapDivergenceHandler,
+    completedMilestoneReopenedHandler,
+    artifactDbStatusDivergenceHandler,
     completionTimestampHandler,
 ];

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -116,6 +116,15 @@ export async function handleCompleteTask(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
+    if (!params.oneLiner || typeof params.oneLiner !== "string" || params.oneLiner.trim() === "") {
+        return { error: "oneLiner is required and must be a non-empty string" };
+    }
+    if (!params.narrative || typeof params.narrative !== "string" || params.narrative.trim() === "") {
+        return { error: "narrative is required and must be a non-empty string" };
+    }
+    if (!params.verification || typeof params.verification !== "string" || params.verification.trim() === "") {
+        return { error: "verification is required and must be a non-empty string" };
+    }
     const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
     // ── Ownership check (opt-in: only enforced when claim file exists) ──────
     const ownershipErr = checkOwnership(artifactBasePath, taskUnitKey(params.milestoneId, params.sliceId, params.taskId), params.actorName);

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -40,6 +40,42 @@ function paramError(message) {
         isError: true,
     };
 }
+function normalizeRuntime(value) {
+    if (value === undefined || value === null || value === "")
+        return "bash";
+    if (typeof value !== "string") {
+        return paramError(`invalid runtime "${String(value)}" — must be bash | node | python`);
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "" || normalized === "bash" || normalized === "sh" || normalized === "shell")
+        return "bash";
+    if (normalized === "node" || normalized === "nodejs" || normalized === "js" || normalized === "javascript")
+        return "node";
+    if (normalized === "python" || normalized === "python3" || normalized === "py")
+        return "python";
+    return paramError(`invalid runtime "${value}" — must be bash | node | python`);
+}
+function normalizeScript(params) {
+    const candidates = [params.script, params.command, params.cmd, params.code];
+    let sawNonString = false;
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === null)
+            continue;
+        if (typeof candidate !== "string") {
+            sawNonString = true;
+            continue;
+        }
+        if (candidate.trim().length > 0)
+            return candidate;
+    }
+    if (sawNonString) {
+        return paramError("script/command must be a non-empty string");
+    }
+    return paramError("script is required and must be a non-empty string");
+}
+function isToolExecutionResult(value) {
+    return typeof value === "object" && value !== null && Array.isArray(value.content);
+}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -151,14 +187,12 @@ function scriptReferencesOriginalRootFromWorktree(script, baseDir) {
 export async function executeGsdExec(params, deps) {
     if (!isEnabled(deps.preferences))
         return contextModeDisabledResult("gsd_exec");
-    const runtime = params.runtime;
-    if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
-        return paramError(`invalid runtime "${String(runtime)}" — must be bash | node | python`);
-    }
-    const script = typeof params.script === "string" ? params.script : "";
-    if (script.trim().length === 0) {
-        return paramError("script is required and must be a non-empty string");
-    }
+    const runtime = normalizeRuntime(params.runtime);
+    if (isToolExecutionResult(runtime))
+        return runtime;
+    const script = normalizeScript(params);
+    if (isToolExecutionResult(script))
+        return script;
     if (Buffer.byteLength(script, "utf8") > 200_000) {
         return paramError("script exceeds the 200 KB length limit");
     }

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -6,8 +6,10 @@ import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, should
 import { getActiveRequirements, insertMilestone, getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
-import { resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { clearPathCache, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { saveFile, clearParseCache } from "../files.js";
 import { unlinkSync } from "node:fs";
+import { join } from "node:path";
 import { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
 import { handleCompleteSlice } from "./complete-slice.js";
@@ -56,6 +58,25 @@ function registerProjectMilestoneSequence(content) {
     }
     return registered;
 }
+async function mirrorArtifactToActiveWorktreeProjection(basePath, relativePath, content) {
+    const contract = resolveGsdPathContract(basePath);
+    if (!contract.worktreeGsd)
+        return;
+    if (contract.worktreeGsd === contract.projectGsd)
+        return;
+    const fullPath = join(contract.worktreeGsd, relativePath);
+    try {
+        await saveFile(fullPath, content);
+        clearPathCache();
+        clearParseCache();
+        invalidateStateCache();
+    }
+    catch (err) {
+        logWarning("tool", `gsd_summary_save worktree projection mirror failed: ${err.message}`, {
+            path: relativePath,
+        });
+    }
+}
 export async function executeSummarySave(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {
@@ -145,6 +166,7 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
             slice_id: isRootArtifact ? undefined : params.slice_id,
             task_id: isRootArtifact ? undefined : params.task_id,
         }, basePath);
+        await mirrorArtifactToActiveWorktreeProjection(basePath, relativePath, contentToSave);
         let registeredMilestones = [];
         if (params.artifact_type === "PROJECT") {
             try {
@@ -238,6 +260,24 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         };
     }
 }
+function normalizeVerificationEvidence(evidence) {
+    return (evidence ?? []).map((entry) => typeof entry === "string"
+        ? { command: entry, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 }
+        : entry);
+}
+function deriveVerificationSummary(evidence) {
+    if (evidence.length === 0)
+        return null;
+    const rendered = evidence.slice(0, 3).map((entry) => {
+        const command = entry.command.trim() || "(unspecified command)";
+        const verdict = entry.verdict.trim() || "recorded";
+        return `\`${command}\` exited ${entry.exitCode} (${verdict})`;
+    });
+    const suffix = evidence.length > rendered.length
+        ? `; ${evidence.length - rendered.length} more check(s) recorded`
+        : "";
+    return `Verification evidence recorded: ${rendered.join("; ")}${suffix}.`;
+}
 export async function executeTaskComplete(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {
@@ -249,7 +289,28 @@ export async function executeTaskComplete(params, basePath = process.cwd()) {
     }
     try {
         const coerced = { ...params };
-        coerced.verificationEvidence = (params.verificationEvidence ?? []).map((v) => typeof v === "string" ? { command: v, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 } : v);
+        const verificationEvidence = normalizeVerificationEvidence(params.verificationEvidence);
+        coerced.verificationEvidence = verificationEvidence;
+        const verification = typeof params.verification === "string" ? params.verification.trim() : "";
+        if (verification.length === 0) {
+            const derived = deriveVerificationSummary(verificationEvidence);
+            if (derived) {
+                coerced.verification = derived;
+            }
+            else if (params.blockerDiscovered === true) {
+                coerced.verification = "Not run: blocker discovered before verification.";
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "Error completing task: verification is required unless verificationEvidence is provided or blockerDiscovered is true.",
+                        }],
+                    details: { operation: "complete_task", error: "verification_required" },
+                    isError: true,
+                };
+            }
+        }
         const result = await handleCompleteTask(coerced, basePath);
         if ("error" in result) {
             return {

package/dist/resources/extensions/gsd/tui/render-kit.js

@@ -105,3 +105,54 @@ export function renderFrame(theme, inner, width, options = {}) {
     lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
     return lines.map((line) => safeLine(line, width, ""));
 }
+function renderTitledTopBorder(theme, title, width, border) {
+    const trimmedTitle = title.trim();
+    if (!trimmedTitle || width < 10) {
+        return border("╭" + "─".repeat(width - 2) + "╮");
+    }
+    const maxTitleWidth = Math.max(0, width - 7);
+    const safeTitle = safeLine(trimmedTitle, maxTitleWidth);
+    const fill = Math.max(0, width - visibleWidth(safeTitle) - 5);
+    return border("╭─ ") + theme.bold(theme.fg("accent", safeTitle)) + border(" " + "─".repeat(fill) + "╮");
+}
+export function renderDialogFrame(theme, title, inner, width, options = {}) {
+    if (width < 4)
+        return inner.map((line) => safeLine(line, width));
+    const borderColor = options.borderColor ?? "borderAccent";
+    const paddingX = Math.max(0, options.paddingX ?? 1);
+    const contentWidth = Math.max(0, width - 2 - paddingX * 2);
+    const border = (text) => theme.fg(borderColor, text);
+    const pad = " ".repeat(paddingX);
+    const lines = [renderTitledTopBorder(theme, title, width, border)];
+    const scroll = options.scroll;
+    const bodyRows = inner.length;
+    const trackOffset = Math.max(0, Math.min(scroll?.trackOffset ?? 0, bodyRows));
+    const trackRows = Math.max(0, Math.min(scroll?.trackRows ?? bodyRows, bodyRows - trackOffset));
+    const scrollable = !!scroll && scroll.totalRows > scroll.visibleRows && trackRows > 0;
+    const thumbLen = scrollable
+        ? Math.max(1, Math.round((scroll.visibleRows / scroll.totalRows) * trackRows))
+        : 0;
+    const maxThumbStart = Math.max(0, trackRows - thumbLen);
+    const maxScrollOffset = scrollable ? Math.max(1, scroll.totalRows - scroll.visibleRows) : 1;
+    const thumbStart = scrollable
+        ? trackOffset + Math.min(maxThumbStart, Math.round((scroll.offset / maxScrollOffset) * maxThumbStart))
+        : -1;
+    for (let i = 0; i < inner.length; i++) {
+        const line = inner[i] ?? "";
+        const rightBorder = scrollable && i >= thumbStart && i < thumbStart + thumbLen ? "┃" : "│";
+        lines.push(border("│") + pad + padRightVisible(line, contentWidth) + pad + border(rightBorder));
+    }
+    const footer = Array.isArray(options.footer)
+        ? options.footer
+        : options.footer
+            ? [options.footer]
+            : [];
+    if (footer.length > 0) {
+        lines.push(border("├" + "─".repeat(width - 2) + "┤"));
+        for (const line of footer) {
+            lines.push(border("│") + pad + padRightVisible(line, contentWidth) + pad + border("│"));
+        }
+    }
+    lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
+    return lines.map((line) => safeLine(line, width, ""));
+}