@amityco/social-plus-vise 1.4.6 → 1.5.0

package/dist/server.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createHash } from "node:crypto";
 import { copyFile, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -20,7 +21,7 @@ import { recordLearningTool, showLearningTool } from "./tools/learning.js";
 import { inspectProjectTool, validateSetupTool } from "./tools/project.js";
 import { resolveRequestTool, suggestPatchTool } from "./tools/resolve.js";
 import { runSensorsTool } from "./tools/sensors.js";
-import { smokeTool } from "./tools/smoke.js";
+import { smokeTool, writeRuntimeProofWaiver } from "./tools/smoke.js";
 import { getSdkFactsTool } from "./tools/sdkFacts.js";
 import { addBlockInstall, listRegistryBlocks, planBlockInstall, validateBlockInstall } from "./tools/blocks.js";
 import { debugIssueTool, debugIssue } from "./tools/debug.js";
@@ -29,6 +30,7 @@ import { uxHarnessTool } from "./tools/uxHarness.js";
 import { exploreRequest } from "./explore.js";
 import { renderHuman, wantsHumanFormat } from "./humanFormat.js";
 import { buildSource, packageName, packageRoot, packageVersion } from "./version.js";
+import { resolveOutcome, relatedOutcomes } from "./outcomes.js";
 const SUPPORT_URL = "mailto:support@social.plus";
 const tools = new Map([
     searchDocsTool,
@@ -314,12 +316,16 @@ async function handleCli(args) {
             const subArgs = args.slice(2);
             if (sub === "next" || sub === "status") {
                 assertOnlyKnownFlags(subArgs, ["request", "surface", "surface-path", "answer"], `workplan ${sub}`);
-                console.log(JSON.stringify(await workplanStatus(subArgs), null, 2));
+                const payload = await workplanStatus(subArgs);
+                console.log(JSON.stringify(payload, null, 2));
+                process.exitCode = workplanExitCode(payload);
                 return "exit";
             }
             if (sub === "complete") {
                 assertOnlyKnownFlags(subArgs, ["request", "surface", "surface-path", "answer", "note"], "workplan complete");
-                console.log(JSON.stringify(await completeWorkplanSurface(subArgs), null, 2));
+                const payload = await completeWorkplanSurface(subArgs);
+                console.log(JSON.stringify(payload, null, 2));
+                process.exitCode = workplanExitCode(payload);
                 return "exit";
             }
             if (sub === "trim") {
@@ -356,6 +362,18 @@ async function handleCli(args) {
             }
             return "exit";
         }
+        if (command === "smoke" && args[1] === "waive") {
+            const waiveArgs = args.slice(2);
+            assertOnlyKnownFlags(waiveArgs, ["reason", "mode"], "smoke waive");
+            const reason = requiredFlagValue(waiveArgs, "reason", "smoke waive requires --reason \"<why runtime proof is not being performed>\".");
+            const modeRaw = flagValue(waiveArgs, "mode") ?? "declined";
+            if (modeRaw !== "declined" && modeRaw !== "deviceless") {
+                throw new Error('smoke waive --mode must be "declined" (user opted out) or "deviceless" (no device/emulator available).');
+            }
+            const waiver = await writeRuntimeProofWaiver(positionalRepoPath(waiveArgs), modeRaw, reason, new Date().toISOString());
+            console.log(JSON.stringify({ status: "waived", waiver, note: "Runtime proof waived — NOT runtime-proven. `vise check` will report runtime-proof-waived (exit 9; pass --allow-proof-waiver to exit 0). Remove sp-vise/evidence/runtime-proof-waiver.json to re-require proof." }, null, 2));
+            return "exit";
+        }
         if (command === "smoke") {
             const printed = await printToolResult(smokeTool, {
                 repoPath: positionalRepoPath(args.slice(1)),
@@ -366,7 +384,7 @@ async function handleCli(args) {
             if (status === "failed") {
                 process.exitCode = 1;
             }
-            else if (status === "no-config" || status === "no-log" || status === "no-surfaces") {
+            else if (status === "no-config" || status === "no-log" || status === "no-surfaces" || status === "no-source-provenance") {
                 process.exitCode = 2;
             }
             return "exit";
@@ -448,15 +466,15 @@ async function handleCli(args) {
             const initRepo = positionalRepoPath(args.slice(1));
             const initRequest = requiredFlagValue(args, "request", "init requires --request.");
             const initWorkplanPlan = await workplanPlan(initRepo, initRequest, args);
-            const { sequence: initSequence, omitted: initOmitted } = await activeBlueprint(initRepo, initRequest, initWorkplanPlan);
+            const { sequence: initSequence, omitted: initOmitted, canonicalRequest: initCanonicalRequest } = await activeBlueprint(initRepo, initRequest, initWorkplanPlan);
             if (initSequence.length >= 2 && initWorkplanPlan.platform !== "unknown") {
-                const blueprintGate = await requireBlueprintConfirmation(initRepo, initRequest, initWorkplanPlan, initSequence, args, new Date().toISOString(), initOmitted);
+                const blueprintGate = await requireBlueprintConfirmation(initRepo, initCanonicalRequest, initWorkplanPlan, initSequence, args, new Date().toISOString(), initOmitted);
                 if (blueprintGate) {
                     console.log(JSON.stringify(blueprintGate, null, 2));
                     process.exitCode = 7;
                     return "exit";
                 }
-                const workplanInitGate = await requireNextWorkplanSurfaceInit(initRepo, initRequest, initSequence, keyValueFlag(args, "answer"));
+                const workplanInitGate = await requireNextWorkplanSurfaceInit(initRepo, initCanonicalRequest, initSequence, keyValueFlag(args, "answer"), initOmitted, initRequest);
                 if (workplanInitGate) {
                     console.log(JSON.stringify(workplanInitGate, null, 2));
                     process.exitCode = 7;
@@ -474,8 +492,8 @@ async function handleCli(args) {
             return "exit";
         }
         if (command === "check") {
-            assertOnlyKnownFlags(args, ["ci", "format", "new-only"], "check");
-            const result = await checkCompliance(positionalRepoPath(args.slice(1)), { newOnly: hasFlag(args, "new-only") });
+            assertOnlyKnownFlags(args, ["ci", "format", "new-only", "allow-proof-waiver"], "check");
+            const result = await checkCompliance(positionalRepoPath(args.slice(1)), { newOnly: hasFlag(args, "new-only"), allowProofWaiver: hasFlag(args, "allow-proof-waiver") });
             emitResult("check", hasFlag(args, "ci") ? ciCheckResult(result) : result, args);
             process.exitCode = result.exitCode;
             return "exit";
@@ -1472,6 +1490,24 @@ async function fileExists(filePath) {
         return false;
     }
 }
+async function digestFile(filePath) {
+    return `sha256:${createHash("sha256").update(await readFile(filePath)).digest("hex")}`;
+}
+function digestJson(value) {
+    return `sha256:${createHash("sha256").update(stableStringify(value)).digest("hex")}`;
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .filter(([, entryValue]) => entryValue !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b));
+        return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "undefined";
+}
 function expandHome(input) {
     if (input === "~") {
         return os.homedir();
@@ -1510,25 +1546,31 @@ function blueprintStagesForSequence(sequence) {
 }
 async function activeBlueprint(repoRoot, request, plan) {
     const planSequence = socialWorkplanSequence(plan);
-    const full = planSequence.length
-        ? planSequence
-        : await socialWorkplanSequenceFromSignedFlow(repoRoot, request);
-    const omitted = await readOmittedSurfaces(repoRoot, request);
+    const flowFallback = await socialWorkplanSequenceFromFlow(repoRoot, request);
+    const canonicalRequest = flowFallback?.request ?? request;
+    const full = planSequence.length ? planSequence : flowFallback?.sequence ?? [];
+    const omitted = await readOmittedSurfaces(repoRoot, canonicalRequest);
     const omittedIds = new Set(omitted.map((item) => item.id));
-    return { sequence: full.filter((surface) => !omittedIds.has(surface.id)), omitted };
+    return { sequence: full.filter((surface) => !omittedIds.has(surface.id)), omitted, canonicalRequest };
 }
-async function socialWorkplanSequenceFromSignedFlow(repoRoot, request) {
+async function socialWorkplanSequenceFromFlow(repoRoot, request) {
     const state = await readFlowState(repoRoot);
-    if (state?.request !== request) {
-        return [];
+    if (!state) {
+        return null;
     }
     const stages = state.blueprint?.stages ?? [];
     if (stages.length <= 1) {
-        return [];
+        return null;
+    }
+    const omitted = state.blueprint?.omitted ?? [];
+    const omittedIds = new Set(omitted.map((item) => item.id));
+    const activeStages = stages.filter((stage) => !omittedIds.has(stage.id || stage.outcome));
+    if (activeStages.length <= 1 || !signedFlowAppliesToRequest(state, request, activeStages, omitted)) {
+        return null;
     }
-    return stages.map((stage, index) => {
+    const sequence = activeStages.map((stage, index) => {
         const id = stage.id || stage.outcome;
-        const commonArgs = `. --request ${shellQuoteForCommand(request)} --answer feature_surface=${id}`;
+        const commonArgs = `. --request ${shellQuoteForCommand(state.request)} --answer feature_surface=${id}`;
         return {
             id,
             order: index + 1,
@@ -1544,6 +1586,23 @@ async function socialWorkplanSequenceFromSignedFlow(repoRoot, request) {
             validation: ["validate_setup", "run_sensors"],
         };
     });
+    return { request: state.request, sequence };
+}
+function signedFlowAppliesToRequest(state, request, activeStages, omitted) {
+    const current = normalizeWorkflowRequest(request);
+    const stored = normalizeWorkflowRequest(state.request);
+    if (!current || !stored) {
+        return false;
+    }
+    if (current === stored || current.includes(stored) || stored.includes(current)) {
+        return true;
+    }
+    const requestedOutcome = resolveOutcome(request, {});
+    const stageOutcomes = [...activeStages, ...omitted].map((stage) => stage.outcome);
+    return relatedOutcomes(stageOutcomes).has(requestedOutcome);
+}
+function normalizeWorkflowRequest(value) {
+    return value.toLowerCase().replace(/[^a-z0-9\s]+/g, " ").replace(/\s+/g, " ").trim();
 }
 async function requireBlueprintConfirmation(repoRoot, request, plan, sequence, args, now, omitted = []) {
     if (sequence.length === 0) {
@@ -1761,33 +1820,67 @@ async function workplanStatus(args) {
     const repoRoot = path.resolve(positionalRepoPath(args));
     const request = requiredFlagValue(args, "request", "workplan next/status requires --request.");
     const plan = await workplanPlan(repoRoot, request, args);
-    const { sequence, omitted } = await activeBlueprint(repoRoot, request, plan);
-    const progress = await readWorkplanProgress(repoRoot);
-    const completed = progress?.request === request ? progress.completed : [];
-    const completedIds = new Set(completed.map((item) => item.surface));
-    const nextSurface = sequence.find((surface) => !completedIds.has(surface.id));
+    const { sequence, omitted, canonicalRequest } = await activeBlueprint(repoRoot, request, plan);
+    let progress = await verifiedWorkplanProgress(repoRoot, canonicalRequest, sequence);
+    let completed = progress.completed;
+    let completedIds = new Set(completed.map((item) => item.surface));
+    let nextSurface = sequence.find((surface) => !completedIds.has(surface.id));
     if (sequence.length === 0) {
+        const existingFlow = await readFlowState(repoRoot);
+        const signedStages = existingFlow?.blueprint?.confirmed_digest ? (existingFlow.blueprint?.stages ?? []) : [];
+        const signedFlowAvailable = signedStages.length >= 2 && existingFlow
+            ? {
+                request: existingFlow.request,
+                nextStep: `A signed multi-surface flow is already in progress for a different request; this request was treated as a separate single-outcome build. To resume that journey, re-run with its original request: vise workplan status . --request ${shellQuoteForCommand(existingFlow.request)}`,
+            }
+            : undefined;
         return {
             status: "not-applicable",
             reason: "The request did not produce a multi-surface social workplan. Use `vise plan` for the single-outcome flow.",
             request,
             progressPath: workplanProgressPath(repoRoot),
+            ...(signedFlowAvailable ? { signedFlowAvailable } : {}),
         };
     }
-    const blueprintGate = await requireBlueprintConfirmation(repoRoot, request, plan, sequence, args, new Date().toISOString(), omitted);
+    const blueprintGate = await requireBlueprintConfirmation(repoRoot, canonicalRequest, plan, sequence, args, new Date().toISOString(), omitted);
     if (blueprintGate) {
         return blueprintGate;
     }
+    let autoCompletedSurface;
+    const scopeOutcome = await readSidecarOutcome(repoRoot);
+    const scopePending = scopeOutcome
+        ? sequence.find((surface) => surface.outcome === scopeOutcome && !completedIds.has(surface.id))
+        : undefined;
+    if (scopePending) {
+        try {
+            const live = await checkCompliance(repoRoot);
+            if (live.outcome === scopePending.outcome && isCompletableCheckStatus(live.status)) {
+                await recordWorkplanSurfaceCompletion(repoRoot, canonicalRequest, sequence, scopePending, live, new Date().toISOString(), "auto-recorded by vise workplan status from a green check for the in-scope surface");
+                autoCompletedSurface = scopePending.id;
+                progress = await verifiedWorkplanProgress(repoRoot, canonicalRequest, sequence);
+                completed = progress.completed;
+                completedIds = new Set(completed.map((item) => item.surface));
+                nextSurface = sequence.find((surface) => !completedIds.has(surface.id));
+            }
+        }
+        catch {
+        }
+    }
     const runtimeReadiness = runtimeReadinessForStages(blueprintStagesForSequence(sequence));
     const nextSurfaceReadiness = nextSurface ? runtimeReadiness.surfaces.find((surface) => surface.id === nextSurface.id) : undefined;
     return {
         status: nextSurface ? "next-surface" : "complete",
-        request,
+        request: canonicalRequest,
+        ...(canonicalRequest !== request ? { requestedAs: request } : {}),
         progressPath: workplanProgressPath(repoRoot),
         creativeContext: plan.socialWorkplan?.creativeContext ?? plan.creativeContext,
         uxHarness: plan.socialWorkplan?.uxHarness ?? plan.uxHarness,
         runtimeReadiness,
         completed,
+        ...(autoCompletedSurface
+            ? { autoCompleted: { surface: autoCompletedSurface, reason: "in-scope surface had a green check; recorded from evidence so you don't need a separate `vise workplan complete` for it" } }
+            : {}),
+        ...(progress.ignored.length ? { ignoredProgress: progress.ignored } : {}),
         sequence: sequence.map((surface) => ({
             id: surface.id,
             order: surface.order,
@@ -1817,7 +1910,7 @@ async function workplanStatus(args) {
                     sync: "vise sync .",
                     validate: "vise validate .",
                     sensors: "vise run-sensors .",
-                    complete: `vise workplan complete . --request ${shellQuoteForCommand(request)} --surface ${nextSurface.id}`,
+                    complete: `vise workplan complete . --request ${shellQuoteForCommand(canonicalRequest)} --surface ${nextSurface.id}`,
                 },
             }
             : undefined,
@@ -1856,8 +1949,8 @@ async function trimWorkplanSurface(args) {
             exitCode: 0,
         };
     }
-    const progress = await readWorkplanProgress(repoRoot);
-    const completedIds = new Set(progress?.request === request ? progress.completed.map((item) => item.surface) : []);
+    const progress = await verifiedWorkplanProgress(repoRoot, request, full);
+    const completedIds = new Set(progress.completed.map((item) => item.surface));
     if (completedIds.has(surfaceId)) {
         throw new Error(`Surface "${surfaceId}" has already been built and recorded; it cannot be trimmed. Trim applies only to not-yet-built companion surfaces.`);
     }
@@ -1897,39 +1990,20 @@ async function trimWorkplanSurface(args) {
         exitCode: 7,
     };
 }
-async function completeWorkplanSurface(args) {
-    const repoRoot = path.resolve(positionalRepoPath(args));
-    const request = requiredFlagValue(args, "request", "workplan complete requires --request.");
-    const surfaceId = requiredFlagValue(args, "surface", "workplan complete requires --surface <surface-id>.");
-    const note = flagValue(args, "note");
-    const plan = await workplanPlan(repoRoot, request, args);
-    const { sequence, omitted } = await activeBlueprint(repoRoot, request, plan);
-    const surface = sequence.find((item) => item.id === surfaceId);
-    if (!surface) {
-        if (omitted.some((item) => item.id === surfaceId)) {
-            throw new Error(`Surface "${surfaceId}" was deliberately trimmed from this blueprint and is not built (recorded omission). Un-trim is not yet supported; to build it, re-select an experience that includes it via \`vise creative\`.`);
-        }
-        throw new Error(`Surface "${surfaceId}" is not in this social workplan. Available surfaces: ${sequence.map((item) => item.id).join(", ") || "(none)"}.`);
-    }
-    const now = new Date().toISOString();
-    const blueprintGate = await requireBlueprintConfirmation(repoRoot, request, plan, sequence, args, now, omitted);
-    if (blueprintGate) {
-        return blueprintGate;
-    }
-    const check = await greenWorkplanCheck(repoRoot, surfaceId, surface.outcome);
-    const snapshot = await writeWorkplanSurfaceSnapshot(repoRoot, surfaceId, check, now);
-    const existing = await readWorkplanProgress(repoRoot);
-    const base = existing?.request === request
-        ? existing
+async function recordWorkplanSurfaceCompletion(repoRoot, canonicalRequest, sequence, surface, check, now, note) {
+    const snapshot = await writeWorkplanSurfaceSnapshot(repoRoot, surface.id, check, now);
+    const existing = await verifiedWorkplanProgress(repoRoot, canonicalRequest, sequence);
+    const base = existing.raw?.request === canonicalRequest
+        ? { ...existing.raw, completed: existing.completed }
         : {
             schema_version: 2,
             vise_version: packageVersion,
-            request,
+            request: canonicalRequest,
             generated_at: now,
             updated_at: now,
             completed: [],
         };
-    const withoutSurface = base.completed.filter((item) => item.surface !== surfaceId);
+    const withoutSurface = base.completed.filter((item) => item.surface !== surface.id);
     const progress = {
         ...base,
         schema_version: 2,
@@ -1938,7 +2012,7 @@ async function completeWorkplanSurface(args) {
         completed: [
             ...withoutSurface,
             {
-                surface: surfaceId,
+                surface: surface.id,
                 outcome: surface.outcome,
                 completed_at: now,
                 ...(note ? { note } : {}),
@@ -1957,7 +2031,31 @@ async function completeWorkplanSurface(args) {
         ].sort((a, b) => sequenceIndex(sequence, a.surface) - sequenceIndex(sequence, b.surface)),
     };
     await writeWorkplanProgress(repoRoot, progress);
-    const status = await workplanStatus(args);
+    return progress;
+}
+async function completeWorkplanSurface(args) {
+    const repoRoot = path.resolve(positionalRepoPath(args));
+    const request = requiredFlagValue(args, "request", "workplan complete requires --request.");
+    const surfaceId = requiredFlagValue(args, "surface", "workplan complete requires --surface <surface-id>.");
+    const note = flagValue(args, "note");
+    const plan = await workplanPlan(repoRoot, request, args);
+    const { sequence, omitted, canonicalRequest } = await activeBlueprint(repoRoot, request, plan);
+    const surface = sequence.find((item) => item.id === surfaceId);
+    if (!surface) {
+        if (omitted.some((item) => item.id === surfaceId)) {
+            throw new Error(`Surface "${surfaceId}" was deliberately trimmed from this blueprint and is not built (recorded omission). Un-trim is not yet supported; to build it, re-select an experience that includes it via \`vise creative\`.`);
+        }
+        throw new Error(`Surface "${surfaceId}" is not in this social workplan. Available surfaces: ${sequence.map((item) => item.id).join(", ") || "(none)"}.`);
+    }
+    const now = new Date().toISOString();
+    const blueprintGate = await requireBlueprintConfirmation(repoRoot, canonicalRequest, plan, sequence, args, now, omitted);
+    if (blueprintGate) {
+        return blueprintGate;
+    }
+    const check = await greenWorkplanCheck(repoRoot, surfaceId, surface.outcome);
+    const progress = await recordWorkplanSurfaceCompletion(repoRoot, canonicalRequest, sequence, surface, check, now, note);
+    const statusArgs = canonicalRequest === request ? args : replaceFlagValue(args, "request", canonicalRequest);
+    const status = await workplanStatus(statusArgs);
     const sequenceStatus = workplanSequenceStatus(status);
     const completedSurfaces = sequenceStatus.filter((item) => item.completed);
     const pendingSurfaces = sequenceStatus.filter((item) => !item.completed);
@@ -2008,11 +2106,14 @@ async function greenWorkplanCheck(repoRoot, surfaceId, expectedOutcome) {
     if (expectedOutcome && check.outcome !== expectedOutcome) {
         throw new Error(`Cannot mark "${surfaceId}" complete: the sp-vise sidecar is currently scoped to outcome "${check.outcome}", not this surface's outcome "${expectedOutcome}". Each workplan surface has its own sidecar scope — run this surface's focused \`vise init\` command (it sets \`--answer feature_surface=${surfaceId}\`) and \`vise check .\` before recording it. (The check reported "${check.status}" only because it ran against the other surface's contract.)`);
     }
-    if (check.status !== "green") {
+    if (!isCompletableCheckStatus(check.status)) {
         throw new Error(`Cannot mark "${surfaceId}" complete because \`vise check\` returned "${check.status}" (exit ${check.exitCode}). Resolve the check result before recording workplan progress.`);
     }
     return check;
 }
+function isCompletableCheckStatus(status) {
+    return status === "green" || status === "runtime-proof-waived";
+}
 async function writeWorkplanSurfaceSnapshot(repoRoot, surfaceId, check, snapshotAt) {
     const snapshotDir = workplanSurfaceSnapshotDir(repoRoot, surfaceId);
     await mkdir(snapshotDir, { recursive: true });
@@ -2034,9 +2135,37 @@ async function writeWorkplanSurfaceSnapshot(repoRoot, surfaceId, check, snapshot
         check,
     }, null, 2)}\n`, "utf8");
     files.push(repoRelativePath(repoRoot, checkPath));
+    const fileDigests = [];
+    for (const relPath of files.sort()) {
+        fileDigests.push({ path: relPath, sha256: await digestFile(path.join(repoRoot, relPath)) });
+    }
+    const manifestPayload = {
+        schema_version: 1,
+        generated_by: "vise workplan complete",
+        generated_at: snapshotAt,
+        surface: surfaceId,
+        outcome: check.outcome,
+        check_digest: digestJson(check),
+        files: fileDigests,
+    };
+    const manifestDigest = digestJson(manifestPayload);
+    const manifestPath = path.join(snapshotDir, "snapshot-manifest.json");
+    const manifestRelPath = repoRelativePath(repoRoot, manifestPath);
+    await writeFile(manifestPath, `${JSON.stringify({
+        ...manifestPayload,
+        manifest_digest: manifestDigest,
+    }, null, 2)}\n`, "utf8");
+    files.push(manifestRelPath);
     return {
         directory: repoRelativePath(repoRoot, snapshotDir),
         files: files.sort(),
+        integrity: {
+            schema_version: 1,
+            manifest_path: manifestRelPath,
+            manifest_digest: manifestDigest,
+            check_digest: manifestPayload.check_digest,
+            files: fileDigests,
+        },
     };
 }
 async function workplanPlan(repoRoot, request, args) {
@@ -2057,16 +2186,18 @@ function socialWorkplanSequence(plan) {
     }
     return workplan.sequence;
 }
-async function requireNextWorkplanSurfaceInit(repoRoot, request, sequence, answers) {
-    const progress = await readWorkplanProgress(repoRoot);
-    const completedIds = new Set(progress?.request === request ? progress.completed.map((item) => item.surface) : []);
+async function requireNextWorkplanSurfaceInit(repoRoot, request, sequence, answers, omitted = [], requestedAs) {
+    const progress = await verifiedWorkplanProgress(repoRoot, request, sequence);
+    const completedIds = new Set(progress.completed.map((item) => item.surface));
     const nextSurface = sequence.find((surface) => !completedIds.has(surface.id));
     const selectedSurface = resolveWorkplanSurfaceAnswer(sequence, answers.feature_surface);
+    const selectedOmittedSurface = resolveOmittedSurfaceAnswer(omitted, answers.feature_surface);
     if (!nextSurface) {
         return {
             status: "workplan-complete",
             exitCode: 7,
             request,
+            ...(requestedAs && requestedAs !== request ? { requestedAs } : {}),
             sequence: sequence.map((surface) => ({
                 id: surface.id,
                 order: surface.order,
@@ -2077,11 +2208,48 @@ async function requireNextWorkplanSurfaceInit(repoRoot, request, sequence, answe
             nextStep: "All active blueprint surfaces are already recorded complete. Run one final `vise check .`, `vise validate .`, and `vise run-sensors .` instead of initializing another surface.",
         };
     }
+    if (selectedOmittedSurface) {
+        return {
+            status: "needs-workplan-order",
+            exitCode: 7,
+            request,
+            ...(requestedAs && requestedAs !== request ? { requestedAs } : {}),
+            attemptedSurface: {
+                id: selectedOmittedSurface.id,
+                outcome: selectedOmittedSurface.outcome,
+                label: selectedOmittedSurface.label,
+                trimmed: true,
+                reason: selectedOmittedSurface.reason,
+            },
+            expectedSurface: nextSurface
+                ? {
+                    id: nextSurface.id,
+                    order: nextSurface.order,
+                    outcome: nextSurface.outcome,
+                    label: nextSurface.label,
+                }
+                : undefined,
+            omitted: omitted.map((item) => ({ id: item.id, outcome: item.outcome, reason: item.reason })),
+            sequence: sequence.map((surface) => ({
+                id: surface.id,
+                order: surface.order,
+                outcome: surface.outcome,
+                label: surface.label,
+                completed: completedIds.has(surface.id),
+            })),
+            nextStep: `Surface "${selectedOmittedSurface.id}" was deliberately trimmed from the signed blueprint (${selectedOmittedSurface.reason}). ` +
+                (nextSurface
+                    ? `Continue the active blueprint with "${nextSurface.id}" using: ${nextSurface.initCommand}. `
+                    : "All active blueprint surfaces are already recorded complete. ") +
+                "To build the trimmed surface, re-select an experience that includes it via `vise creative` and collect a fresh blueprint sign-off.",
+        };
+    }
     if (!answers.feature_surface || !selectedSurface) {
         return {
             status: "needs-workplan-surface",
             exitCode: 7,
             request,
+            ...(requestedAs && requestedAs !== request ? { requestedAs } : {}),
             expectedSurface: {
                 id: nextSurface.id,
                 order: nextSurface.order,
@@ -2104,6 +2272,7 @@ async function requireNextWorkplanSurfaceInit(repoRoot, request, sequence, answe
             status: "needs-workplan-order",
             exitCode: 7,
             request,
+            ...(requestedAs && requestedAs !== request ? { requestedAs } : {}),
             attemptedSurface: {
                 id: selectedSurface.id,
                 order: selectedSurface.order,
@@ -2137,6 +2306,150 @@ function resolveWorkplanSurfaceAnswer(sequence, answer) {
         ?? sequence.find((surface) => surface.label.toLowerCase() === normalized)
         ?? sequence.find((surface) => surface.label.toLowerCase().includes(normalized));
 }
+function resolveOmittedSurfaceAnswer(omitted, answer) {
+    const normalized = (answer ?? "").trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    return omitted.find((surface) => surface.id.toLowerCase() === normalized)
+        ?? omitted.find((surface) => surface.label?.toLowerCase() === normalized)
+        ?? omitted.find((surface) => surface.label?.toLowerCase().includes(normalized));
+}
+async function verifiedWorkplanProgress(repoRoot, request, sequence) {
+    const raw = await readWorkplanProgress(repoRoot);
+    if (!raw || raw.request !== request) {
+        return { raw, completed: [], ignored: [] };
+    }
+    const surfacesById = new Map(sequence.map((surface) => [surface.id, surface]));
+    const completed = [];
+    const ignored = [];
+    let liveOutcome;
+    let liveCompletable = false;
+    const currentScopeOutcome = await readSidecarOutcome(repoRoot);
+    const hasCompletedForCurrentScope = !!currentScopeOutcome && (raw.completed ?? []).some((item) => surfacesById.get(item.surface)?.outcome === currentScopeOutcome);
+    if (hasCompletedForCurrentScope) {
+        try {
+            const live = await checkCompliance(repoRoot);
+            liveOutcome = live.outcome;
+            liveCompletable = isCompletableCheckStatus(live.status);
+        }
+        catch {
+            liveOutcome = undefined;
+        }
+    }
+    for (const item of raw.completed ?? []) {
+        const surface = surfacesById.get(item.surface);
+        if (!surface) {
+            ignored.push({ surface: item.surface, reason: "surface is not in the active signed blueprint" });
+            continue;
+        }
+        const check = item.evidence?.check;
+        if (!check || !isCompletableCheckStatus(check.status) || check.outcome !== surface.outcome) {
+            ignored.push({ surface: item.surface, reason: "progress entry is missing a green (or proof-waived) check summary for this surface/outcome" });
+            continue;
+        }
+        const snapshotDir = item.evidence?.snapshot?.directory;
+        if (typeof snapshotDir !== "string" || snapshotDir.length === 0) {
+            ignored.push({ surface: item.surface, reason: "progress entry is missing a workplan snapshot directory" });
+            continue;
+        }
+        const snapshotPath = path.resolve(repoRoot, snapshotDir, "check.json");
+        if (!pathInside(repoRoot, snapshotPath)) {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot path points outside the repository" });
+            continue;
+        }
+        const integrity = item.evidence?.snapshot?.integrity;
+        if (!integrity || integrity.schema_version !== 1 || typeof integrity.manifest_path !== "string" || typeof integrity.manifest_digest !== "string") {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot is missing an integrity manifest; rerun workplan complete after a green check" });
+            continue;
+        }
+        const manifestPath = path.resolve(repoRoot, integrity.manifest_path);
+        if (!pathInside(repoRoot, manifestPath) || !pathInside(path.resolve(repoRoot, snapshotDir), manifestPath)) {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot integrity manifest path is outside the snapshot directory" });
+            continue;
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+        }
+        catch {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot integrity manifest is missing or unreadable" });
+            continue;
+        }
+        const { manifest_digest: manifestDigest, ...manifestPayload } = manifest;
+        if (manifest.schema_version !== 1 ||
+            manifest.generated_by !== "vise workplan complete" ||
+            manifest.surface !== item.surface ||
+            manifest.outcome !== surface.outcome ||
+            manifest.check_digest !== integrity.check_digest ||
+            manifestDigest !== integrity.manifest_digest ||
+            digestJson(manifestPayload) !== integrity.manifest_digest) {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot integrity manifest does not match this surface/outcome" });
+            continue;
+        }
+        const manifestFiles = Array.isArray(manifest.files) ? manifest.files : [];
+        const manifestFileDigests = manifestFiles
+            .map((entry) => entry && typeof entry === "object" && typeof entry.path === "string" && typeof entry.sha256 === "string"
+            ? { path: entry.path, sha256: entry.sha256 }
+            : null)
+            .filter((entry) => entry != null);
+        if (manifestFileDigests.length !== manifestFiles.length || manifestFileDigests.length === 0) {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot integrity manifest has no valid file digests" });
+            continue;
+        }
+        const expectedFileDigest = digestJson(manifestFileDigests);
+        const recordedFileDigest = digestJson(integrity.files ?? []);
+        if (expectedFileDigest !== recordedFileDigest) {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot integrity files differ from the recorded progress manifest" });
+            continue;
+        }
+        let fileDigestMismatch = null;
+        for (const fileDigest of manifestFileDigests) {
+            const filePath = path.resolve(repoRoot, fileDigest.path);
+            if (!pathInside(repoRoot, filePath) || !pathInside(path.resolve(repoRoot, snapshotDir), filePath)) {
+                fileDigestMismatch = `${fileDigest.path} is outside the snapshot directory`;
+                break;
+            }
+            try {
+                const actual = await digestFile(filePath);
+                if (actual !== fileDigest.sha256) {
+                    fileDigestMismatch = `${fileDigest.path} changed`;
+                    break;
+                }
+            }
+            catch {
+                fileDigestMismatch = `${fileDigest.path} is missing`;
+                break;
+            }
+        }
+        if (fileDigestMismatch) {
+            ignored.push({ surface: item.surface, reason: `workplan snapshot integrity mismatch: ${fileDigestMismatch}` });
+            continue;
+        }
+        let snapshot;
+        try {
+            snapshot = JSON.parse(await readFile(snapshotPath, "utf8"));
+        }
+        catch {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot check.json is missing or unreadable" });
+            continue;
+        }
+        if (!snapshot.check || digestJson(snapshot.check) !== integrity.check_digest) {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot check digest does not match the recorded integrity manifest" });
+            continue;
+        }
+        const snapshotExitOk = snapshot.check?.status === "runtime-proof-waived" || snapshot.check?.exitCode === 0;
+        if (snapshot.surface !== item.surface || !isCompletableCheckStatus(snapshot.check?.status) || snapshot.check?.outcome !== surface.outcome || !snapshotExitOk) {
+            ignored.push({ surface: item.surface, reason: "workplan snapshot check.json is not a green (or proof-waived) check for this surface/outcome" });
+            continue;
+        }
+        if (liveOutcome && item.outcome === liveOutcome && !liveCompletable) {
+            ignored.push({ surface: item.surface, reason: "live `vise check` for this surface's current scope is no longer green/proof-waived — the recorded completion is stale or was not produced by a real check" });
+            continue;
+        }
+        completed.push(item);
+    }
+    return { raw, completed, ignored };
+}
 async function readWorkplanProgress(repoRoot) {
     try {
         return JSON.parse(await readFile(workplanProgressPath(repoRoot), "utf8"));
@@ -2145,6 +2458,15 @@ async function readWorkplanProgress(repoRoot) {
         return null;
     }
 }
+async function readSidecarOutcome(repoRoot) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(sidecarPath(repoRoot), "compliance.json"), "utf8"));
+        return typeof parsed.outcome === "string" ? parsed.outcome : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 async function writeWorkplanProgress(repoRoot, progress) {
     const filePath = workplanProgressPath(repoRoot);
     await mkdir(path.dirname(filePath), { recursive: true });
@@ -2160,13 +2482,49 @@ function workplanSurfaceSnapshotDir(repoRoot, surfaceId) {
     }
     return path.join(sidecarPath(repoRoot), "workplan-snapshots", safeSurfaceId);
 }
+function workplanExitCode(payload) {
+    if (typeof payload.exitCode === "number") {
+        return payload.exitCode;
+    }
+    const status = typeof payload.status === "string" ? payload.status : "";
+    return status === "needs-blueprint-confirmation" || status === "needs-workplan-surface" || status === "needs-workplan-order" || status === "blocked"
+        ? 7
+        : 0;
+}
 function repoRelativePath(repoRoot, filePath) {
     return path.relative(repoRoot, filePath).split(path.sep).join("/");
 }
+function pathInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
 function sequenceIndex(sequence, surfaceId) {
     const index = sequence.findIndex((surface) => surface.id === surfaceId);
     return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
 }
+function replaceFlagValue(args, flag, value) {
+    const out = [];
+    let replaced = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === `--${flag}`) {
+            out.push(arg, value);
+            i += 1;
+            replaced = true;
+            continue;
+        }
+        if (arg.startsWith(`--${flag}=`)) {
+            out.push(`--${flag}=${value}`);
+            replaced = true;
+            continue;
+        }
+        out.push(arg);
+    }
+    if (!replaced) {
+        out.push(`--${flag}`, value);
+    }
+    return out;
+}
 function shellQuoteForCommand(value) {
     return `'${value.replace(/'/g, "'\\''")}'`;
 }
@@ -2179,6 +2537,7 @@ function ciCheckResult(result) {
             exitCode: result.exitCode,
             blockingResultStatuses: [
                 "contract-drift",
+                "no-platform",
                 "blocked",
                 "deterministic-failures",
                 "needs-attestation",