@amityco/social-plus-vise 1.3.0 → 1.4.0

package/dist/outcomes.js

@@ -1,3 +1,4 @@
+import { experienceBundleFor } from "./experience.js";
 export function hasAnswer(answers, id) {
     const value = answers[id];
     return typeof value === "string" && value.trim() !== "";
@@ -28,12 +29,54 @@ const LIVE_PATTERNS = [
     EVENT_REGEX,
     LIVESTREAM_REGEX,
 ];
+export const PLATFORM_FEATURE_GAPS = [
+    {
+        feature: "Scheduled events & RSVP",
+        match: EVENT_REGEX,
+        exclude: /\bevents?\s+(?:listener|listeners|handler|handlers|subscription|subscriptions|emitter|emitters|bus|stream|streams|callback|callbacks)\b|\b(?:real-?time|analytics|tracking|telemetry)\s+events?\b/i,
+        unavailableOn: ["flutter"],
+        availableOn: ["typescript", "ios", "android"],
+        objectIds: ["event", "rsvp"],
+        sdkSource: "social-plus-sdk/social/events/overview",
+        guidance: "The social.plus Flutter SDK does not expose scheduled-event creation, query, management, or RSVP APIs — events are available on the iOS, Android, and TypeScript SDKs. Do not invent an AmityEventRepository / event query in Dart. Choose an alternative: (a) model events as posts in a dedicated community and carry date/RSVP details in post metadata, (b) call the server-side Event REST API (api-reference/event) from your backend and surface results through your own endpoint, or (c) build the event surface on a supported platform (iOS, Android, or TypeScript/web).",
+    },
+    {
+        feature: "Room-based livestreaming (broadcast & room management)",
+        match: LIVESTREAM_REGEX,
+        exclude: /\blive\s+chat\b|\bvideo\s+(?:call|calling|conferenc)\w*\b/i,
+        unavailableOn: ["flutter"],
+        availableOn: ["typescript", "ios", "android"],
+        objectIds: ["livestream"],
+        sdkSource: "use-cases/social/livestream/go-live-and-room-management",
+        guidance: "Room-based livestreaming — broadcasting, going live, and room management (RoomRepository.createRoom / getRoom / getRooms / stopRoom) — is NOT in the social.plus Flutter SDK; it is available on the iOS, Android, and TypeScript/web SDKs. The Flutter SDK exposes only the DEPRECATED legacy Stream API (StreamRepository.getStream) for VIEWING existing stream posts — there is no Room API in Dart, so do not invent RoomRepository / createRoom. Options: (a) build the broadcast/host livestream experience on a supported platform (iOS, Android, or TypeScript/web), (b) on Flutter, render an existing legacy stream post read-only via StreamRepository.getStream(streamId) (deprecated — exposes title/status/isLive only), or (c) embed a web livestream view.",
+    },
+];
+export function platformFeatureGapsFor(request, platform) {
+    return PLATFORM_FEATURE_GAPS.filter((gap) => gap.unavailableOn.includes(platform) &&
+        gap.match.test(request) &&
+        !(gap.exclude && gap.exclude.test(request)));
+}
+export function platformFeatureGapsForObjects(objectIds, platform) {
+    const present = new Set(objectIds);
+    const out = [];
+    for (const gap of PLATFORM_FEATURE_GAPS) {
+        if (!gap.unavailableOn.includes(platform) || !gap.objectIds)
+            continue;
+        const objects = gap.objectIds.filter((id) => present.has(id));
+        if (objects.length > 0)
+            out.push({ gap, objects });
+    }
+    return out;
+}
 const FEED_PATTERNS = [
     /\b(social feature|social features|feed|timeline|post list|news feed|create post|create a post|post creation|compose post)\b/,
 ];
 const COMMENT_PATTERNS = [
     /\b(comment|comments|reply|replies|thread|discussion thread|comment composer)\b/,
 ];
+const REACTION_PATTERNS = [
+    /\b(reaction|reactions|react|like|likes|emoji react|upvote)\b/,
+];
 const MODERATION_OUTCOME_PATTERNS = [
     /\b(moderation|report|flag|block user|mute user|hide content|abuse|review queue|admin queue)\b/,
 ];
@@ -61,7 +104,7 @@ const NOTIFICATION_PATTERNS = [
 const TROUBLESHOOT_PATTERNS = [/\b(error|broken|crash|not working|fail|timeout|401|403)\b/];
 const VALIDATE_PATTERNS = [/\b(validate|check|correct|setup right|initiali[sz])\b/];
 const SETUP_PATTERNS = [/\b(setup|set up|install|integrate|wire|configure|init sdk|sdk setup|session lifecycle)\b|initialise?s?\b/];
-export const BROAD_SOCIAL_REGEX = /\b(nice|social features|social feature|engagement|community experience)\b|\b(?:feed|post|posts|comments?)\b[\s\S]{0,160}\b(?:chat|messaging|profile|followers?|following|social graph)\b|\b(?:chat|messaging|profile|followers?|following|social graph)\b[\s\S]{0,160}\b(?:feed|post|posts|comments?)\b/i;
+export const BROAD_SOCIAL_REGEX = /\b(nice|social features|social feature|engagement|community experience)\b|\b(?:feeds?|post|posts|comments?)\b[\s\S]{0,160}\b(?:chat|messaging|profile|followers?|following|social graph)\b|\b(?:chat|messaging|profile|followers?|following|social graph)\b[\s\S]{0,160}\b(?:feeds?|post|posts|comments?)\b/i;
 export const DESIGN_REGEX = /\bdesign token|design tokens|theme|same design|design system|brand/i;
 export function classifyOutcome(request) {
     const normalized = request.toLowerCase();
@@ -111,10 +154,11 @@ export function classifyOutcome(request) {
 }
 export function resolveOutcome(request, answers = {}) {
     const selectedSurface = outcomeFromFeatureSurface(answers.feature_surface);
-    if (selectedSurface && BROAD_SOCIAL_REGEX.test(request)) {
+    const bareOutcome = classifyOutcome(request);
+    if (selectedSurface && (BROAD_SOCIAL_REGEX.test(request) || experienceBundleFor(request) !== undefined || bareOutcome === "unknown")) {
         return selectedSurface;
     }
-    return classifyOutcome(request);
+    return bareOutcome;
 }
 function outcomeFromFeatureSurface(answer) {
     const normalized = (answer ?? "").toLowerCase();
@@ -424,8 +468,11 @@ const setupLiveData = {
         "UI handling for loading, empty, error, insertion, deletion, and modification states",
     ],
     implementationRules: () => [
+        "Gate the live query on a REACTIVE session-readiness signal (observe the session/auth state, seeded synchronously from its current value) so the query (re-)runs when the session becomes active AFTER the view mounts. The consuming surface usually mounts before login resolves; a one-shot readiness check at mount (onAppear / useEffect([]) / initState / onViewCreated) that returns early and never re-fires leaves the surface permanently empty even though it compiles and vise check is green. Render the not-ready and error states as retryable, not a dead end.",
         "Do not replace Live Object or Live Collection observation with polling unless the docs or user explicitly require it.",
         "Always clean up observers/subscriptions when the owning component, screen, ViewModel, or controller is destroyed.",
+        "On iOS/SwiftUI, deinit-based cleanup does NOT run while the owner is retained for the app's lifetime (e.g. a @StateObject view-model in a TabView): for such surfaces prefer .onDisappear / viewWillDisappear so the observer is released when the user leaves the surface, not only when the owner deallocates.",
+        "vise's deterministic events/stories live-collection checks verify reactivity + observer cleanup only and pass on the ABSENCE of a violation (not on positive presence) — independently confirm the surface itself is wired: events need getEvents/getRSVPs + RSVP create/update; stories need getActiveStoriesByTarget + a ring/viewer.",
         "Handle loading and error states from the live data API before rendering data as ready.",
         "For collections, use insertion/deletion/modification changes for targeted UI updates instead of assuming a full list replacement.",
     ],
@@ -442,7 +489,11 @@ const setupLiveData = {
             ],
         },
         {
-            step: "Implement the subscription in the owning lifecycle scope and render loading, empty, error, and data states.",
+            step: "Drive the subscription off a reactive session-readiness signal (observe session/auth state, seeded synchronously from the current value) so the query (re-)runs when the session becomes active — the surface usually mounts before login resolves, and a one-shot readiness check at mount that never re-fires leaves it permanently empty.",
+            evidence: ["social-plus-sdk/getting-started/authentication", liveDataPlatformPath(ctx.platform)],
+        },
+        {
+            step: "Implement the subscription in the owning lifecycle scope and render loading, empty, error, and data states (with not-ready and error states rendered as retryable, not a dead end).",
             evidence: ["requiredInputs.lifecycle owner for subscribe/unsubscribe cleanup", "implementationRules.loading-error-states"],
         },
         {
@@ -521,7 +572,7 @@ const addFeed = {
         questions.push({
             id: "feed_scope",
             question: "What scope should the first feed use?",
-            why: "Feed APIs and query shape depend on whether the content is global, user-specific, or community-specific.",
+            why: "Feed APIs and query shape depend on whether the content is global, user-specific, or community-specific. A general social feed defaults to global (app-wide); choose community only when the request is explicitly community-scoped — and note a community feed additionally requires the user to be a member before they can post.",
             required: true,
             blocksImplementationWhenMissing: true,
             options: ["global", "user", "community"],
@@ -529,10 +580,10 @@ const addFeed = {
         questions.push({
             id: "feed_target",
             question: "What concrete feed target should reads and post creation use?",
-            why: "A coding agent must not invent community IDs, user timeline targets, or global feed assumptions. If this is a community feed, provide the existing communityId or the flow that lets users select/create one.",
+            why: "Prefer the global (app-wide) feed or the current user's feed for a general social feed — both are ID-free, need no membership to post, and are the safe default. The no-invent rule applies to IDs: never invent a communityId, targetId, or feedId. Choose a community target only when the request names a community-scoped surface, and then source it from route/app state, SDK discovery, user selection, or a create flow.",
             required: true,
             blocksImplementationWhenMissing: true,
-            options: ["existing communityId", "current user's feed", "selected user's feed", "app-defined/global feed", "ask user at runtime"],
+            options: ["app-defined/global feed", "current user's feed", "selected user's feed", "community selected from route/discovery/create flow", "ask user at runtime"],
         });
         questions.push({
             id: "target_screen_or_route",
@@ -565,6 +616,14 @@ const addFeed = {
             blocksImplementationWhenMissing: false,
             options: ["all SDK-available creation types", "text only", "text + media", "text + media + poll", "custom subset"],
         });
+        questions.push({
+            id: "auth_secure_mode",
+            question: "Is this integration production-bound (secure-mode auth with a server-issued token) or dev/testing only (unsecure auth, no token)?",
+            why: "Unsecure (development) auth — login without a server-issued auth token — lets any client impersonate any user. Fine for local testing, but production MUST use secure mode (a server-issued auth token + a renewal handler). `vise check` surfaces a security advisory whenever the code uses unsecure auth, regardless of this answer.",
+            required: false,
+            blocksImplementationWhenMissing: false,
+            options: ["production — secure mode (server-issued auth token)", "dev/testing only — unsecure auth (no token)"],
+        });
         return filterAnswered(ctx.answers, questions);
     },
     requiredInputs: () => [
@@ -572,7 +631,7 @@ const addFeed = {
         "lifecycle owner for subscribe/unsubscribe cleanup",
         "feature choice: feed, comments, profile, community, chat, notifications, or another social surface",
         "feed scope: global, user, or community",
-        "concrete feed target for reads and post creation: existing communityId, selected user target, current user target, or app-defined feed target",
+        "concrete feed target for reads and post creation: app-defined/global feed, current user feed, selected user target, or community selected from route/discovery/create flow",
         "target screen or route for the feed UI",
     ],
     implementationRules: () => [
@@ -606,6 +665,13 @@ const addFeed = {
                     "social-plus-sdk/core-concepts/realtime-communication/live-objects-collections/overview",
                 ],
             },
+            {
+                step: "Drive the feed query off a reactive session-readiness signal (observe session/auth state, seeded synchronously) so it (re-)runs when the session becomes active — the feed screen usually mounts before login resolves, and a one-shot readiness check at mount (onAppear / useEffect([]) / initState) that never re-fires leaves the feed permanently empty even though it compiles and vise check is green. Render the not-ready and error states as retryable, not a dead end.",
+                evidence: [
+                    "social-plus-sdk/getting-started/authentication",
+                    "requiredInputs.target screen or route",
+                ],
+            },
             {
                 step: "Wire feed pagination: after the initial page loads, expose a 'Load more' action (button, scroll trigger, or infinite-query) that calls the collection's next-page method (loadMore() / nextPage() / onNextPage()). Check hasMore / hasNextPage before showing the control so it disappears when the list is exhausted. Use only opaque cursor tokens returned by the SDK — never construct numeric page offsets. On React/TypeScript, useAmityElement with an infinite-query hook is the idiomatic pattern; on Flutter, a ScrollController + loadMore callback; on Android, PagingData with a LazyColumn scroll trigger.",
                 evidence: [
@@ -633,7 +699,11 @@ const addFeed = {
             { step: "Reuse the host app's existing visual system for the social surface.", evidence: designEvidence },
             { step: "Implement loading, empty, error, and data states.", evidence: ["implementationRules.file-specific edits"] },
             {
-                step: "In post card renderers, resolve each media type from the parent post OR its childrenPosts — in a feed the parent is usually dataType 'text' and the image/video/poll/clip/room rides on a child post. Handle at minimum: text, image, video, file, poll, clip, room. Do not render placeholder labels like '[Image post]' or '[Poll post]'; read the SDK data/accessors and render the actual content. Do NOT gate media on the parent's dataType alone (e.g. post.dataType === 'poll') — that never matches a text parent and the content silently never renders. When rendering the text body itself (post or comment), apply @mention highlights if metadata carries mention entries ({ type: 'user', index, length, userId }, length excluding the '@'): wrap each [index, index + length + 1] span in a styled element and resolve userId to a display name, rather than printing raw text. Pass mentionees on create so mentioned users are notified.",
+                step: "In post card renderers, render the normal post body/description/caption when it is present. Do not make `postId` the primary visible content, and do not invent a required title model: `post.title`, `metadata.title`, or custom-payload title fields are optional product choices, not requirements for a correct social.plus post renderer.",
+                evidence: ["social-plus-sdk/social/content-management/posts/creation/text-post", "capabilityAvailability.available"],
+            },
+            {
+                step: "In post card renderers, resolve each media type from the parent post OR its childrenPosts — in a feed the parent is usually dataType 'text' and the image/video/poll/clip/room rides on a child post. Handle at minimum: text, image, video, file, poll, clip, room. Do not render placeholder labels like '[Image post]' or '[Poll post]'; read the SDK data/accessors and render the actual content. Do NOT gate media on the parent's dataType alone (e.g. post.dataType === 'poll') — that never matches a text parent and the content silently never renders. Read child media from the RESOLVED children accessor (post.childrenPosts, whose entries are Post objects exposing .dataType / getImageInfo() etc.) — or, if you only have the raw `post.children` array, resolve the child-post IDs first (getPost(childId) / getPostByIds). Do NOT cast `post.children` to post objects and read `.dataType` on it: `post.children` holds child-post ID STRINGS, so `.dataType` is undefined there and attachments silently never render — a resolution bug a presence check (the code merely references children) cannot catch. When rendering the text body itself (post or comment), apply @mention highlights if metadata carries mention entries ({ type: 'user', index, length, userId }, length excluding the '@'): wrap each [index, index + length + 1] span in a styled element and resolve userId to a display name, rather than printing raw text. Pass mentionees on create so mentioned users are notified.",
                 evidence: ["social-plus-sdk/social/content-management/posts/creation/text-post", "intake.feed_post_type_scope", "capabilityAvailability.available"],
             },
             {
@@ -658,6 +728,15 @@ const addFeed = {
                     evidence: ["social-plus-sdk/social/content-management/comments/creation/text-comment"],
                 },
             ] : []),
+            ...(REACTION_PATTERNS.some((p) => p.test(ctx.request.toLowerCase())) ? [
+                {
+                    step: "If post cards display a reaction/like control, wire it end to end via ReactionRepository — not a static icon. Add on tap with addReaction(referenceType: 'post', referenceId: post.postId, reactionName) and remove with removeReaction(...) on un-tap (reaction names are case-sensitive and app-defined, e.g. 'like'). Source the count and the current user's state from the post's own reaction data (post.reactionsCount / post.myReactions) so the UI reflects optimistic toggles, and use ReactionRepository.getReactions({ referenceId, referenceType: 'post' }) only when you need the per-user breakdown. A heart/like button with no add/remove wiring (or a hardcoded count) is incomplete — users expect the count to update when they react.",
+                    evidence: [
+                        "social-plus-sdk/core-concepts/content-handling/reactions.mdx",
+                        "social-plus-sdk/core-concepts/realtime-communication/live-objects-collections/overview",
+                    ],
+                },
+            ] : []),
             ...(/notification|bell|tray|inbox/i.test(ctx.request) ? [
                 {
                     step: "If the design includes a notification bell or notification center, implement it with the notificationTray SDK: getNotificationTrayItems (live collection), markItemsSeen on open, and an unread badge sourced from getNotificationTraySeen.",
@@ -700,6 +779,7 @@ const addFeed = {
         "posts.status-filtered",
         "pagination.cursor-opaque",
         "unread.server-synced",
+        "feed.post-body-rendering",
         "feed.rich-post-rendering",
         "feed.rich-post-composer-scope",
         "feed.post-type-scope-explicit",
@@ -711,8 +791,8 @@ const addFeed = {
         "profile.social-counts",
     ],
     stopConditions: (ctx) => filterStops(ctx.answers, [
-        { id: "feed_target", text: "The concrete feed target is unknown; do not invent communityId, targetId, feedId, or global feed assumptions." },
-        { id: "feed_target", text: "If post creation is in scope, the write target must be provided by the user, existing app state, or a customer-owned selection/create flow." },
+        { id: "feed_target", text: "The concrete feed target is unknown; never invent a communityId, targetId, or feedId. For a general social feed, default to the ID-free app-wide global feed or the current user's feed; reserve a specific community/target for an explicitly community-scoped request." },
+        { id: "feed_target", text: "If post creation is in scope, the write target must be a concrete feed — the global or current-user feed (no id, no membership needed), or a community/selected target the user or app state provides (never a hardcoded or invented id)." },
     ]),
     resolvePlan: () => [
         {
@@ -1009,9 +1089,16 @@ const addChat = {
             {
                 id: "channel_source",
                 question: "How are channels/conversations created or discovered?",
-                why: "Avoids invented channel IDs. Channels come from user selection, SDK query, or app logic.",
+                why: "For a chat inbox/browse surface, prefer the current user's own channels — queryChannels()/getChannels with membership:'member' is ID-free and needs no channelId. Creating a 1:1 DM needs a recipient userId and a group needs member userIds (createChannel); opening a specific existing channel uses its channelId from the inbox query. The no-invent rule applies to IDs: never invent a channelId or member list.",
                 required: true,
                 blocksImplementationWhenMissing: true,
+                options: [
+                    "my inbox (queryChannels()/getChannels, membership:'member')",
+                    "user/app selection of an existing channel",
+                    "create 1:1 DM (needs recipient userId)",
+                    "create group channel (needs member userIds)",
+                    "ask user at runtime",
+                ],
             },
             {
                 id: "message_capabilities",
@@ -1081,8 +1168,12 @@ const addChat = {
                 step: "Implement channel query/creation and message observation with lifecycle cleanup.",
                 evidence: ["social-plus-sdk/chat/channels", "social-plus-sdk/chat/messages"],
             },
+            {
+                step: "Drive the channel-list (and message) query off a reactive session-readiness signal (observe session/auth state, seeded synchronously) so it (re-)runs when the session becomes active — the inbox/thread usually mounts before login resolves, and a one-shot readiness check at mount (onAppear / useEffect([]) / initState) that never re-fires leaves chat permanently empty even though it compiles and vise check is green. Render the not-ready and error states as retryable, not a dead end.",
+                evidence: ["social-plus-sdk/getting-started/authentication", "social-plus-sdk/chat/channels"],
+            },
             { step: "Reuse the host app's existing visual system for chat UI.", evidence: designEvidence },
-            { step: "Add message send with error handling and auth gate. Observe each message's syncState and surface failed sends (error state) with a retry/delete affordance instead of rendering optimistic success unconditionally; clean up unrecoverable failures (e.g. deleteFailedMessages) on init.", evidence: ["implementationRules.file-specific edits"] },
+            { step: "Add message send with error handling and auth gate. Observe each message's syncState and surface failed sends (error state) with a retry/delete affordance instead of rendering optimistic success unconditionally; clean up unrecoverable failures (e.g. deleteFailedMessages) on init. For a community channel, sending may require joining first (joinChannel) — surface a join affordance so a non-member's send does not silently fail.", evidence: ["implementationRules.file-specific edits"] },
             { step: "Render the chat inbox from SDK channel queries/live collections. Show unread counts/badges from the SDK on channel rows or the chat tab (`channel.getUnreadCount()`, `getSubChannelsUnreadCount()`, or `AmityCoreClient.observeUserUnread()` / `getTotalChannelUnread()`), and declare channel-list sorting explicitly (typically last activity descending) so recency cannot be reversed by UI defaults.", evidence: ["social-plus-sdk/chat/channels", "intake.chat_inbox_scope", "capabilityAvailability.available"] },
             { step: "Declare message order explicitly with `AmityMessageQuerySortOption.FIRST_CREATED` or `LAST_CREATED` so the message thread cannot invert by relying on defaults.", evidence: ["social-plus-sdk/chat/messages"] },
             { step: "Wire read receipts and typing indicators if required — and mark the channel/messages read on open (channel.markAsRead() / message.markRead()) so the server-side unread count actually decrements. Reading the unread count without ever marking read leaves the badge stuck. Note: the MarkerSyncEngine receipt-sync API (startMessageReceiptSync/stopMessageReceiptSync) is deprecated and being sun-set — track read state with the unread count + markRead() instead.", evidence: ["requiredInputs.read receipt and typing indicator requirements"] },
@@ -1164,10 +1255,17 @@ const addCommunity = {
             },
             {
                 id: "community_target",
-                question: "Where does the community ID come from (route param, selection, or a create flow)?",
-                why: "The coding agent must not invent a communityId; it needs a concrete source.",
+                question: "Where do the communities come from — a discovery query, a create flow, user selection, or an app route/detail state?",
+                why: "For a browse/join or create surface this is ID-free: discover communities via getCommunities/searchCommunities/getRecommendedCommunities/getTrendingCommunities (a query, no communityId), or create one with createCommunity (the id is server-generated). A concrete inbound community object/id belongs only to a detail/members or membership-management surface of a specific existing community — source it from route/app state, user selection, discovery, or the create-flow return value. The no-invent rule applies to IDs: never invent a communityId.",
                 required: true,
                 blocksImplementationWhenMissing: true,
+                options: [
+                    "discovery query (getCommunities/searchCommunities/getRecommendedCommunities/getTrendingCommunities)",
+                    "createCommunity flow (server-generated id)",
+                    "user selection of an existing community",
+                    "route/app state for an existing community",
+                    "ask user at runtime",
+                ],
             },
             {
                 id: "lifecycle_owner",
@@ -1189,7 +1287,7 @@ const addCommunity = {
     requiredInputs: () => [
         "community surface: create, browse/join, detail+members, or membership management",
         "community privacy model: public (instant) vs private (join request)",
-        "concrete community ID source (route param, selection, or create flow)",
+        "natural community source (route/app state, discovery, user selection, or create flow)",
         "lifecycle owner for community/member observer cleanup",
         "target screen or component",
     ],
@@ -1206,8 +1304,8 @@ const addCommunity = {
             : ["requiredInputs.design token or theme source file"];
         return [
             {
-                step: "Confirm the community surface, privacy model, community ID source, and target screen before writing code.",
-                evidence: ["requiredInputs.community surface", "requiredInputs.community privacy model", "requiredInputs.concrete community ID source"],
+                step: "Confirm the community surface, privacy model, natural community source, and target screen before writing code.",
+                evidence: ["requiredInputs.community surface", "requiredInputs.community privacy model", "requiredInputs.natural community source"],
             },
             {
                 step: "Implement the community/member query with the platform's Live Collection (AmityCommunityRepository / getMembers), with cleanup on the lifecycle owner.",
@@ -1230,13 +1328,11 @@ const addCommunity = {
         "community.avatar-from-sdk",
         "community.display-name-from-sdk",
         "moderation.role-gated-action",
-        "validate_setup",
-        "run_sensors",
     ],
     stopConditions: (ctx) => filterStops(ctx.answers, [
         { id: "community_scope", text: "The community surface is unknown; do not assume create vs browse vs members vs management." },
         { id: "community_privacy", text: "The privacy model is unknown; public (instant) and private (join-request) flows differ and must not be guessed." },
-        { id: "community_target", text: "The community ID source is unknown; do not invent a communityId." },
+        { id: "community_target", text: "The natural community source is unknown; do not invent a communityId." },
         { id: "lifecycle_owner", text: "The lifecycle owner for community/member observer cleanup is unknown." },
     ]),
     resolvePlan: () => [
@@ -1291,10 +1387,17 @@ const addFollow = {
             },
             {
                 id: "follow_target",
-                question: "Where does the target userId come from (route param, profile selection, current user)?",
-                why: "The coding agent must not invent a userId; it needs a concrete source.",
+                question: "Whose social graph is this — the current user's own (follower/following lists, counts), another user's profile, or a follow/unfollow button (always another user)?",
+                why: "Scope this to the surface. For the current user's OWN follower/following lists, counts, and relationship state, the ID-free default is getCurrentUser()/client.userId — pass that own id to getFollowInfo (counts) and getFollowers/getFollowings (lists); the SDK routes those to the ID-free /me endpoint when the id is your own, so no external userId is needed. A follow/unfollow BUTTON always targets ANOTHER user, so a concrete target userId is required there (do not default it to self); viewing another user's profile/lists likewise needs that user's id. The no-invent rule applies to IDs: never invent a userId.",
                 required: true,
                 blocksImplementationWhenMissing: true,
+                options: [
+                    "current user, own graph (getCurrentUser()/client.userId — for own lists/counts)",
+                    "another user's profile (their userId — for viewing their lists/counts)",
+                    "follow/unfollow button target (another user's userId — required, never self)",
+                    "route param userId",
+                    "ask user at runtime",
+                ],
             },
             {
                 id: "lifecycle_owner",
@@ -1360,8 +1463,6 @@ const addFollow = {
         "profile.identity-from-sdk",
         "profile.avatar-from-sdk",
         "profile.social-counts",
-        "validate_setup",
-        "run_sensors",
     ],
     stopConditions: (ctx) => filterStops(ctx.answers, [
         { id: "follow_surface", text: "The social-graph surface is unknown; do not assume follow button vs lists vs blocked users." },
@@ -1456,9 +1557,6 @@ const addNotifications = {
         "notifications.tray-live",
         "notifications.mark-seen",
         "notifications.preferences-respected",
-        "this is in-app tray, not push setup",
-        "validate_setup",
-        "run_sensors",
     ],
     stopConditions: (ctx) => filterStops(ctx.answers, [
         { id: "notification_surface", text: "The notification surface is unknown; do not assume tray vs badge vs settings." },

package/dist/productExpectations.js

@@ -1,11 +1,13 @@
 export const PRODUCT_EXPECTATION_TITLES = {
     "feed.target-resolved": "Feed target comes from app state",
+    "feed.source-used": "Feed source uses SDK post APIs",
     "feed.ui-states-present": "Feed renders loading, empty, and error states",
     "feed.pagination-wired": "Feed pagination is wired",
     "moderation.affordance-present": "UGC moderation affordance is present",
     "posts.status-filtered": "Post queries filter unsafe statuses",
     "pagination.cursor-opaque": "Pagination cursors stay opaque",
     "unread.server-synced": "Unread counts use the server-synced stream",
+    "feed.post-body-rendering": "Feed renders post body content",
     "feed.rich-post-rendering": "Feed renders rich post types",
     "feed.rich-post-composer-scope": "Feed composer surfaces rich post scope",
     "feed.post-type-scope-explicit": "Feed post-type scope is explicit",
@@ -45,6 +47,12 @@ const platformBindings = (expectationId, sensorsByPlatform) => Object.entries(se
     platform,
 })));
 export const PRODUCT_EXPECTATION_BINDINGS = [
+    ...platformBindings("feed.source-used", {
+        typescript: "typescript.feed.source-used",
+        "react-native": "react-native.feed.source-used",
+        flutter: "flutter.feed.source-used",
+        ios: "ios.feed.source-used",
+    }),
     ...platformBindings("feed.target-resolved", {
         typescript: ["typescript.feed.target.literal", "typescript.feed.target-type-explicit"],
         "react-native": ["react-native.feed.target.literal", "react-native.feed.target-type-explicit"],
@@ -114,6 +122,13 @@ export const PRODUCT_EXPECTATION_BINDINGS = [
         flutter: "flutter.unread.subscribed-not-counted",
         ios: "ios.unread.subscribed-not-counted",
     }),
+    ...platformBindings("feed.post-body-rendering", {
+        typescript: "typescript.feed.post-body-rendered",
+        "react-native": "react-native.feed.post-body-rendered",
+        android: "android.feed.post-body-rendered",
+        flutter: "flutter.feed.post-body-rendered",
+        ios: "ios.feed.post-body-rendered",
+    }),
     {
         expectationId: "feed.rich-post-rendering",
         sensorId: "typescript.feed.post-datatype-handled",

package/dist/requestReadiness.js

@@ -0,0 +1,99 @@
+export function clarifyDimensions(input) {
+    const dims = [];
+    if (!input.platformDetected) {
+        dims.push("platform");
+    }
+    if (input.outcome === "unknown" && !input.creativeSelected && !input.uikitGuidedUnknown) {
+        dims.push("experience");
+    }
+    return dims;
+}
+const PLATFORM_QUESTION = {
+    dimension: "platform",
+    ask: "No social.plus SDK platform was detected in this repo. Which target app/platform should receive social.plus, and where is that app shell?",
+    why: "Vise validates real SDK code, not an abstract idea. A static or platform-unknown repo must be scaffolded or pointed at a real web TypeScript/React, React Native, Flutter, iOS, or Android surface before implementation can be verified.",
+    requiredDecision: "Target platform plus app/surface path to build in.",
+    options: [
+        "web TypeScript/React: package.json with @amityco/ts-sdk and a route/component to mount",
+        "React Native: app package plus screen/component path",
+        "Flutter: pubspec.yaml app plus widget/route path",
+        "iOS: Xcode/Swift package app plus view/module path",
+        "Android: Gradle app module plus Activity/Fragment/Compose screen path",
+    ],
+    answerFormat: "Tell the agent the target platform and app shell path; scaffold the platform first when it does not exist, then re-run `vise inspect` and `vise plan`.",
+    examples: [
+        "web TypeScript/React in apps/web, mount at /social",
+        "Android app module :app, add the surface to MainActivity/Compose navigation",
+        "Flutter app in mobile/, add the surface under lib/features/social/",
+    ],
+    doNot: [
+        "Do not paste SDK code into a static site before a platform has been chosen.",
+        "Do not assume web just because package.json is absent.",
+    ],
+};
+const EXPERIENCE_QUESTION = {
+    dimension: "experience",
+    routeTo: "vise creative",
+    ask: "The request did not name a buildable social experience. Which EI experience should be selected, or is this a no-fit for the current catalog?",
+    why: "A broad request like 'add social.plus features' needs a product direction before planning. Vise must not keyword-guess the experience; the host agent should use the EI candidate menu as advisory data and show the choice before accepting one.",
+    requiredDecision: "Selected EI experience variant, or explicit no-fit.",
+    answerFormat: "Run `vise creative . --request \"<intent>\"`, present the EI choice block, then run `vise creative accept . --variant <id|none> --rationale \"<why>\" --confidence high|medium|low`.",
+    examples: [
+        "community-first because the app needs topic/member spaces before feeds and chat",
+        "discovery-first because the core goal is browsing and finding social content",
+        "none because none of the surfaced candidates match the requested product motion",
+    ],
+    doNot: [
+        "Do not accept a variant before showing the recommendation, alternatives, tradeoffs, expected surfaces, and no-fit option.",
+        "Do not infer the experience from keywords alone.",
+    ],
+};
+export function clarifyGuidance(dims) {
+    if (dims.length === 0) {
+        return undefined;
+    }
+    const resolve = [];
+    if (dims.includes("platform")) {
+        resolve.push(PLATFORM_QUESTION);
+    }
+    if (dims.includes("experience")) {
+        resolve.push(EXPERIENCE_QUESTION);
+    }
+    const reasons = [
+        dims.includes("platform") ? "no SDK platform is detected" : undefined,
+        dims.includes("experience") ? "no buildable social feature is classified" : undefined,
+    ].filter((reason) => Boolean(reason));
+    const decisionChecklist = [
+        dims.includes("platform") ? "target platform/app shell and mount route or screen" : undefined,
+        dims.includes("experience") ? "selected EI experience, alternatives considered, or explicit no-fit" : undefined,
+        "after the request is classifiable: social.plus region (US/EU/SG), API-key env/config placeholder, identity source, feature scope, and route/surface placement",
+        "if the request is prebuilt/standard UI shaped: explicit solution_path=sdk|uikit|hybrid before hand-rolling UI",
+    ].filter((item) => Boolean(item));
+    const nextStepParts = [
+        "Stop before editing code and resolve `clarify.resolve` with the user",
+        dims.includes("experience") ? "run `vise creative`, present the EI choice block, then accept the chosen experience with rationale/confidence" : undefined,
+        dims.includes("platform") ? "confirm + scaffold the target platform/app shell (do not invent an integration on an undetected platform)" : undefined,
+        "then re-run `vise plan`.",
+    ].filter((part) => Boolean(part));
+    return {
+        why: `This request is not yet specific enough to produce a buildable plan (${reasons.join("; ")}).`,
+        resolve,
+        decisionChecklist,
+        unattended: {
+            status: "blocked",
+            mode: "handoff-required",
+            reason: "Blocking clarification is required before implementation can be planned safely.",
+            instruction: "If the user is not available, stop and return the clarify.resolve questions plus decisionChecklist. Do not choose defaults, scaffold speculative code, or proceed to init/build.",
+            allowedActions: [
+                "read-only inspect/plan output",
+                "run `vise creative` only to prepare an EI choice menu when the experience dimension is unresolved",
+            ],
+            resumeWhen: [
+                "the target platform/app shell is selected and scaffolded when required",
+                "the EI experience or no-fit decision is selected when required",
+                "a fresh `vise plan` no longer returns this clarify block",
+            ],
+        },
+        nextStep: nextStepParts.join(" — "),
+    };
+}