@amityco/social-plus-vise 0.14.3 → 0.14.5

package/CHANGELOG.md

@@ -4,7 +4,17 @@ All notable changes to `@amityco/social-plus-vise` are documented in this file.
 
 The format is loosely based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## 0.14.3 — 2026-06-04
+## 0.14.5 — 2026-06-04
+
+**Theme:** Optional feed capabilities become explicit opt-in sensors.
+
+### Changed
+- **Add-feed completeness baseline narrowed to pagination:** image upload, poll creation, and edit post are no longer baseline completeness requirements. The add-feed `completenessChecklist` now gates pagination / load-more only.
+- **Optional feed capabilities require explicit opt-in:** `vise plan` now offers image upload, poll creation, and edit post as `optionalCapabilities`. When the user selects one and the agent carries it into `vise init --answer feed_optional_capabilities=...`, `vise check` runs selected source sensors and exits `selected-capability-failures` (exit code 6) until the selected capability is implemented.
+
+---
+
+## 0.14.4 — 2026-06-04
 
 **Theme:** Completeness-gap enforcement and add-feed guidance hardening (image upload + poll creation + pagination build step).
 
@@ -17,6 +27,7 @@ The format is loosely based on [Keep a Changelog](https://keepachangelog.com/en/
 ### Fixed
 - **`targetType` rule recommendation tightened:** the `validateFeedTargetTypeExplicit` validator recommendation now explicitly calls for binding `targetType` to the intake-resolved feed target (e.g. `communityId` from route params, `userId` from auth context) rather than simply avoiding a literal. Prevents agents from introducing an unbound variable that satisfies the literal check while leaving the same intent gap.
 - **Completeness assessment note language corrected:** `vise plan` completeness note and `assessCompleteness` output no longer say "advisory — never fails the check". They now accurately state that missing items cause `vise check` to exit `completeness-gap` (exit code 5).
+- **Scope-omit markers now require a reason:** `// vise: scope-omit <id>` no longer clears a completeness gap by itself. The marker must include a reason (for example `// vise: scope-omit post-poll — polls disabled for this tenant`) or the capability remains `missing`.
 
 ### Changed
 - **`SKILL.md` scope-omit enforcement:** the Required Loop section now treats missing completeness items as a stop condition, not a suggestion. Agents must either implement or `// vise: scope-omit <id> — <reason>` each missing capability before reporting done.

package/README.md

@@ -45,7 +45,7 @@ See [Usage Flow](#usage-flow) for the full step-by-step diagram.
 
 Instead of just providing a CLI or AI skills, Vise implements a technique called **Agentic Workflow Governance**. Think of it as a customer-project integration harness: the governed build loop runs inside the target repo, grounded in the real project, real docs, and real validation signals.
 
-Vise wraps your local coding agents in compliance guardrails when they integrate social.plus SDKs. It inspects your project, grounds the agent in hosted docs, enforces 300 platform-specific compliance rules, checks the generated UI against the customer's design system, surfaces the full SDK feature surface so nothing is silently dropped, and runs your project's own build/lint/typecheck sensors. **Your source code never leaves your machine.**
+Vise wraps your local coding agents in compliance guardrails when they integrate social.plus SDKs. It inspects your project, grounds the agent in hosted docs, enforces 300 platform-specific compliance rules, checks the generated UI against the customer's design system, gates narrow baseline capabilities so nothing mandatory is silently dropped, offers richer feed capabilities as explicit opt-ins, and runs your project's own build/lint/typecheck sensors. **Your source code never leaves your machine.**
 
 At a glance, Vise sits between the user's prompt and the agent's code changes. The agent still edits the app; Vise turns the request into a grounded plan, records the local contract, and keeps checking until the integration is ready to ship.
 
@@ -77,9 +77,9 @@ Vise validates on three layers, and the layer is set by the *kind of claim* —
 |---|---|---|---|
 | **SDK compliance** | "this is **wrong**" | 300 deterministic rules (session renewal, live-collection vs one-shot, no secret in logs, parent-child rendering, ban-state gating…) | **Hard gate** — `vise check` blocks until green or attested. A small advisory subset surfaces as informational only and never blocks. |
 | **Design conformance** | "this **looks off**" | extract the customer's design system into a contract, then check token usage | **Advisory** — `vise design check`/`preview`; never fails a build |
-| **Feature completeness** | "this is **missing**" | Vise proposes the full SDK feature surface per outcome; the agent opts out of anything out of scope with a recorded reason | **Advisory** — surfaced in `vise plan`/`check`; never fails a build |
+| **Feature completeness** | "this is **missing**" | Vise proposes a narrow baseline per outcome; for add-feed, pagination is mandatory, while richer feed capabilities are opt-in choices from `vise plan` | **Decision gate** — `vise check` exits `completeness-gap` until each baseline capability is built or validly opted out; selected optional capabilities run separate sensors |
 
-Only correctness is gated (it can be made FP-free); conformance and completeness are surfaced, because "all post types" and "matches the brand" are legitimately scope-dependent. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+Correctness is gated by deterministic rules or attestations. Baseline completeness is gated by explicit scope decisions: if a baseline capability is legitimately out of scope, record `// vise: scope-omit <id> — <reason>` and it no longer blocks. Optional feed capabilities such as image upload, poll creation, and edit post are offered during planning and become checked only after the user opts in. Conformance remains advisory because "matches the brand" is legitimately subjective. See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
 
 ### Relationship to social.plus Block Factory
 
@@ -409,12 +409,13 @@ jobs:
 
 | Code | Meaning |
 |---|---|
-| `0` | All rules pass and all expected capabilities are either present or opted-out |
+| `0` | All rules pass, all baseline capabilities are present or opted-out, and any selected optional capabilities pass |
 | `1` | One or more rules need attestation |
 | `2` | One or more rules have deterministic failures |
 | `3` | One or more blockers fired (missing prerequisite, e.g. `google-services.json`) |
 | `4` | Contract drift — rules in `sp-vise/compliance.json` no longer match the current ruleset |
-| `5` | One or more expected capabilities are neither implemented nor opted-out — add the capability or place `// vise: scope-omit <id> — <reason>` |
+| `5` | One or more baseline capabilities are neither implemented nor validly opted-out — add the capability or place `// vise: scope-omit <id> — <reason>` |
+| `6` | One or more explicitly selected optional capabilities failed source sensors |
 
 `vise check --ci` is read-only. It never updates `sp-vise/`. The JSON output includes a `ci` block with structured details for pipeline logs.
 

package/dist/capabilities.js

@@ -1,26 +1,25 @@
 /**
- * Feature-completeness assessment — ADVISORY ONLY.
+ * Feature-completeness assessment.
  *
  * Boundary (see the validation-boundaries principle): completeness is a "this is
- * missing" claim — a universal-negative over open-ended correct implementations.
- * It is structurally false-positive-prone and therefore NEVER a hard gate. This
- * module only surfaces nudges; `vise check`'s status/exit code are untouched.
+ * missing" claim — a universal-negative over open-ended correct implementations
+ * unless the customer/agent explicitly removes it from scope. Missing capabilities
+ * now produce `completeness-gap` in `vise check`; a recorded scope-omit reason is
+ * the false-positive escape hatch.
  *
  * Memory-independence comes from inversion: VISE authors the canonical capability
  * set per outcome; the agent must OPT OUT of a capability with a recorded reason
  * (`// vise: scope-omit <id> <reason>`), which `check` reads and reports. The
  * agent subtracts with justification — it doesn't have to remember the set.
  *
- * Gate-eligibility (not used here — these stay advisory): a capability could only
- * ever graduate to a gate if it has a named SDK-call anchor AND a no-fire fixture.
- * Every capability below is anchored on SDK symbols for exactly that reason, but
- * the output is advisory regardless.
+ * Baseline capability gates must stay narrow. For add-feed, pagination is the
+ * mandatory capability; richer composer affordances are selected optional sensors.
  */
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
-// Canonical, Vise-authored capability set — the SDK feature surface (grounded in
-// rules/*.yaml + SKILL.md, not guessed). Anchored on SDK symbol names (consistent
-// enough across TS/Flutter/Android/iOS to match cross-platform). All advisory.
+// Canonical, Vise-authored capability catalog — the SDK feature surface
+// (grounded in rules/*.yaml + SKILL.md, not guessed). Baseline gating is applied
+// by baselineCapabilities(); not every catalog item is mandatory for every outcome.
 export const CAPABILITIES = [
     // ── add-feed: post dataTypes (a feed parent is usually 'text'; rich content
     //    rides on child posts — render each type the feed can return) ──────────
@@ -367,23 +366,143 @@ export const CAPABILITIES = [
         hint: "respect Amity's server-side notification settings/preferences (getSettings)",
     },
 ];
-const ADVISORY_NOTE = "Build each missing capability, or opt out with a recorded reason: `// vise: scope-omit <id> <reason>`. Missing capabilities that are neither built nor opted-out cause `vise check` to exit with status `completeness-gap` (exit code 5).";
-/** The Vise-authored capability checklist for an outcome (for `vise plan` feed-forward). */
+// Optional capabilities are not baseline compliance. `vise plan` offers them as
+// explicit feed-forward choices; `vise init --answer feed_optional_capabilities=...`
+// records selected choices; `vise check` then evaluates these source sensors.
+export const OPTIONAL_CAPABILITIES = [
+    {
+        id: "post-image-upload",
+        label: "Image/file upload composer",
+        outcomes: ["add-feed"],
+        aliases: [/image(?:\/file)? upload/i, /image post/i, /file post/i, /attachments?/i, /media upload/i],
+        sensors: [
+            { label: "FileRepository.uploadImage or uploadImage", regex: /FileRepository\.uploadImage\s*\(|(?<![.\w])uploadImage\s*\(/ },
+            { label: "createPost attachments array", regex: /createPost\s*\(\s*\{[\s\S]*?attachments\s*:/ },
+        ],
+        hint: "If the user opts into media posting, implement file picker -> FileRepository.uploadImage(file) -> createPost({ ..., attachments: [{ fileId, fileType: 'image' }] }).",
+    },
+    {
+        id: "post-poll-creation",
+        label: "Poll composer and voting",
+        outcomes: ["add-feed"],
+        aliases: [/poll creation/i, /poll composer/i, /create poll/i, /\bpolls?\b/i],
+        sensors: [
+            { label: "PollRepository.createPoll", regex: /PollRepository\.createPoll\s*\(|(?<![.\w])createPoll\s*\(/ },
+            {
+                label: "createPost links pollId",
+                regex: /createPost\s*\(\s*\{[\s\S]*?data\s*:\s*\{[\s\S]*?\bpollId\b\s*(?::|[,}])/,
+            },
+            { label: "PollRepository.votePoll", regex: /PollRepository\.votePoll\s*\(|(?<![.\w])votePoll\s*\(/ },
+        ],
+        hint: "If the user opts into polls, implement the createPoll -> createPost({ data: { pollId } }) chain and the votePoll read-side interaction.",
+    },
+    {
+        id: "post-edit",
+        label: "Edit own post",
+        outcomes: ["add-feed"],
+        aliases: [/edit post/i, /edit own post/i, /author edit/i, /\beditPost\b/i],
+        sensors: [
+            { label: "PostRepository.editPost", regex: /PostRepository\.editPost\s*\(|(?<![.\w])editPost\s*\(/ },
+        ],
+        hint: "If the user opts into author management, show edit only for post.postedUserId === currentUserId and call PostRepository.editPost with updated text data.",
+    },
+];
+const ADVISORY_NOTE = "Build each missing capability, or opt out with a recorded reason: `// vise: scope-omit <id> — <reason>`. A scope-omit marker without a reason is invalid and still counts as missing. Missing capabilities that are neither built nor validly opted-out cause `vise check` to exit with status `completeness-gap` (exit code 5).";
+const BASELINE_CAPABILITY_IDS_BY_OUTCOME = {
+    "add-feed": ["pagination"],
+};
+function baselineCapabilities(outcome) {
+    const caps = CAPABILITIES.filter((c) => c.outcomes.includes(outcome));
+    const baselineIds = BASELINE_CAPABILITY_IDS_BY_OUTCOME[outcome];
+    if (!baselineIds) {
+        return caps;
+    }
+    const baseline = new Set(baselineIds);
+    return caps.filter((capability) => baseline.has(capability.id));
+}
+/** The Vise-authored baseline capability checklist for an outcome. */
 export function capabilityChecklist(outcome) {
-    return CAPABILITIES.filter((c) => c.outcomes.includes(outcome)).map((c) => ({ id: c.id, label: c.label, hint: c.hint }));
+    return baselineCapabilities(outcome).map((c) => ({ id: c.id, label: c.label, hint: c.hint }));
+}
+/** Optional feed-forward choices. These are not baseline completeness requirements. */
+export function optionalCapabilityChecklist(outcome) {
+    return OPTIONAL_CAPABILITIES.filter((c) => c.outcomes.includes(outcome)).map((c) => ({ id: c.id, label: c.label, hint: c.hint }));
+}
+export function selectedOptionalCapabilityIds(outcome, answers = {}, _request = "") {
+    const candidates = OPTIONAL_CAPABILITIES.filter((capability) => capability.outcomes.includes(outcome));
+    if (candidates.length === 0) {
+        return [];
+    }
+    const answerText = [answers.feed_optional_capabilities, answers.optional_capabilities, answers.selected_capabilities]
+        .filter(Boolean)
+        .join("\n");
+    const normalized = answerText.toLowerCase();
+    if (!normalized.trim() || /\b(none|no optional|default only)\b/.test(normalized)) {
+        return [];
+    }
+    const selected = new Set();
+    for (const capability of candidates) {
+        if (normalized.includes(capability.id.toLowerCase()) || capability.aliases.some((alias) => alias.test(answerText))) {
+            selected.add(capability.id);
+        }
+    }
+    return [...selected].sort();
+}
+export function assessSelectedOptionalCapabilities(source, outcome, selectedIds = []) {
+    const selected = [...new Set(selectedIds.map((id) => id.trim()).filter(Boolean))].sort();
+    if (selected.length === 0) {
+        return null;
+    }
+    const applicable = new Map(OPTIONAL_CAPABILITIES.filter((capability) => capability.outcomes.includes(outcome)).map((capability) => [capability.id, capability]));
+    const passed = [];
+    const failed = [];
+    const unknown = [];
+    for (const id of selected) {
+        const capability = applicable.get(id);
+        if (!capability) {
+            unknown.push(id);
+            continue;
+        }
+        const present = capability.sensors.filter((sensor) => sensor.regex.test(source)).map((sensor) => sensor.label);
+        const missing = capability.sensors.filter((sensor) => !sensor.regex.test(source)).map((sensor) => sensor.label);
+        if (missing.length === 0) {
+            passed.push({ id, label: capability.label, present });
+        }
+        else {
+            failed.push({ id, label: capability.label, missing, hint: capability.hint });
+        }
+    }
+    return {
+        outcome,
+        selected,
+        passed,
+        failed,
+        unknown,
+        note: "Selected optional capabilities are enforced only after the user or host agent opts in through `feed_optional_capabilities`. They are source sensors, not baseline compliance rules.",
+    };
 }
 /** Pure assessment over already-read source text. */
 export function assessCompleteness(source, outcome) {
-    const caps = CAPABILITIES.filter((c) => c.outcomes.includes(outcome));
+    const caps = baselineCapabilities(outcome);
     const optOuts = new Map();
+    const invalidOptOuts = new Map();
     const omitPattern = /vise:\s*scope-omit\s+([a-z][\w-]*)\s*(?:[—:|-]+\s*(.*))?/gi;
     let match;
     while ((match = omitPattern.exec(source)) !== null) {
-        optOuts.set(match[1].toLowerCase(), (match[2] ?? "").trim() || "no reason given");
+        const id = match[1].toLowerCase();
+        const reason = (match[2] ?? "").trim();
+        if (reason) {
+            optOuts.set(id, reason);
+            invalidOptOuts.delete(id);
+        }
+        else if (!optOuts.has(id)) {
+            invalidOptOuts.set(id, "scope-omit marker must include a reason");
+        }
     }
     const present = [];
     const missing = [];
     const optedOut = [];
+    const invalid = [];
     for (const cap of caps) {
         if (optOuts.has(cap.id)) {
             optedOut.push({ id: cap.id, reason: optOuts.get(cap.id) });
@@ -392,10 +511,18 @@ export function assessCompleteness(source, outcome) {
             present.push({ id: cap.id, label: cap.label });
         }
         else {
-            missing.push({ id: cap.id, label: cap.label, hint: cap.hint });
+            const invalidReason = invalidOptOuts.get(cap.id);
+            if (invalidReason) {
+                invalid.push({ id: cap.id, reason: invalidReason });
+            }
+            missing.push({
+                id: cap.id,
+                label: cap.label,
+                hint: invalidReason ? `${cap.hint}; found scope-omit marker without a reason, so add a reason or implement it` : cap.hint,
+            });
         }
     }
-    return { outcome, present, missing, optedOut, note: ADVISORY_NOTE };
+    return { outcome, present, missing, optedOut, invalidOptOuts: invalid, note: ADVISORY_NOTE };
 }
 // ── Bounded source read (advisory; perf-bounded like the design check scan) ──
 const SCAN_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".dart", ".kt", ".java", ".swift", ".vue"]);
@@ -403,9 +530,15 @@ const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", "ou
 const MAX_FILES = 1500;
 const MAX_FILE_BYTES = 1_000_000;
 export async function assessProjectCompleteness(root, outcome) {
-    if (CAPABILITIES.every((c) => !c.outcomes.includes(outcome))) {
+    if (baselineCapabilities(outcome).length === 0) {
         return null; // outcome has no completeness checklist
     }
+    return assessCompleteness(await readProjectSource(root), outcome);
+}
+export async function assessProjectSelectedOptionalCapabilities(root, outcome, selectedIds = []) {
+    return assessSelectedOptionalCapabilities(await readProjectSource(root), outcome, selectedIds);
+}
+async function readProjectSource(root) {
     const resolved = path.resolve(root);
     const parts = [];
     const stack = [resolved];
@@ -443,5 +576,5 @@ export async function assessProjectCompleteness(root, outcome) {
             }
         }
     }
-    return assessCompleteness(parts.join("\n"), outcome);
+    return parts.join("\n");
 }

package/dist/server.js

@@ -218,8 +218,8 @@ async function handleCli(args) {
             return "exit";
         }
         if (command === "init") {
-            assertOnlyKnownFlags(args, ["request", "surface", "surface-path"], "init");
-            console.log(JSON.stringify(await initCompliance(positionalRepoPath(args.slice(1)), requiredFlagValue(args, "request", "init requires --request."), flagValue(args, "surface") ?? flagValue(args, "surface-path")), null, 2));
+            assertOnlyKnownFlags(args, ["request", "surface", "surface-path", "answer"], "init");
+            console.log(JSON.stringify(await initCompliance(positionalRepoPath(args.slice(1)), requiredFlagValue(args, "request", "init requires --request."), flagValue(args, "surface") ?? flagValue(args, "surface-path"), keyValueFlag(args, "answer")), null, 2));
             return "exit";
         }
         if (command === "check") {
@@ -501,7 +501,8 @@ Usage:
 Initialize the local sp-vise compliance sidecar for one integration request.
 
 Usage:
-  vise init [repoPath] --request "Add a social feed" [--surface apps/web]`;
+  vise init [repoPath] --request "Add a social feed" [--surface apps/web]
+  vise init [repoPath] --request "Add a social feed" --answer feed_optional_capabilities=post-poll-creation`;
     }
     if (command === "check") {
         return `${packageName} check

package/dist/tools/compliance.js

@@ -2,7 +2,7 @@ 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 { assessProjectCompleteness, assessProjectSelectedOptionalCapabilities, selectedOptionalCapabilityIds, } from "../capabilities.js";
 import { classifyOutcome } from "../outcomes.js";
 import { objectInput, optionalStringField, stringField, textResult } from "../types.js";
 import { packageVersion } from "../version.js";
@@ -21,13 +21,18 @@ 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" },
+            },
         },
         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)));
     },
 };
 export const checkComplianceTool = {
@@ -46,6 +51,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,10 +242,11 @@ 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 = {}) {
     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
@@ -254,6 +272,7 @@ 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);
@@ -282,6 +301,7 @@ 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 }),
         ...(warnings.length > 0 && { warnings }),
         nextStep: "Run vise check, then implement until rules pass deterministically or are attested.",
     };
@@ -454,31 +474,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 opted-out require an explicit decision
+    // 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 — any capability can be excluded with a recorded reason. Failure to assess is silently ignored.
+    // 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) {

package/dist/tools/integration.js

@@ -2,7 +2,7 @@ import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import { BROAD_SOCIAL_REGEX, DESIGN_REGEX, classifyOutcome, getOutcomeDefinition, hasAnswer, planContextFor, } from "../outcomes.js";
 import { objectInput, optionalStringField, stringField, textResult } from "../types.js";
-import { capabilityChecklist } from "../capabilities.js";
+import { capabilityChecklist, optionalCapabilityChecklist, selectedOptionalCapabilityIds } from "../capabilities.js";
 import { applicableComplianceRuleSummaries } from "./compliance.js";
 import { buildDesignBrief, readDesignContract } from "./design.js";
 import { sdkVersionGuidance } from "./sdkVersion.js";
@@ -122,6 +122,7 @@ async function buildIntegrationPlan(repoPath, request, surfacePath, answers = {}
         evidencePolicy: "Every implementation step must cite at least one detected file, docs page, validator rule, or required user input. If evidence is missing, stop and ask the user instead of inventing details.",
         designContract: designContract ? designContractGuidance(designContract) : undefined,
         completenessChecklist: completenessChecklistFor(outcome),
+        optionalCapabilities: optionalCapabilitiesFor(outcome, ctx.answers, request),
         sdkVersion,
     };
 }
@@ -139,6 +140,18 @@ function completenessChecklistFor(outcome) {
         capabilities: items,
     };
 }
+function optionalCapabilitiesFor(outcome, answers, request) {
+    const choices = optionalCapabilityChecklist(outcome);
+    if (choices.length === 0) {
+        return undefined;
+    }
+    return {
+        answerId: "feed_optional_capabilities",
+        note: "Optional feed capabilities are feed-forward choices, not baseline compliance. If the user opts in, pass the selected ids through `--answer feed_optional_capabilities=<id[,id]>` on `vise plan` and `vise init`; `vise check` will then run source sensors for those selected capabilities.",
+        choices,
+        selected: selectedOptionalCapabilityIds(outcome, answers, request),
+    };
+}
 // Build advisory UI-generation guidance from an extracted design contract.
 // Declared tokens are surfaced with their custom-property name (so the agent
 // references `var(--x)` / maps it per platform); inferred tokens carry their
@@ -216,6 +229,16 @@ function intakeFor(ctx, outcomeQuestions, outcome, brief) {
             blocksImplementationWhenMissing: false,
         });
     }
+    if (outcome === "add-feed" && optionalCapabilityChecklist(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(outcome).map((capability) => capability.id)],
+        });
+    }
     const remainingBlocking = questions.filter((question) => question.blocksImplementationWhenMissing).length;
     return {
         status: remainingBlocking > 0 ? "needs-clarification" : "ready",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/social-plus-vise",
-  "version": "0.14.3",
+  "version": "0.14.5",
   "description": "Skill-guided deterministic CLI for social.plus SDK integration assistance.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",

package/skills/social-plus-vise/SKILL.md

@@ -37,7 +37,7 @@ vise run-sensors .
 
 **`vise check .` is mandatory, not optional. You are not done until it passes or every finding is explicitly attested.** Running `vise plan` and `vise inspect` but skipping `vise check` is the most common failure mode — it means the deterministic catch-net never ran and known-bad patterns ship. When you read a `vise plan`, do not truncate it (`| head` drops the implementation steps); read the full `implementationSteps` array.
 
-**Completeness is also a stop condition.** When `vise check .` exits with status `completeness-gap` (exit code 5), one or more expected capabilities are neither implemented nor opted-out. For each missing item: either implement it, or place `// vise: scope-omit <id> — <reason>` in the relevant source file and re-run `vise check .` to confirm it exits 0. A missing capability that is neither built nor opted-out is a silent drop — the check will not pass green until every capability is resolved.
+**Baseline completeness is also a stop condition.** When `vise check .` exits with status `completeness-gap` (exit code 5), one or more baseline capabilities are neither implemented nor opted-out. For add-feed, the baseline capability is pagination. For each missing item: either implement it, or place `// vise: scope-omit <id> — <reason>` in the relevant source file and re-run `vise check .` to confirm it exits 0. A missing baseline capability that is neither built nor opted-out is a silent drop — the check will not pass green until every baseline capability is resolved.
 
 Treat Vise runtime smoke sensors as real validation. For TypeScript/React Native projects, `vise run-sensors` may include `TypeScript SDK import smoke`; if it fails, the SDK package does not resolve from the host project runtime and the integration is not done.
 
@@ -244,13 +244,15 @@ vise plan . --request "<feed or post request>"
 
 Require a concrete target from the app: current user feed, selected community, selected channel, or another user-provided domain object. Do not hardcode random target IDs.
 
-**Decide engagement scope explicitly — Vise authors the checklist, you subtract with a reason.** `vise plan` returns a `completenessChecklist` (the canonical capabilities for the outcome, e.g. comments, reactions, pagination, polls, media, moderation) and `vise check` reports each as present / missing / opted-out. The check gate never blocks on completeness (to avoid false positives from legitimately scope-limited integrations), but **missing items that are neither built nor opted-out are silent drops — treat them as a stop condition, not a suggestion.** For each capability: build it, or explicitly opt out with a recorded marker in the code so the omission is reviewable, not accidental:
+**Decide engagement scope explicitly — Vise authors the baseline checklist, and optional feed capabilities require user opt-in.** `vise plan` returns a `completenessChecklist` for baseline capabilities (for add-feed today: pagination) and an `optionalCapabilities` block for feed-forward choices such as image upload, poll creation, and edit post. `vise check` reports baseline capabilities as present / missing / opted-out. Missing baseline items that are neither built nor validly opted-out produce `completeness-gap` (exit code 5), because they are silent drops. For each baseline capability: build it, or explicitly opt out with a recorded marker in the code so the omission is reviewable, not accidental:
 
 ```
-// vise: scope-omit poll — text + image feed only; polls disabled for this tenant
+// vise: scope-omit pagination — single-screen feed; no load-more affordance in this integration
 ```
 
-Do not report the integration complete while any capability is `missing`. Re-run `vise check .` after placing a scope-omit marker to confirm it moves from `missing` to `opted-out`.
+Do not report the integration complete while any baseline capability is `missing`. A scope-omit marker must include a reason after the capability id; otherwise it remains invalid and the capability still counts as missing. Re-run `vise check .` after placing a scope-omit marker to confirm it moves from `missing` to `opted-out`.
+
+Optional feed choices are not baseline compliance. If the user explicitly chooses one during planning, carry that decision into init, for example `vise init . --request "Add a social feed" --answer feed_optional_capabilities=post-poll-creation`. Once recorded, `vise check .` runs the selected source sensors and exits `selected-capability-failures` (exit code 6) until the selected capability is implemented.
 
 **Demo wiring (when the app needs to compile before the real target source exists):** even at the top-level `App` / `MaterialApp` / `_app.tsx` / `AppDelegate` wiring site, do not pass a literal string. Use the host platform's compile-time env channel so the rule sees no string literal at the call site: