@amityco/social-plus-vise 1.5.0 → 1.7.0

package/dist/tools/compliance.js

@@ -416,6 +416,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 +484,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 +507,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 +891,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) {
@@ -996,6 +1025,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) {
@@ -1153,22 +1203,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.",
             };
         }
@@ -1668,6 +1719,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) {
@@ -2300,6 +2374,9 @@ export const FILE_SCOPABLE_SENSOR_SUFFIXES = new Set([
     "live-collection.api-mismatch",
     "story.live-collection",
     "search.live-collection",
+    "message-search.live-collection",
+    "channel-archive.live-collection",
+    "for-you-feed.live-collection",
     "notification-tray.live-collection",
     "event.live-collection",
     "blocked-users.live-collection",
@@ -2432,6 +2509,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(),
     };
@@ -2788,6 +2866,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) {
@@ -2824,6 +2904,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);
@@ -2838,19 +3041,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 {
@@ -2859,9 +3061,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;
+    }
+}

package/dist/tools/project.js

@@ -472,6 +472,9 @@ async function validateAndroid(root) {
     findings.push(...validateLiveCollectionApiMismatch(root, "android", sourceContent));
     findings.push(...validateStories(root, "android", sourceContent));
     findings.push(...validateSearch(root, "android", sourceContent));
+    findings.push(...validateMessageSearch(root, "android", sourceContent));
+    findings.push(...validateChannelArchive(root, "android", sourceContent));
+    findings.push(...validateForYouFeed(root, "android", sourceContent));
     findings.push(...validateNotificationTray(root, "android", sourceContent));
     findings.push(...validateMembershipList(root, "android", sourceContent));
     findings.push(...validateEvents(root, "android", sourceContent));
@@ -601,6 +604,8 @@ async function validateFlutter(root) {
     findings.push(...validateLiveCollectionApiMismatch(root, "flutter", dartContent));
     findings.push(...validateStories(root, "flutter", dartContent));
     findings.push(...validateSearch(root, "flutter", dartContent));
+    findings.push(...validateMessageSearch(root, "flutter", dartContent));
+    findings.push(...validateChannelArchive(root, "flutter", dartContent));
     findings.push(...validateMembershipList(root, "flutter", dartContent));
     findings.push(...validateBlockedUsers(root, "flutter", dartContent));
     findings.push(...validatePollVoteStatusGuard(root, "flutter", dartContent));
@@ -732,6 +737,9 @@ async function validateTypeScript(root, platform) {
     findings.push(...validateLiveCollectionApiMismatch(root, platform, sourceContent));
     findings.push(...validateStories(root, platform, sourceContent));
     findings.push(...validateSearch(root, platform, sourceContent));
+    findings.push(...validateMessageSearch(root, platform, sourceContent));
+    findings.push(...validateChannelArchive(root, platform, sourceContent));
+    findings.push(...validateForYouFeed(root, platform, sourceContent));
     findings.push(...validateNotificationTray(root, platform, sourceContent));
     findings.push(...validateMembershipList(root, platform, sourceContent));
     findings.push(...validateEvents(root, platform, sourceContent));
@@ -1862,6 +1870,200 @@ function validateSearch(root, platform, sourceContent) {
     }
     return findings;
 }
+function validateMessageSearch(root, platform, sourceContent) {
+    const findings = [];
+    const ruleId = `${platform}.message-search.live-collection`;
+    const MESSAGE_SEARCH_QUERY_PATTERNS = [
+        /\bsearchMessages?\b/,
+        /\bAmityMessageSearchQuery\b/,
+        /\bAmityMessageSearchOptions\b/,
+        /\bSearchMessageBuilder\b/,
+        /\bSearchMessageLiveCollection\b/,
+    ];
+    const LIST_UI_PATTERNS = [
+        /\bmap\s*\(/,
+        /\bFlatList\b/,
+        /\bListView\b/,
+        /\bRecyclerView\b/,
+        /\bLazyColumn\b/,
+        /\bLazyRow\b/,
+        /\bLazyVerticalGrid\b/,
+        /\bLazyVerticalStaggeredGrid\b/,
+        /\bForEach\b/,
+        /\bList\s*\(/,
+        /\bsubmitList\b/,
+        /\btableView\b/,
+        /\bcollectionView\b/
+    ];
+    const REACTIVE_MARKERS = [
+        /\bgetLiveCollection\b/,
+        /\bobserve\b/,
+        /\bobserveOnce\b/,
+        /\blisten\b/,
+        /\bonData\b/,
+        /\bStreamBuilder\b/,
+        /\bLiveData\b/,
+        /\bMutableLiveData\b/,
+        /\bMediatorLiveData\b/,
+        /collectAsState/,
+        /observeAsState/,
+        /Amity\w*Flow\b/,
+        /\bPagingData\b/,
+        /LazyPagingItems/,
+        /collectAsLazyPagingItems/,
+        /\.on\s*\(\s*['"]data[A-Z]/,
+        /\$snapshots\b/,
+        /\bPagingController\b/,
+        /\bgetPagingData\b/,
+        /\bsearchMessages?\s*\(\s*\{[^{}]*\}\s*,\s*(?:\w+|\([^)]*\)\s*=>|function\b|async\b)/,
+        /\/\/\s*vise:\s*one-shot query/i
+    ];
+    for (const [file, content] of sourceContent) {
+        const rel = relativeFile(root, file);
+        if (path.basename(file).endsWith('.d.ts'))
+            continue;
+        const hasSearchQuery = MESSAGE_SEARCH_QUERY_PATTERNS.some((p) => p.test(content));
+        if (hasSearchQuery) {
+            const hasListUI = LIST_UI_PATTERNS.some((p) => p.test(content));
+            if (hasListUI) {
+                const reactiveSurface = commentStripped(file, platform, content);
+                const hasReactivity = /\/\/\s*vise:\s*one-shot query/i.test(content) || REACTIVE_MARKERS.some((p) => p.test(reactiveSurface));
+                if (!hasReactivity) {
+                    findings.push(finding(ruleId, "warning", `A message search (searchMessage/searchMessages) renders a list but no reactive/paginated markers (observe, the (params, callback) live form, PagingData, PagingController) were found in the same file.`, rel, "Render message-search results from the reactive, paginated Search Message LiveCollection so the list live-updates and pages. Use the live callback (TS/RN: searchMessage(params, callback)), observe the collection (iOS searchMessages(options:) + .observe / Android AmityMessageSearchQuery PagingData), or wire a PagingController with SearchMessageLiveCollection (Flutter). If a one-shot single-page search is truly intended, add comment // vise: one-shot query."));
+                }
+            }
+        }
+    }
+    return findings;
+}
+function validateChannelArchive(root, platform, sourceContent) {
+    const findings = [];
+    const ruleId = `${platform}.channel-archive.live-collection`;
+    const ARCHIVE_QUERY_PATTERNS = [
+        /\bgetArchivedChannels\b/,
+        /\bgetArchivedChannelIds\b/,
+    ];
+    const LIST_UI_PATTERNS = [
+        /\bmap\s*\(/,
+        /\bFlatList\b/,
+        /\bListView\b/,
+        /\bRecyclerView\b/,
+        /\bLazyColumn\b/,
+        /\bLazyRow\b/,
+        /\bLazyVerticalGrid\b/,
+        /\bLazyVerticalStaggeredGrid\b/,
+        /\bForEach\b/,
+        /\bList\s*\(/,
+        /\bsubmitList\b/,
+        /\btableView\b/,
+        /\bcollectionView\b/
+    ];
+    const REACTIVE_MARKERS = [
+        /\bgetLiveCollection\b/,
+        /\bobserve\b/,
+        /\bobserveOnce\b/,
+        /\blisten\b/,
+        /\bonData\b/,
+        /\bStreamBuilder\b/,
+        /\bLiveData\b/,
+        /\bMutableLiveData\b/,
+        /\bMediatorLiveData\b/,
+        /collectAsState/,
+        /observeAsState/,
+        /Amity\w*Flow\b/,
+        /\bPagingData\b/,
+        /LazyPagingItems/,
+        /collectAsLazyPagingItems/,
+        /\.on\s*\(\s*['"]data[A-Z]/,
+        /\$snapshots\b/,
+        /\bPagingController\b/,
+        /\bgetPagingData\b/,
+        /\bgetArchivedChannels\s*\(\s*\{[^{}]*\}\s*,\s*(?:\w+|\([^)]*\)\s*=>|function\b|async\b)/,
+        /\/\/\s*vise:\s*one-shot query/i
+    ];
+    for (const [file, content] of sourceContent) {
+        const rel = relativeFile(root, file);
+        if (path.basename(file).endsWith('.d.ts'))
+            continue;
+        const hasArchiveQuery = ARCHIVE_QUERY_PATTERNS.some((p) => p.test(content));
+        if (hasArchiveQuery) {
+            const hasListUI = LIST_UI_PATTERNS.some((p) => p.test(content));
+            if (hasListUI) {
+                const reactiveSurface = commentStripped(file, platform, content);
+                const hasReactivity = /\/\/\s*vise:\s*one-shot query/i.test(content) || REACTIVE_MARKERS.some((p) => p.test(reactiveSurface));
+                if (!hasReactivity) {
+                    findings.push(finding(ruleId, "warning", `An archived-channels view (getArchivedChannels / getArchivedChannelIds) renders a list but no reactive markers (observe, the (params, callback) live form, PagingData, PagingController) were found in the same file.`, rel, "Render the archived-channels view from the getArchivedChannels LiveCollection (subscribe via its callback / observe and re-render on updates, dispose on unmount) rather than a one-shot getArchivedChannelIds fetch, so the list updates as channels are archived or unarchived. If a one-shot snapshot is truly intended, add comment // vise: one-shot query."));
+                }
+            }
+        }
+    }
+    return findings;
+}
+function validateForYouFeed(root, platform, sourceContent) {
+    const findings = [];
+    if (platform === "flutter")
+        return findings;
+    const ruleId = `${platform}.for-you-feed.live-collection`;
+    const FORYOU_QUERY_PATTERNS = [
+        /\bgetForYouFeed\b/,
+    ];
+    const LIST_UI_PATTERNS = [
+        /\bmap\s*\(/,
+        /\bFlatList\b/,
+        /\bListView\b/,
+        /\bRecyclerView\b/,
+        /\bLazyColumn\b/,
+        /\bLazyRow\b/,
+        /\bLazyVerticalGrid\b/,
+        /\bLazyVerticalStaggeredGrid\b/,
+        /\bForEach\b/,
+        /\bList\s*\(/,
+        /\bsubmitList\b/,
+        /\btableView\b/,
+        /\bcollectionView\b/
+    ];
+    const REACTIVE_MARKERS = [
+        /\bgetLiveCollection\b/,
+        /\bobserve\b/,
+        /\bobserveOnce\b/,
+        /\blisten\b/,
+        /\bonData\b/,
+        /\bStreamBuilder\b/,
+        /\bLiveData\b/,
+        /\bMutableLiveData\b/,
+        /\bMediatorLiveData\b/,
+        /collectAsState/,
+        /observeAsState/,
+        /Amity\w*Flow\b/,
+        /\bPagingData\b/,
+        /LazyPagingItems/,
+        /collectAsLazyPagingItems/,
+        /\.on\s*\(\s*['"]data[A-Z]/,
+        /\$snapshots\b/,
+        /\bPagingController\b/,
+        /\bgetPagingData\b/,
+        /\bgetForYouFeed\s*\(\s*\{[^{}]*\}\s*,\s*(?:\w+|\([^)]*\)\s*=>|function\b|async\b)/,
+        /\bgetForYouFeed\s*\(\s*(?:\([^)]*\)\s*=>|\w+\s*=>|function\b|async\b)/,
+        /\/\/\s*vise:\s*one-shot query/i
+    ];
+    for (const [file, content] of sourceContent) {
+        const rel = relativeFile(root, file);
+        if (path.basename(file).endsWith('.d.ts'))
+            continue;
+        const hasForYouQuery = FORYOU_QUERY_PATTERNS.some((p) => p.test(content));
+        if (hasForYouQuery) {
+            const hasListUI = LIST_UI_PATTERNS.some((p) => p.test(content));
+            if (hasListUI) {
+                const reactiveSurface = commentStripped(file, platform, content);
+                const hasReactivity = /\/\/\s*vise:\s*one-shot query/i.test(content) || REACTIVE_MARKERS.some((p) => p.test(reactiveSurface));
+                if (!hasReactivity) {
+                    findings.push(finding(ruleId, "warning", `A For-You feed (getForYouFeed) renders a list but no reactive markers (observe, the (params, callback) live form, PagingData, PagingController) were found in the same file.`, rel, "Query the personalized feed via getForYouFeed and OBSERVE it as a live collection (subscribe / .observe / PagingData — never a one-shot fetch-and-map), so the feed updates as ranking and freshness change. Gate on getForYouFeedSetting and, when disabled, fall back to the global feed rather than rendering empty. If a one-shot snapshot is truly intended, add comment // vise: one-shot query."));
+                }
+            }
+        }
+    }
+    return findings;
+}
 function validateNotificationTray(root, platform, sourceContent) {
     const findings = [];
     const ruleId = `${platform}.notification-tray.live-collection`;
@@ -3162,6 +3364,9 @@ async function validateIos(root) {
     findings.push(...validateLiveCollectionApiMismatch(root, "ios", swiftContent));
     findings.push(...validateStories(root, "ios", swiftContent));
     findings.push(...validateSearch(root, "ios", swiftContent));
+    findings.push(...validateMessageSearch(root, "ios", swiftContent));
+    findings.push(...validateChannelArchive(root, "ios", swiftContent));
+    findings.push(...validateForYouFeed(root, "ios", swiftContent));
     findings.push(...validateNotificationTray(root, "ios", swiftContent));
     findings.push(...validateMembershipList(root, "ios", swiftContent));
     findings.push(...validateEvents(root, "ios", swiftContent));