@amityco/social-plus-vise 0.14.4 → 0.14.6

package/dist/tools/blocks.js

@@ -0,0 +1,385 @@
+import { access, mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { packageVersion } from "../version.js";
+import { inspectProject } from "./project.js";
+import { detectCommandSensors } from "./harness.js";
+import { readDesignContract } from "./design.js";
+const registryPlatformByVisePlatform = {
+    typescript: "react",
+    "react-native": "react-native",
+    flutter: "flutter",
+};
+export async function listRegistryBlocks(registryPath) {
+    const registry = await loadRegistry(registryPath);
+    return {
+        source: "social-plus-block-factory",
+        mode: "block-registry",
+        schemaVersion: registry.schemaVersion,
+        blocks: registry.blocks.map((block) => ({
+            blockId: block.blockId,
+            version: block.version,
+            status: block.status,
+            surfaces: block.surfaces,
+            requiredSdkCapabilities: block.requiredSdkCapabilities,
+            events: block.events,
+        })),
+    };
+}
+export async function planBlockInstall(options) {
+    return buildInstallPlan(options, "plan");
+}
+export async function addBlockInstall(options) {
+    const mode = options.apply ? "apply" : "dry-run";
+    const plan = await buildInstallPlan(options, mode);
+    if (!options.apply) {
+        return plan;
+    }
+    if (plan.status !== "ready") {
+        return {
+            ...plan,
+            applied: false,
+            reason: "Block install needs review before Vise can safely write files.",
+        };
+    }
+    const repoPath = requiredRepoPath(options);
+    const filesTouched = [];
+    filesTouched.push(...(await applyPackageChange(repoPath, plan)));
+    filesTouched.push(...(await applySourceChanges(repoPath, plan)));
+    filesTouched.push(await writeBlocksSidecar(repoPath, plan, options.packageSource ?? "npm", filesTouched));
+    return {
+        ...plan,
+        applied: true,
+        filesTouched,
+    };
+}
+export async function validateBlockInstall(options) {
+    if (!options.blockId) {
+        const repoPath = requiredRepoPath(options);
+        const registry = await loadRegistry(options.registryPath);
+        const sidecar = await readSidecar(repoPath);
+        const installed = sidecar?.installed ?? [];
+        const knownBlocks = new Set(registry.blocks.map((block) => block.blockId));
+        const findings = installed
+            .filter((entry) => !knownBlocks.has(entry.blockId))
+            .map((entry) => ({
+            ruleId: "blocks.registry.known",
+            severity: "warning",
+            message: `Installed sidecar entry references unknown registry block ${entry.blockId}.`,
+            recommendation: "Update the Block Factory registry or remove stale block sidecar state.",
+        }));
+        if (installed.length === 0) {
+            findings.push({
+                ruleId: "blocks.sidecar.installed",
+                severity: "warning",
+                message: "No installed block sidecar entries exist.",
+                recommendation: "Run `vise blocks add <repoPath> --block <id> --apply` after reviewing the dry-run plan.",
+            });
+        }
+        return {
+            status: findings.some((finding) => finding.severity === "error") ? "needs-review" : "ready",
+            mode: "validate",
+            registryBlocks: registry.blocks.map((block) => block.blockId),
+            sidecarPath: path.join("sp-vise", "blocks.json"),
+            sidecarInstalled: installed,
+            findings,
+        };
+    }
+    const plan = await buildInstallPlan(options, "validate");
+    const repoPath = requiredRepoPath(options);
+    const sidecar = await readSidecar(repoPath);
+    const installed = (sidecar?.installed ?? []).filter((entry) => !options.blockId || entry.blockId === options.blockId);
+    const findings = [];
+    if (installed.length === 0) {
+        findings.push({
+            ruleId: "blocks.sidecar.installed",
+            severity: "warning",
+            message: options.blockId ? `No sidecar entry exists for block ${options.blockId}.` : "No installed block sidecar entries exist.",
+            recommendation: "Run `vise blocks add <repoPath> --block <id> --apply` after reviewing the dry-run plan.",
+        });
+    }
+    if (plan.packageChange.alreadyPresent === false) {
+        findings.push({
+            ruleId: "blocks.package.present",
+            severity: "error",
+            message: `Required package dependency is missing: ${plan.packageChange.dependency}.`,
+            recommendation: `Install ${plan.packageChange.dependency} in ${plan.packageChange.file}.`,
+        });
+    }
+    for (const targetFile of plan.targetFiles) {
+        if (targetFile.operation === "needs-review") {
+            findings.push({
+                ruleId: "blocks.anchor.present",
+                severity: "error",
+                message: `Missing safe install anchor ${targetFile.anchor} in ${targetFile.path}.`,
+                recommendation: "Add an explicit social.plus block install anchor or install the block manually and re-run validation.",
+            });
+        }
+    }
+    const hasError = findings.some((finding) => finding.severity === "error");
+    return {
+        ...plan,
+        status: hasError ? "needs-review" : plan.status,
+        validationStatus: hasError ? "failed" : "passed",
+        sidecarInstalled: installed,
+        findings,
+    };
+}
+async function buildInstallPlan(options, mode) {
+    const repoPath = requiredRepoPath(options);
+    const registry = await loadRegistry(options.registryPath);
+    const block = findBlock(registry, options.blockId);
+    const inspection = await inspectProject(repoPath, options.surfacePath);
+    const platform = inspection.platforms[0] ?? "unknown";
+    const registryPlatform = registryPlatformByVisePlatform[platform];
+    const sensors = await detectCommandSensors(inspection.effectiveRoot, inspection.platforms);
+    const stopConditions = [];
+    if (!registryPlatform) {
+        stopConditions.push(`Unsupported Vise blocks installer platform: ${platform}. Supported installer platforms: react, react-native, flutter.`);
+    }
+    const packageInfo = registryPlatform ? block.packages[registryPlatform] : undefined;
+    if (!packageInfo || !registryPlatform) {
+        stopConditions.push(`Block ${block.blockId} does not provide installer metadata for detected platform ${platform}.`);
+    }
+    const safePackage = packageInfo ?? {
+        packageName: "",
+        dependencyName: "",
+        publicEntrypoint: "",
+        importName: "",
+        installAnchor: "",
+    };
+    const packageChange = await packageChangeFor(inspection.effectiveRoot, registryPlatform, safePackage, options.packageSource);
+    const targetFiles = await targetFilesFor(inspection.effectiveRoot, block.blockId, registryPlatform, safePackage);
+    for (const targetFile of targetFiles) {
+        if (targetFile.operation === "needs-review") {
+            stopConditions.push(`Missing safe install anchor ${targetFile.anchor} in ${targetFile.path}.`);
+        }
+    }
+    return {
+        status: stopConditions.length > 0 ? "needs-review" : "ready",
+        mode,
+        block: {
+            id: block.blockId,
+            version: block.version,
+            status: block.status,
+        },
+        platform,
+        registryPlatform: registryPlatform ?? "react",
+        package: safePackage,
+        packageSource: options.packageSource,
+        packageChange,
+        targetFiles,
+        sensors: sensors.map((sensor) => ({ name: sensor.name, command: sensor.command, source: sensor.source })),
+        stopConditions,
+        sidecarPath: path.join("sp-vise", "blocks.json"),
+    };
+}
+async function loadRegistry(registryPath) {
+    if (!registryPath) {
+        throw new Error("blocks command requires --registry <path>.");
+    }
+    const resolved = path.resolve(registryPath);
+    if (!(await exists(resolved))) {
+        throw new Error(`Block registry not found: ${registryPath}. Local registry paths are supported in this MVP.`);
+    }
+    const registryFile = (await stat(resolved)).isDirectory() ? path.join(resolved, "blocks.json") : resolved;
+    const registry = JSON.parse(await readFile(registryFile, "utf8"));
+    validateRegistry(registry, registryFile);
+    return registry;
+}
+function validateRegistry(registry, registryFile) {
+    if (registry.schemaVersion !== "2026-06-04.block-registry.v1") {
+        throw new Error(`${registryFile}: unsupported block registry schemaVersion ${registry.schemaVersion}`);
+    }
+    if (!Array.isArray(registry.blocks) || registry.blocks.length === 0) {
+        throw new Error(`${registryFile}: registry.blocks must be a non-empty array`);
+    }
+    for (const block of registry.blocks) {
+        if (!block.blockId || !block.version || !Array.isArray(block.surfaces)) {
+            throw new Error(`${registryFile}: every block requires blockId, version, and surfaces`);
+        }
+    }
+}
+function findBlock(registry, blockId) {
+    if (!blockId) {
+        throw new Error("blocks command requires --block <id> for plan/add/validate.");
+    }
+    const block = registry.blocks.find((entry) => entry.blockId === blockId);
+    if (!block) {
+        throw new Error(`Unknown block in registry: ${blockId}`);
+    }
+    return block;
+}
+async function packageChangeFor(root, platform, packageInfo, packageSource) {
+    if (platform === "flutter") {
+        const file = "pubspec.yaml";
+        const source = await readFile(path.join(root, file), "utf8").catch(() => "");
+        return {
+            file,
+            dependency: packageInfo.dependencyName,
+            value: dependencyValue(root, packageInfo, packageSource, platform),
+            alreadyPresent: new RegExp(`\\b${escapeRegExp(packageInfo.dependencyName)}\\s*:`).test(source),
+        };
+    }
+    const file = "package.json";
+    const packageJson = await readPackageJson(path.join(root, file));
+    return {
+        file,
+        dependency: packageInfo.dependencyName,
+        value: dependencyValue(root, packageInfo, packageSource, platform),
+        alreadyPresent: Boolean(packageJson.dependencies?.[packageInfo.dependencyName]),
+    };
+}
+async function targetFilesFor(root, blockId, platform, packageInfo) {
+    const sourceFile = sourceFileFor(platform);
+    if (!sourceFile) {
+        return [];
+    }
+    const absolutePath = path.join(root, sourceFile);
+    const source = await readFile(absolutePath, "utf8").catch(() => "");
+    const blockPresent = packageInfo.publicEntrypoint !== "" && source.includes(packageInfo.publicEntrypoint);
+    const anchorPresent = packageInfo.installAnchor !== "" && source.includes(packageInfo.installAnchor);
+    return [
+        {
+            path: sourceFile,
+            anchor: packageInfo.installAnchor,
+            operation: blockPresent ? "already-present" : anchorPresent ? "insert" : "needs-review",
+        },
+    ];
+}
+async function applyPackageChange(repoPath, plan) {
+    const filePath = path.join(repoPath, plan.packageChange.file);
+    if (plan.packageChange.alreadyPresent) {
+        return [];
+    }
+    if (plan.registryPlatform === "flutter") {
+        const source = await readFile(filePath, "utf8");
+        const next = addPubspecDependency(source, plan.packageChange.dependency, plan.packageChange.value);
+        await writeFile(filePath, next, "utf8");
+        return [plan.packageChange.file];
+    }
+    const packageJson = await readPackageJson(filePath);
+    packageJson.dependencies = {
+        ...(packageJson.dependencies ?? {}),
+        [plan.packageChange.dependency]: plan.packageChange.value,
+    };
+    await writeFile(filePath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+    return [plan.packageChange.file];
+}
+async function applySourceChanges(repoPath, plan) {
+    const touched = [];
+    for (const targetFile of plan.targetFiles) {
+        if (targetFile.operation !== "insert") {
+            continue;
+        }
+        const filePath = path.join(repoPath, targetFile.path);
+        const source = await readFile(filePath, "utf8");
+        const next = insertBlockSnippet(source, plan);
+        if (next !== source) {
+            await writeFile(filePath, next, "utf8");
+            touched.push(targetFile.path);
+        }
+    }
+    return touched;
+}
+async function writeBlocksSidecar(repoPath, plan, packageSource, filesTouched) {
+    const designContract = await readDesignContract(repoPath);
+    const sidecarPath = path.join(repoPath, "sp-vise", "blocks.json");
+    const existing = await readSidecar(repoPath);
+    const sidecar = existing ?? {
+        schemaVersion: "2026-06-04.vise-blocks-sidecar.v1",
+        viseVersion: packageVersion,
+        generatedAt: new Date().toISOString(),
+        installed: [],
+    };
+    const entry = {
+        blockId: plan.block.id,
+        blockVersion: plan.block.version,
+        platform: plan.registryPlatform,
+        packageSource,
+        filesTouched,
+        designContractDigest: designContract?.digest,
+        sdkFactsVersion: plan.block.version,
+        validationStatus: "installed",
+    };
+    sidecar.viseVersion = packageVersion;
+    sidecar.generatedAt = new Date().toISOString();
+    sidecar.installed = [...sidecar.installed.filter((item) => item.blockId !== plan.block.id), entry];
+    await mkdir(path.dirname(sidecarPath), { recursive: true });
+    await writeFile(sidecarPath, `${JSON.stringify(sidecar, null, 2)}\n`, "utf8");
+    return path.join("sp-vise", "blocks.json");
+}
+async function readSidecar(repoPath) {
+    const sidecarPath = path.join(repoPath, "sp-vise", "blocks.json");
+    try {
+        return JSON.parse(await readFile(sidecarPath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function dependencyValue(root, packageInfo, packageSource, platform) {
+    if (!packageSource || packageSource === "npm") {
+        return platform === "flutter" ? "^0.1.0" : "^0.1.0";
+    }
+    if (packageSource.startsWith("file:")) {
+        return packageSource;
+    }
+    const resolved = path.resolve(root, packageSource);
+    return `file:${path.relative(root, resolved)}`;
+}
+function sourceFileFor(platform) {
+    if (platform === "react") {
+        return path.join("src", "render.mjs");
+    }
+    if (platform === "react-native") {
+        return path.join("src", "App.mjs");
+    }
+    if (platform === "flutter") {
+        return path.join("lib", "main.dart");
+    }
+    return null;
+}
+function insertBlockSnippet(source, plan) {
+    if (source.includes(plan.package.publicEntrypoint)) {
+        return source;
+    }
+    if (plan.registryPlatform === "react" || plan.registryPlatform === "react-native") {
+        const importSnippet = `import { ${plan.package.importName} } from "${plan.package.publicEntrypoint}";`;
+        return source.replace(plan.package.installAnchor, `${plan.package.installAnchor}\n${importSnippet}\n// social-plus-vise: ${plan.block.id} source mount requires human review in brownfield apps`);
+    }
+    if (plan.registryPlatform === "flutter") {
+        const importSnippet = `import '${plan.package.publicEntrypoint}';`;
+        return source.replace(plan.package.installAnchor, `${plan.package.installAnchor}\n${importSnippet}\n// social-plus-vise: ${plan.block.id} widget mount requires human review in brownfield apps`);
+    }
+    return source;
+}
+function addPubspecDependency(source, dependencyName, value) {
+    if (!source.includes("dependencies:")) {
+        return `${source.trimEnd()}\n\ndependencies:\n  ${dependencyName}:\n    path: ${value.replace(/^file:/, "")}\n`;
+    }
+    const lines = source.split(/\r?\n/);
+    const insertIndex = lines.findIndex((line) => line.trim() === "dependencies:") + 1;
+    lines.splice(insertIndex, 0, `  ${dependencyName}:`, `    path: ${value.replace(/^file:/, "")}`);
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+async function readPackageJson(filePath) {
+    return JSON.parse(await readFile(filePath, "utf8"));
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function requiredRepoPath(options) {
+    if (!options.repoPath) {
+        throw new Error("blocks command requires repoPath.");
+    }
+    return path.resolve(options.repoPath);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/tools/compliance.js

@@ -2,11 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { assessProjectCompleteness } from "../capabilities.js";
-import { classifyOutcome } from "../outcomes.js";
-import { objectInput, optionalStringField, stringField, textResult } from "../types.js";
+import { assessProjectCompleteness, assessProjectSelectedOptionalCapabilities, optionalCapabilityChecklist, selectedOptionalCapabilityIds, } from "../capabilities.js";
+import { classifyOutcome, getOutcomeDefinition, hasAnswer, planContextFor, } from "../outcomes.js";
+import { objectInput, optionalBooleanField, optionalStringField, stringField, textResult } from "../types.js";
 import { packageVersion } from "../version.js";
-import { readDesignContract } from "./design.js";
+import { buildDesignBrief, readDesignContract } from "./design.js";
 import { inspectProject, validateSetup } from "./project.js";
 const complianceDirName = "sp-vise";
 const attestationsDirName = "attestations";
@@ -21,13 +21,22 @@ export const initComplianceTool = {
             repoPath: { type: "string" },
             request: { type: "string" },
             surfacePath: { type: "string" },
+            answers: {
+                type: "object",
+                description: "Optional intake answers from vise plan, including feed_optional_capabilities.",
+                additionalProperties: { type: "string" },
+            },
+            allowUnresolvedIntake: {
+                type: "boolean",
+                description: "Explicit acknowledgement for retrospective/harness initialization when blocking intake questions remain unresolved.",
+            },
         },
         required: ["repoPath", "request"],
         additionalProperties: false,
     },
     async call(input) {
         const args = objectInput(input);
-        return textResult(await initCompliance(stringField(args, "repoPath"), stringField(args, "request"), optionalStringField(args, "surfacePath")));
+        return textResult(await initCompliance(stringField(args, "repoPath"), stringField(args, "request"), optionalStringField(args, "surfacePath"), answersFromInput(args.answers), { allowUnresolvedIntake: optionalBooleanField(args, "allowUnresolvedIntake") }));
     },
 };
 export const checkComplianceTool = {
@@ -46,6 +55,18 @@ export const checkComplianceTool = {
         return textResult(await checkCompliance(stringField(args, "repoPath")));
     },
 };
+function answersFromInput(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return {};
+    }
+    const answers = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === "string" && value.trim() !== "") {
+            answers[key] = value;
+        }
+    }
+    return answers;
+}
 export const syncComplianceTool = {
     name: "sync_compliance",
     description: "Persist current deterministic-pass compliance results into the sp-vise sidecar.",
@@ -225,15 +246,34 @@ async function readEngagement(repoRoot) {
 function engagementPath(repoRoot) {
     return path.join(sidecarDir(repoRoot), "engagement.json");
 }
-export async function initCompliance(repoPath, request, surfacePath) {
+export async function initCompliance(repoPath, request, surfacePath, answers = {}, options = {}) {
     const repoRoot = path.resolve(repoPath);
     const inspection = await inspectProject(repoRoot, surfacePath);
     const outcome = classifyOutcome(request);
+    const selectedOptionalCapabilities = selectedOptionalCapabilityIds(outcome, answers, request);
     const rules = await applicableRules(outcome, inspection.platforms);
     const refs = rules.map(ruleRef); // minimal shape — stable digest input
     const fileRefs = rules.map(ruleRefForFile); // adds title for human/agent readers
     const engagement = await readEngagement(repoRoot);
     const designContract = await readDesignContract(repoRoot);
+    const intake = intakeAuditFor({
+        request,
+        outcome,
+        platforms: inspection.platforms,
+        designSignals: inspection.designSignals,
+        answers,
+        designBrief: designContract ? buildDesignBrief(designContract) : undefined,
+        allowUnresolvedIntake: options.allowUnresolvedIntake === true,
+    });
+    if (intake.remainingBlocking > 0 && !intake.acknowledged_unresolved_blocking) {
+        return {
+            status: "needs-clarification",
+            exitCode: 7,
+            outcome,
+            intake,
+            nextStep: "Run `vise plan` and surface the blocking intake questions to the customer. Re-run `vise init` with --answer for each blocking question, or pass --allow-unresolved-intake only for retrospective/harness initialization.",
+        };
+    }
     const compliance = {
         schema_version: schemaVersion,
         vise_version: packageVersion,
@@ -254,9 +294,16 @@ export async function initCompliance(repoPath, request, surfacePath) {
                 inferred_tokens: designContract.stats.inferred_tokens,
             }
             : undefined,
+        selected_optional_capabilities: selectedOptionalCapabilities.length > 0 ? selectedOptionalCapabilities : undefined,
     };
     await mkdir(attestationsDir(repoRoot), { recursive: true });
     await writeJson(compliancePath(repoRoot), compliance);
+    await writeJson(path.join(sidecarDir(repoRoot), "intake.json"), {
+        generated_at: compliance.generated_at,
+        request,
+        outcome,
+        ...intake,
+    });
     await writeJson(path.join(sidecarDir(repoRoot), "inspection.json"), inspection);
     await writeFile(path.join(sidecarDir(repoRoot), "README.md"), sidecarReadme(compliance), "utf8");
     // Write a frozen check snapshot so agents can see current rule status immediately
@@ -282,10 +329,83 @@ export async function initCompliance(repoPath, request, surfacePath) {
         rules: refs.length,
         engagement_id: engagement?.engagement_id,
         ...(compliance.design_contract && { design_contract: compliance.design_contract }),
+        ...(selectedOptionalCapabilities.length > 0 && { selected_optional_capabilities: selectedOptionalCapabilities }),
+        intake: {
+            status: intake.status,
+            remainingBlocking: intake.remainingBlocking,
+            acknowledged_unresolved_blocking: intake.acknowledged_unresolved_blocking,
+            questions: intake.questions,
+            answers: intake.answers,
+        },
         ...(warnings.length > 0 && { warnings }),
         nextStep: "Run vise check, then implement until rules pass deterministically or are attested.",
     };
 }
+function intakeAuditFor(args) {
+    const platform = preferredPlatform(args.platforms);
+    const ctx = planContextFor({
+        request: args.request,
+        outcome: args.outcome,
+        platform,
+        platforms: args.platforms,
+        designSignals: args.designSignals,
+        answers: args.answers,
+    });
+    const questions = [...getOutcomeDefinition(args.outcome).intakeQuestions(ctx)];
+    if (ctx.mentionsDesign && ctx.designSignals.length === 0 && !hasAnswer(ctx.answers, "design_source")) {
+        questions.push({
+            id: "design_source",
+            question: "Where are the app's design tokens, theme, or reusable UI components defined?",
+            why: "The user asked to match the existing design, and no local design source was detected.",
+            required: true,
+            blocksImplementationWhenMissing: true,
+        });
+    }
+    if (ctx.mentionsDesign && ctx.designSignals.length > 0 && !hasAnswer(ctx.answers, "confirm_design_source")) {
+        questions.push({
+            id: "confirm_design_source",
+            question: `Should the social UI use the detected design source(s): ${ctx.designSignals.map((signal) => signal.file).join(", ")}?`,
+            why: "Vise found likely design evidence, but the user or host agent should confirm it is the right source before UI edits.",
+            required: true,
+            blocksImplementationWhenMissing: false,
+            options: ["yes", "use another source"],
+        });
+    }
+    if (args.designBrief &&
+        (args.outcome === "add-feed" || args.outcome === "add-chat") &&
+        !args.designBrief.roles.some((role) => role.role === "primaryAction") &&
+        !hasAnswer(ctx.answers, "primary_action_token")) {
+        questions.push({
+            id: "primary_action_token",
+            question: "Which design token (or color value) should be used as the primary action color? No primary-action token was confidently identified in the design contract.",
+            why: "A primary action colour is needed for interactive elements (composer button, own-message bubble). Without a confident token, the agent must guess or omit it.",
+            required: false,
+            blocksImplementationWhenMissing: false,
+        });
+    }
+    if (args.outcome === "add-feed" && optionalCapabilityChecklist(args.outcome).length > 0 && !hasAnswer(ctx.answers, "feed_optional_capabilities")) {
+        questions.push({
+            id: "feed_optional_capabilities",
+            question: "Which optional feed capabilities should be in scope: post-image-upload, post-poll-creation, post-edit, or none?",
+            why: "These capabilities are useful for full feeds, but should become enforceable only after the customer explicitly opts in.",
+            required: false,
+            blocksImplementationWhenMissing: false,
+            options: ["none", ...optionalCapabilityChecklist(args.outcome).map((capability) => capability.id)],
+        });
+    }
+    const remainingBlocking = questions.filter((question) => question.blocksImplementationWhenMissing).length;
+    return {
+        status: remainingBlocking > 0 ? "needs-clarification" : "ready",
+        questions,
+        answers: args.answers,
+        remainingBlocking,
+        acknowledged_unresolved_blocking: args.allowUnresolvedIntake && remainingBlocking > 0,
+    };
+}
+function preferredPlatform(platforms) {
+    const order = ["flutter", "android", "typescript", "react-native", "ios"];
+    return order.find((platform) => platforms.includes(platform)) ?? platforms[0] ?? "unknown";
+}
 export async function applicableComplianceRuleSummaries(outcome, platforms) {
     return (await applicableRules(outcome, platforms)).map(ruleRefForFile);
 }
@@ -454,31 +574,48 @@ export async function checkCompliance(repoPath) {
     const hasDeterministicFailure = results.some((result) => result.status === "deterministic-fail");
     // "advisory" status is intentionally excluded — advisory rules surface but never block.
     const needsAttestation = results.some((result) => result.status === "attestation-needed" || result.status === "stale");
-    // Precedence: blocked (3) > deterministic-failures (2) > needs-attestation (1) > completeness-gap (5) > green (0).
+    // Precedence: blocked (3) > deterministic-failures (2) > needs-attestation (1) >
+    // completeness-gap (5) > selected-capability-failures (6) > green (0).
     // Contract drift (exit 4) is handled earlier and short-circuits the loop.
     // Completeness-gap: capabilities that are neither present nor validly opted-out require an explicit decision
     // (build it, or place // vise: scope-omit <id> — <reason>). The scope-omit escape hatch keeps this
     // FP-free because any capability can be excluded with a recorded reason. Failure to assess is silently ignored.
     const completeness = (await assessProjectCompleteness(inspection.effectiveRoot, compliance.outcome).catch(() => null)) ?? undefined;
     const hasCompletenessGap = (completeness?.missing.length ?? 0) > 0;
+    const selectedOptionalCapabilities = (await assessProjectSelectedOptionalCapabilities(inspection.effectiveRoot, compliance.outcome, compliance.selected_optional_capabilities ?? []).catch(() => null)) ?? undefined;
+    const hasSelectedOptionalFailures = ((selectedOptionalCapabilities?.failed.length ?? 0) > 0) || ((selectedOptionalCapabilities?.unknown.length ?? 0) > 0);
     // Blocked wins because the agent cannot proceed without customer input;
     // surfacing a smaller failure first would distract from the real blocker.
+    const status = hasBlocked
+        ? "blocked"
+        : hasDeterministicFailure
+            ? "deterministic-failures"
+            : needsAttestation
+                ? "needs-attestation"
+                : hasCompletenessGap
+                    ? "completeness-gap"
+                    : hasSelectedOptionalFailures
+                        ? "selected-capability-failures"
+                        : "green";
     return {
-        status: hasBlocked
-            ? "blocked"
+        status,
+        exitCode: hasBlocked
+            ? 3
             : hasDeterministicFailure
-                ? "deterministic-failures"
+                ? 2
                 : needsAttestation
-                    ? "needs-attestation"
+                    ? 1
                     : hasCompletenessGap
-                        ? "completeness-gap"
-                        : "green",
-        exitCode: hasBlocked ? 3 : hasDeterministicFailure ? 2 : needsAttestation ? 1 : hasCompletenessGap ? 5 : 0,
+                        ? 5
+                        : hasSelectedOptionalFailures
+                            ? 6
+                            : 0,
         outcome: compliance.outcome,
         surfacePath: compliance.surface?.path,
         summary,
         rules: results,
         ...(completeness && (completeness.missing.length > 0 || completeness.optedOut.length > 0 || completeness.present.length > 0) ? { completeness } : {}),
+        ...(selectedOptionalCapabilities ? { selectedOptionalCapabilities } : {}),
     };
 }
 export async function syncCompliance(repoPath) {