@amityco/social-plus-vise 1.6.0 → 1.8.0

package/dist/tools/compliance.js

@@ -16,7 +16,7 @@ import { packageVersion } from "../version.js";
 import { readFlowState } from "../flow.js";
 import { DESIGN_CONTRACT_CONFIRMATION_ANSWER_ID, buildDesignBrief, designContractConfirmationFromAnswers, designPreviewPath, readDesignContract, } from "./design.js";
 import { installedBlockProvidedCapabilities } from "./blocks.js";
-import { inspectProject, validateSetup } from "./project.js";
+import { inspectProject, validateSetupWithCoverage, } from "./project.js";
 import { readCreativeSelection } from "./creative.js";
 import { readRuntimeProofWaiver, hasExecutableSmokeMarker } from "./smoke.js";
 import { assessUxHarness, buildExperienceReport, buildUxHarness, readUxHarness, } from "./uxHarness.js";
@@ -326,6 +326,18 @@ function designReviewFor(repoRoot, contract, answers) {
 export async function initCompliance(repoPath, request, surfacePath, answers = {}, options = {}) {
     const repoRoot = path.resolve(repoPath);
     const inspection = await inspectProject(repoRoot, surfacePath);
+    if (!inspection.scanCoverage.complete) {
+        const truncated = inspection.scanCoverage.scans.filter((scan) => scan.truncated);
+        return {
+            status: "needs-clarification",
+            exitCode: 7,
+            reason: `Vise could not inspect the complete project inventory: ${truncated
+                .map((scan) => `${scan.scope} reached its ${scan.limit}-file limit under ${scan.root}`)
+                .join("; ")}.`,
+            instruction: "Select the specific app/workspace surface before initializing a compliance contract; an incomplete platform inventory cannot be baked into a greenable sidecar.",
+            nextStep: "Re-run `vise init` with --surface <app-path> (or --surface-path <app-path>) after narrowing the project.",
+        };
+    }
     const outcome = resolveOutcome(request, answers);
     const platform = preferredPlatform(inspection.platforms);
     const capabilityAvailability = await platformCapabilityAvailability(outcome, platform);
@@ -416,6 +428,22 @@ export async function initCompliance(repoPath, request, surfacePath, answers = {
                 "The gate still blocks until every id above is answered; pass --allow-unresolved-intake only for retrospective/harness initialization.",
         };
     }
+    const previousCompliance = await readJsonIfExists(compliancePath(repoRoot));
+    let engagementSwitch;
+    if (previousCompliance && previousCompliance.outcome !== outcome) {
+        const finalCheck = await checkCompliance(repoPath).catch(() => undefined);
+        if (finalCheck?.status === "green" && !options.supersedeEngagement) {
+            return {
+                status: "needs-engagement-supersede-confirmation",
+                exitCode: 7,
+                from: previousCompliance.outcome,
+                to: outcome,
+                reason: `The current engagement (outcome "${previousCompliance.outcome}") is green — finished, verified work. Initializing "${outcome}" replaces its contract, and its completeness will no longer be checked (it moves to the engagement ledger; see \`vise status\` previousEngagements and \`vise check --all-engagements\`).`,
+                instruction: `Re-run with --supersede-engagement to proceed. The green final state will be recorded in sp-vise/engagements/${previousCompliance.outcome}/ first.`,
+            };
+        }
+        engagementSwitch = await recordEngagementOnSwitch(repoRoot, previousCompliance, outcome, finalCheck);
+    }
     const compliance = {
         schema_version: schemaVersion,
         vise_version: packageVersion,
@@ -468,6 +496,17 @@ export async function initCompliance(repoPath, request, surfacePath, answers = {
     if (engagement && engagement.scope.outcomes.length > 0 && !engagement.scope.outcomes.includes(outcome)) {
         warnings.push(`Outcome "${outcome}" is not in the engagement scope (${engagement.scope.outcomes.join(", ")}). Compliance was still initialized; extend the scope in engagement.json or re-run vise engagement init.`);
     }
+    const preExistingFindingFiles = [
+        ...new Set(checkSnapshot.rules
+            .filter((rule) => BASELINE_NON_GREEN.has(rule.status) && rule.finding?.file)
+            .map((rule) => rule.finding?.file)),
+    ];
+    const brownfieldHint = !options.baselinePlanned && preExistingFindingFiles.length > 0 && !(await readBaseline(repoRoot))
+        ? {
+            pre_existing_finding_files: preExistingFindingFiles.slice(0, 5),
+            hint: "This repo already contains social.plus integration with non-green findings that predate this engagement. Record `vise baseline .` NOW (before writing any code) so `vise check --new-only` gates only findings you introduce. The outcome's completeness checklist is never baselined — the requested feature still has to be built. Never record a baseline mid-build: it would swallow your own findings.",
+        }
+        : undefined;
     return {
         status: "initialized",
         sidecar: complianceDirName,
@@ -480,6 +519,8 @@ export async function initCompliance(repoPath, request, surfacePath, answers = {
         ...(compliance.design_contract && { design_contract: compliance.design_contract }),
         ...(selectedOptionalCapabilities.length > 0 && { selected_optional_capabilities: selectedOptionalCapabilities }),
         ...(runtimeSmokeTemplate ? { runtime_smoke: runtimeSmokeTemplate } : {}),
+        ...(brownfieldHint ? { brownfield: brownfieldHint } : {}),
+        ...(engagementSwitch ? { engagement_switch: engagementSwitch } : {}),
         intake: {
             status: intake.status,
             remainingBlocking: intake.remainingBlocking,
@@ -862,7 +903,7 @@ async function ruleFreshness(rule) {
 }
 export async function checkCompliance(repoPath, options = {}) {
     const repoRoot = path.resolve(repoPath);
-    const compliance = await readCompliance(repoRoot);
+    const compliance = options.contract ?? (await readCompliance(repoRoot));
     const rules = await rulesById();
     const drift = contractDrift(compliance, rules);
     if (drift.length > 0) {
@@ -902,8 +943,23 @@ export async function checkCompliance(repoPath, options = {}) {
         }
     }
     const { canonicalPlatform } = await import("./sdkFacts.js");
-    const allFindings = await Promise.all(platforms.map((p) => validateSetup(inspection.effectiveRoot, p)));
-    const findings = allFindings.flat();
+    const validations = await Promise.all(platforms.map((p) => validateSetupWithCoverage(inspection.effectiveRoot, p)));
+    const findings = validations.flatMap((validation) => validation.findings);
+    const scanCoverage = {
+        complete: inspection.scanCoverage.complete && validations.every((validation) => validation.scanCoverage.complete),
+        scans: [...inspection.scanCoverage.scans, ...validations.flatMap((validation) => validation.scanCoverage.scans)],
+    };
+    if (!inspection.scanCoverage.complete && !findings.some((finding) => finding.ruleId === "project.scan.complete")) {
+        const truncated = inspection.scanCoverage.scans.filter((scan) => scan.truncated);
+        findings.push({
+            ruleId: "project.scan.complete",
+            severity: "error",
+            message: `Vise could not inspect the complete project inventory: ${truncated
+                .map((scan) => `${scan.scope} reached its ${scan.limit}-file limit under ${scan.root}`)
+                .join("; ")}.`,
+            recommendation: "Point Vise at the specific app with --surface/--surface-path and re-run init/check.",
+        });
+    }
     const findingsById = new Map();
     const findingsByIdAll = new Map();
     for (const finding of findings) {
@@ -915,7 +971,7 @@ export async function checkCompliance(repoPath, options = {}) {
         }
     }
     const attestations = await readAttestations(repoRoot);
-    const attestationHygiene = await readAttestationHygiene(repoRoot, compliance);
+    const attestationHygiene = await readAttestationHygiene(repoRoot, inspection.effectiveRoot, compliance);
     const results = [];
     for (const ref of compliance.rules) {
         const rule = rules.get(ref.rule_id);
@@ -996,6 +1052,27 @@ export async function checkCompliance(repoPath, options = {}) {
             const exactMatch = attestation.rule_digest === ref.rule_digest;
             const grandfathered = !exactMatch && isAttestationGrandfathered(rule, attestation);
             if (exactMatch || grandfathered) {
+                if (attestation.outcome !== undefined &&
+                    attestation.outcome !== compliance.outcome &&
+                    !(attestation.file_scoped === true && isFileScopableRule(rule))) {
+                    const crossEngagementStatus = rule.advisory ? "advisory" : rule.enforcement.attestation.allowed ? "attestation-needed" : "deterministic-fail";
+                    results.push({
+                        ...checkRuleIdentity(rule.id),
+                        title: rule.title,
+                        severity: rule.severity,
+                        status: crossEngagementStatus,
+                        reason: rule.advisory
+                            ? "Advisory: informational only — does not affect compliance status."
+                            : `Attestation was recorded during a different engagement (outcome "${attestation.outcome}", attested ${attestation.attested_at}); the current engagement is "${compliance.outcome}". Re-verify the claim still holds for the code this engagement adds, then re-attest.`,
+                        finding,
+                        recommendation: finding?.recommendation,
+                        rationale: rule.rationale,
+                        current_rule: ruleSummary(rule),
+                        stale_engagement_attestation: { outcome: attestation.outcome, attested_at: attestation.attested_at },
+                        ...(crossEngagementStatus === "attestation-needed" && rule.enforcement.attestation.allowed && attestHint(rule, compliance)),
+                    });
+                    continue;
+                }
                 const sourceFingerprintStatus = await checkSourceFingerprints(repoRoot, inspection.effectiveRoot, attestation.source_fingerprints ?? []);
                 const staleFingerprints = sourceFingerprintStatus.filter((item) => item.status !== "match");
                 if (staleFingerprints.length > 0) {
@@ -1088,6 +1165,18 @@ export async function checkCompliance(repoPath, options = {}) {
             ...(baseStatus === "attestation-needed" && rule.enforcement.attestation.allowed && attestHint(rule, compliance)),
         });
     }
+    const incompleteScanFinding = findings.find((finding) => finding.ruleId === "project.scan.complete");
+    if (incompleteScanFinding) {
+        results.push({
+            ruleId: incompleteScanFinding.ruleId,
+            title: "Complete source scan",
+            severity: "error",
+            status: "deterministic-fail",
+            reason: incompleteScanFinding.message,
+            finding: incompleteScanFinding,
+            recommendation: incompleteScanFinding.recommendation,
+        });
+    }
     const driftStale = await surfaceDriftStale(compliance);
     if (driftStale.size > 0) {
         for (const result of results) {
@@ -1153,22 +1242,23 @@ export async function checkCompliance(repoPath, options = {}) {
                     result.baselined = true;
                 }
             }
-            const baselinedMissing = new Set(baselineFile.completeness_missing);
-            const baselinedSelected = new Set(baselineFile.selected_optional);
+            const legacyDeliverableEntries = (baselineFile.completeness_missing?.length ?? 0) + (baselineFile.selected_optional?.length ?? 0);
             gatedResults = results.filter((result) => !result.baselined);
-            gatedMissing = (completeness?.missing ?? []).filter((item) => !baselinedMissing.has(item.id));
-            gatedSelectedFailed = (selectedOptionalCapabilities?.failed ?? []).filter((item) => !baselinedSelected.has(item.id));
-            gatedSelectedUnknown = (selectedOptionalCapabilities?.unknown ?? []).filter((id) => !baselinedSelected.has(id));
             baselineReport = {
                 present: true,
                 applied: true,
                 baselined_at: baselineFile.baselined_at,
                 excluded: {
                     rules: results.filter((result) => result.baselined).length,
-                    completeness: (completeness?.missing.length ?? 0) - gatedMissing.length,
-                    selected_optional: ((selectedOptionalCapabilities?.failed.length ?? 0) - gatedSelectedFailed.length) +
-                        ((selectedOptionalCapabilities?.unknown.length ?? 0) - gatedSelectedUnknown.length),
+                    completeness: 0,
+                    selected_optional: 0,
                 },
+                ...(legacyDeliverableEntries > 0
+                    ? {
+                        ignored_legacy_deliverable_entries: legacyDeliverableEntries,
+                        ignored_legacy_note: "This baseline predates the deliverables fix and recorded completeness/selected-capability entries; they are ignored — the engagement's deliverables always gate. Re-run `vise baseline` to refresh the file.",
+                    }
+                    : {}),
                 residual_caveat: "Baseline excludes pre-existing findings keyed by rule+file (count-based). A NEW violation of an already-baselined rule in the SAME file can be masked at this granularity — review the touched files directly for a precise per-change gate.",
             };
         }
@@ -1181,7 +1271,7 @@ export async function checkCompliance(repoPath, options = {}) {
     const { status, exitCode } = deriveGate({
         hasNoPlatform: detectedPlatforms.length === 0,
         hasBlocked: gatedResults.some((result) => result.status === "blocked"),
-        hasDeterministicFailure: gatedResults.some((result) => result.status === "deterministic-fail"),
+        hasDeterministicFailure: !scanCoverage.complete || gatedResults.some((result) => result.status === "deterministic-fail"),
         needsAttestation: gatedResults.some((result) => result.status === "attestation-needed" || result.status === "stale"),
         hasCompletenessGap,
         hasSelectedOptionalFailures,
@@ -1213,6 +1303,7 @@ export async function checkCompliance(repoPath, options = {}) {
         surfacePath: compliance.surface?.path,
         summary,
         rules: results,
+        scanCoverage,
         ...(evidenceBasis ? { evidence_basis: evidenceBasis } : {}),
         ...(evidenceBasisNote ? { evidence_basis_note: evidenceBasisNote } : {}),
         ...(completeness && (completeness.missing.length > 0 || completeness.optedOut.length > 0 || completeness.present.length > 0) ? { completeness } : {}),
@@ -1668,6 +1759,29 @@ export async function statusCompliance(repoPath, options = {}) {
                 reviewer_assignment: engagement.reviewer_assignment,
             },
         }),
+        ...(await previousEngagementsSection(repoRoot, check.outcome)),
+    };
+}
+async function previousEngagementsSection(repoRoot, activeOutcome) {
+    const dir = engagementsDir(repoRoot);
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const previous = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === activeOutcome) {
+            continue;
+        }
+        const record = await readJsonIfExists(path.join(dir, entry.name, "record.json"));
+        if (record) {
+            previous.push(record);
+        }
+    }
+    if (previous.length === 0) {
+        return {};
+    }
+    previous.sort((a, b) => String(a.outcome).localeCompare(String(b.outcome)));
+    return {
+        previousEngagements: previous,
+        previousEngagements_note: "Superseded engagements' last recorded state (latest per outcome; snapshots, not live verdicts). Their completeness is NOT checked by the active contract — to re-verify one today, re-run `vise init` with its original request and `vise check`. On-demand re-verification lands with `vise check --all-engagements` (docs/ENGAGEMENTS_DESIGN.md, B2).",
     };
 }
 async function applicableRules(outcome, platforms) {
@@ -2253,7 +2367,8 @@ async function liveSensorContradiction(repoRoot, compliance, rule) {
     if (platforms.length === 0) {
         return { violatorFiles: [] };
     }
-    const allFindings = await Promise.all(platforms.map((platform) => validateSetup(inspection.effectiveRoot, platform)));
+    const validations = await Promise.all(platforms.map((platform) => validateSetupWithCoverage(inspection.effectiveRoot, platform)));
+    const allFindings = validations.map((validation) => validation.findings);
     const findingsById = new Map();
     const findingsByIdAll = new Map();
     for (const finding of allFindings.flat()) {
@@ -2266,6 +2381,19 @@ async function liveSensorContradiction(repoRoot, compliance, rule) {
     }
     const finding = deterministicFinding(rule, findingsById);
     if (!finding) {
+        const incomplete = allFindings.flat().find((item) => item.ruleId === "project.scan.complete");
+        if (incomplete) {
+            return {
+                warning: {
+                    message: "The live deterministic sensor could not inspect the complete source surface. This attestation overrides an incomplete analysis; narrow the surface and re-check before relying on it.",
+                    sensor_finding: {
+                        ruleId: incomplete.ruleId,
+                        recommendation: incomplete.recommendation,
+                    },
+                },
+                violatorFiles: [],
+            };
+        }
         return { violatorFiles: [] };
     }
     const violatorFiles = await ruleViolatorFiles(repoRoot, sourceRootForCompliance(repoRoot, compliance), rule, findingsByIdAll);
@@ -2435,6 +2563,7 @@ function buildAttestation(compliance, rule, signer, confidence, identity, ration
         evidence,
         source_fingerprints: sourceFingerprints,
         ...(fileScoped ? { file_scoped: true } : {}),
+        outcome: compliance.outcome,
         rationale_for_attestation: rationale,
         attested_at: new Date().toISOString(),
     };
@@ -2685,9 +2814,24 @@ async function readAttestations(repoRoot) {
     }
     return result;
 }
-async function readAttestationHygiene(repoRoot, compliance) {
+async function recordedEngagementRuleIds(repoRoot) {
+    const ruleIds = new Set();
+    const entries = await readdir(engagementsDir(repoRoot), { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const contract = await readJsonIfExists(path.join(engagementsDir(repoRoot), entry.name, "contract.json"));
+        for (const rule of contract?.rules ?? []) {
+            ruleIds.add(rule.rule_id);
+        }
+    }
+    return ruleIds;
+}
+async function readAttestationHygiene(repoRoot, sourceRoot, compliance) {
     const dir = attestationsDir(repoRoot);
     const activeRuleIds = new Set(compliance.rules.map((rule) => rule.rule_id));
+    const recordedRuleIds = await recordedEngagementRuleIds(repoRoot);
     const ignored = [];
     const invalid = [];
     let entries = [];
@@ -2708,10 +2852,24 @@ async function readAttestationHygiene(repoRoot, compliance) {
             continue;
         }
         if (!activeRuleIds.has(candidate.attestation.rule_id)) {
+            const sourceFingerprintStatus = await checkSourceFingerprints(repoRoot, sourceRoot, candidate.attestation.source_fingerprints ?? []);
+            const staleFingerprints = sourceFingerprintStatus.filter((item) => item.status !== "match");
+            if (staleFingerprints.length > 0) {
+                ignored.push({
+                    file: rel,
+                    rule_id: candidate.attestation.rule_id,
+                    reason: "Attestation is outside the active contract and its recorded source fingerprints changed or disappeared. Refresh or remove it before relying on the evidence trail.",
+                    source_fingerprint_status: sourceFingerprintStatus,
+                });
+                continue;
+            }
+            if (recordedRuleIds.has(candidate.attestation.rule_id)) {
+                continue;
+            }
             ignored.push({
                 file: rel,
                 rule_id: candidate.attestation.rule_id,
-                reason: "Attestation rule_id is not in the current compliance contract. It may be stale, off-platform, or from a previous sidecar scope; it is ignored by vise check.",
+                reason: "Attestation rule_id is not in the active or recorded engagement contracts. It may be stale or off-platform and is ignored by vise check.",
             });
         }
     }
@@ -2722,7 +2880,7 @@ async function readAttestationHygiene(repoRoot, compliance) {
         status: "needs-review",
         ignored,
         invalid,
-        nextStep: "Review ignored/invalid attestation files before using the evidence trail for handoff. Remove stale files only when you are sure they are unrelated, or re-run vise init/check/sync for the intended scope.",
+        nextStep: "Review fingerprint-stale, orphaned, or invalid attestation files before handoff. Matching evidence retained by a recorded engagement is checked through the engagement ledger and is not reported as stale.",
     };
 }
 async function readAttestationCandidate(filePath) {
@@ -2791,6 +2949,8 @@ function sidecarReadme(compliance) {
         "",
         "Attestations include source fingerprints; `vise check` marks them stale if the cited files change.",
         "",
+        "`engagements/<outcome>/` (when present) is the engagement ledger: each superseded engagement's final check, contract, and intake, recorded when a `vise init` switched to a different outcome. `vise status` lists them under `previousEngagements`; re-verify with `vise check --engagement <outcome>` or `--all-engagements`.",
+        "",
     ].join("\n");
 }
 function attestationsDir(repoRoot) {
@@ -2827,6 +2987,129 @@ function deriveGate(flags) {
         return { status: "runtime-proof-waived", exitCode: flags.allowProofWaiver ? 0 : 9 };
     return { status: "green", exitCode: 0 };
 }
+async function recordEngagementOnSwitch(repoRoot, previous, nextOutcome, finalCheck) {
+    const previousIntake = await readJsonIfExists(path.join(sidecarDir(repoRoot), "intake.json"));
+    const dir = path.join(engagementsDir(repoRoot), String(previous.outcome));
+    await rm(dir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    const verdict = finalCheck
+        ? { status: finalCheck.status, exitCode: finalCheck.exitCode }
+        : { status: "unrecorded", exitCode: null, note: "The final check could not run at switch time; contract and intake are still recorded." };
+    const record = {
+        outcome: previous.outcome,
+        ...(typeof previousIntake?.request === "string" ? { request: previousIntake.request } : {}),
+        recorded_at: new Date().toISOString(),
+        reason: `superseded by ${nextOutcome} init`,
+        ruleset_digest: previous.ruleset_digest,
+        verdict,
+    };
+    await writeJson(path.join(dir, "record.json"), record);
+    if (finalCheck) {
+        await writeJson(path.join(dir, "final-check.json"), finalCheck);
+    }
+    await writeJson(path.join(dir, "contract.json"), previous);
+    if (previousIntake) {
+        await writeJson(path.join(dir, "intake.json"), previousIntake);
+    }
+    return {
+        from: previous.outcome,
+        to: nextOutcome,
+        recorded: path.join(complianceDirName, "engagements", String(previous.outcome)),
+        last_verdict: verdict,
+        note: "The previous engagement's final state is recorded in the ledger; its completeness is no longer checked by this contract. `vise status` lists it under previousEngagements. On-demand re-verification (`vise check --all-engagements`) lands with B2 (docs/ENGAGEMENTS_DESIGN.md).",
+    };
+}
+function engagementsDir(repoRoot) {
+    return path.join(sidecarDir(repoRoot), "engagements");
+}
+async function reVerdictOne(repoPath, repoRoot, outcome) {
+    const dir = path.join(engagementsDir(repoRoot), outcome);
+    const record = await readJsonIfExists(path.join(dir, "record.json"));
+    const recorded = await readJsonIfExists(path.join(dir, "contract.json"));
+    if (!record || !recorded) {
+        const available = (await readdir(engagementsDir(repoRoot), { withFileTypes: true }).catch(() => []))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+        throw new Error(`No recorded engagement for outcome "${outcome}".${available.length > 0 ? ` Recorded engagements: ${available.join(", ")}.` : " The engagement ledger is empty (it is written when an init switches away from an outcome)."}`);
+    }
+    const inspection = await inspectProject(repoRoot, recorded.surface?.path === "." ? undefined : recorded.surface?.path);
+    const platforms = Array.from(new Set([...inspection.platforms, ...(recorded.surface?.platforms ?? [])]));
+    const rules = await applicableRules(recorded.outcome, platforms.length > 0 ? platforms : ["unknown"]);
+    const synthetic = {
+        ...recorded,
+        ruleset_digest: digestJson(rules.map(ruleRef)),
+        rules: rules.map(ruleRefForFile),
+        generated_at: new Date().toISOString(),
+    };
+    const check = await checkCompliance(repoPath, { contract: synthetic });
+    return { record, check, ruleset_upgraded: recorded.ruleset_digest !== synthetic.ruleset_digest };
+}
+export async function checkEngagementReVerdict(repoPath, outcome) {
+    const repoRoot = path.resolve(repoPath);
+    const { record, check, ruleset_upgraded } = await reVerdictOne(repoPath, repoRoot, outcome);
+    const drifted = check.status !== "green";
+    return {
+        mode: "re-verdict",
+        engagement: outcome,
+        ...(typeof record.request === "string" ? { request: record.request } : {}),
+        recorded_at: record.recorded_at,
+        recorded_verdict: record.verdict,
+        ruleset_upgraded,
+        status: check.status,
+        exitCode: drifted ? 11 : 0,
+        summary: check.summary,
+        ...(check.completeness ? { completeness: check.completeness } : {}),
+        rules: check.rules.filter((rule) => BASELINE_NON_GREEN.has(rule.status)),
+        note: "Re-verdict of a recorded engagement against the current ruleset and code. It does not change the active engagement's gate; exit 11 signals engagement drift.",
+    };
+}
+export async function checkAllEngagements(repoPath, options = {}) {
+    const repoRoot = path.resolve(repoPath);
+    const active = await checkCompliance(repoPath, options);
+    const activeNonGreenKeys = new Set(active.rules.filter((rule) => BASELINE_NON_GREEN.has(rule.status)).map((rule) => baselineKeyFor(rule)));
+    const entries = await readdir(engagementsDir(repoRoot), { withFileTypes: true }).catch(() => []);
+    const engagements = [];
+    let anyDrift = false;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === active.outcome) {
+            continue;
+        }
+        const { record, check, ruleset_upgraded } = await reVerdictOne(repoPath, repoRoot, entry.name);
+        const nonGreen = check.rules.filter((rule) => BASELINE_NON_GREEN.has(rule.status));
+        const gating = nonGreen.filter((rule) => !activeNonGreenKeys.has(baselineKeyFor(rule)));
+        const shared = nonGreen.length - gating.length;
+        const completenessMissing = check.completeness?.missing ?? [];
+        const drifted = gating.length > 0 || completenessMissing.length > 0 || check.status === "contract-drift";
+        anyDrift = anyDrift || drifted;
+        engagements.push({
+            outcome: entry.name,
+            ...(typeof record.request === "string" ? { request: record.request } : {}),
+            recorded_at: record.recorded_at,
+            recorded_verdict: record.verdict,
+            ruleset_upgraded,
+            status: drifted ? check.status : "green",
+            drift: drifted,
+            ...(shared > 0 ? { shared_with_active: shared } : {}),
+            ...(gating.length > 0 ? { gating } : {}),
+            ...(completenessMissing.length > 0 ? { completeness_missing: completenessMissing.map((item) => item.id) } : {}),
+        });
+    }
+    engagements.sort((a, b) => String(a.outcome).localeCompare(String(b.outcome)));
+    const activeGreen = active.exitCode === 0;
+    return {
+        ...active,
+        ...(activeGreen && anyDrift
+            ? {
+                status: "engagement-drift",
+                exitCode: 11,
+                active_status: active.status,
+                active_exitCode: active.exitCode,
+            }
+            : {}),
+        engagements,
+        engagements_note: "Re-verdicts of recorded engagements against the current ruleset and code. Findings already gating the active engagement are counted once there (shared_with_active). Exit 11 = active engagement green but a recorded engagement drifted.",
+    };
+}
 export async function recordBaseline(repoPath) {
     const repoRoot = path.resolve(repoPath);
     const compliance = await readCompliance(repoRoot);
@@ -2841,19 +3124,18 @@ export async function recordBaseline(repoPath) {
         const key = baselineKeyFor(result);
         findings[key] = (findings[key] ?? 0) + 1;
     }
-    const completeness_missing = (check.completeness?.missing ?? []).map((item) => item.id);
-    const selected_optional = [
-        ...(check.selectedOptionalCapabilities?.failed ?? []).map((item) => item.id),
-        ...(check.selectedOptionalCapabilities?.unknown ?? []),
-    ];
+    const deliverables_not_baselined = {
+        completeness_missing: (check.completeness?.missing ?? []).length,
+        selected_optional: (check.selectedOptionalCapabilities?.failed ?? []).length + (check.selectedOptionalCapabilities?.unknown ?? []).length,
+    };
     const baseline = {
         baselined_at: new Date().toISOString(),
         vise_version: packageVersion,
         outcome: compliance.outcome,
         ruleset_digest: compliance.ruleset_digest,
         findings,
-        completeness_missing,
-        selected_optional,
+        completeness_missing: [],
+        selected_optional: [],
     };
     await writeJson(baselinePath(repoRoot), baseline);
     return {
@@ -2862,9 +3144,15 @@ export async function recordBaseline(repoPath) {
         outcome: baseline.outcome,
         recorded: {
             findings: Object.values(findings).reduce((a, b) => a + b, 0),
-            completeness_missing: completeness_missing.length,
-            selected_optional: selected_optional.length,
         },
+        ...(deliverables_not_baselined.completeness_missing + deliverables_not_baselined.selected_optional > 0
+            ? {
+                deliverables_not_baselined: {
+                    ...deliverables_not_baselined,
+                    note: "The outcome's completeness checklist and selected optional capabilities are this engagement's deliverables — they are never baselined and still gate `vise check --new-only`. Use a completeness opt-out for capabilities the product genuinely does not want.",
+                },
+            }
+            : {}),
         nextStep: "Implement your change, then run `vise check --new-only` to gate only on findings introduced since this baseline. Re-run `vise baseline` after the contract or outcome changes.",
     };
 }

package/dist/tools/internalWorkspace.js

@@ -0,0 +1,44 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+const INTERNAL_PACKAGE_NAMES = {
+    "@amityco/social-plus-vise": "the Vise source tree",
+    "social-plus-blocks": "the social.plus blocks product tree",
+};
+export async function detectInternalWorkspace(repoPath) {
+    const root = path.resolve(repoPath);
+    const markers = [];
+    const rootName = await packageName(root);
+    if (rootName && INTERNAL_PACKAGE_NAMES[rootName]) {
+        markers.push(`package.json name "${rootName}" — this is ${INTERNAL_PACKAGE_NAMES[rootName]}`);
+    }
+    const workspaceFile = path.join(root, "pnpm-workspace.yaml");
+    if (await readFile(workspaceFile, "utf8").then(() => true, () => false)) {
+        const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".")) {
+                continue;
+            }
+            const memberName = await packageName(path.join(root, entry.name));
+            if (memberName && INTERNAL_PACKAGE_NAMES[memberName]) {
+                markers.push(`workspace member ${entry.name}/ is "${memberName}" — this is ${INTERNAL_PACKAGE_NAMES[memberName]}`);
+            }
+        }
+    }
+    return { isInternalWorkspace: markers.length > 0, markers };
+}
+export function internalWorkspaceWarning(detection) {
+    return {
+        detectedMarkers: detection.markers,
+        reason: "This target looks like the social.plus Vise / social.plus blocks development workspace, not a customer project.",
+        guidance: "Customer-integration commands write sp-vise/ state into a customer repo. For SDK surface facts while packaging blocks, use `vise sdk-facts` (projectless and read-only). To run the customer flow against a workspace fixture, point Vise at the fixture directory itself.",
+    };
+}
+async function packageName(directory) {
+    try {
+        const parsed = JSON.parse(await readFile(path.join(directory, "package.json"), "utf8"));
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}