@amityco/social-plus-vise 0.14.26 → 0.14.28

package/dist/server.js

@@ -6,11 +6,14 @@ import { fileURLToPath } from "node:url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { attestRule, attestRuleTool, checkCompliance, checkComplianceTool, explainRule, explainRuleTool, initCompliance, initComplianceTool, initEngagement, initEngagementTool, showEngagement, showEngagementTool, statusCompliance, syncCompliance, syncComplianceTool, } from "./tools/compliance.js";
+import { attestRule, attestRuleTool, checkCompliance, checkComplianceTool, explainRule, explainRuleTool, experienceReportTool, initCompliance, initComplianceTool, initEngagement, initEngagementTool, showEngagement, showEngagementTool, statusCompliance, syncCompliance, syncComplianceTool, } from "./tools/compliance.js";
 import { designCheckTool, designExtractTool, designInitTokensTool, designPreviewTool, designReferenceTool } from "./tools/design.js";
 import { getDocPageTool, searchDocsTool } from "./tools/docs.js";
+import { compileExperienceTool } from "./tools/experienceCompiler.js";
+import { experienceSensorsTool } from "./tools/experienceSensors.js";
 import { planHarnessTool } from "./tools/harness.js";
 import { planIntegrationTool } from "./tools/integration.js";
+import { recordLearningTool, showLearningTool } from "./tools/learning.js";
 import { inspectProjectTool, validateSetupTool } from "./tools/project.js";
 import { resolveRequestTool, suggestPatchTool } from "./tools/resolve.js";
 import { runSensorsTool } from "./tools/sensors.js";
@@ -18,6 +21,7 @@ import { getSdkFactsTool } from "./tools/sdkFacts.js";
 import { addBlockInstall, listRegistryBlocks, planBlockInstall, validateBlockInstall } from "./tools/blocks.js";
 import { debugIssueTool, debugIssue } from "./tools/debug.js";
 import { creativeAcceptTool, creativeBriefTool } from "./tools/creative.js";
+import { uxHarnessTool } from "./tools/uxHarness.js";
 import { packageName, packageVersion } from "./version.js";
 const tools = new Map([
     searchDocsTool,
@@ -25,10 +29,16 @@ const tools = new Map([
     inspectProjectTool,
     creativeBriefTool,
     creativeAcceptTool,
+    uxHarnessTool,
+    compileExperienceTool,
+    experienceSensorsTool,
     planHarnessTool,
     planIntegrationTool,
     initComplianceTool,
     checkComplianceTool,
+    experienceReportTool,
+    recordLearningTool,
+    showLearningTool,
     syncComplianceTool,
     attestRuleTool,
     explainRuleTool,
@@ -140,15 +150,18 @@ async function handleCli(args) {
         if (command === "creative") {
             if (args[1] === "accept") {
                 const subArgs = args.slice(2);
-                assertOnlyKnownFlags(subArgs, ["variant", "brief", "brief-path"], "creative accept");
+                assertOnlyKnownFlags(subArgs, ["variant", "brief", "brief-path", "rationale", "confidence", "closest"], "creative accept");
                 await printToolResult(creativeAcceptTool, {
                     repoPath: positionalRepoPath(subArgs),
-                    variantId: requiredFlagValue(subArgs, "variant", "creative accept requires --variant <id>."),
+                    variantId: requiredFlagValue(subArgs, "variant", "creative accept requires --variant <id> (or --variant none to record a catalog gap)."),
                     briefPath: flagValue(subArgs, "brief") ?? flagValue(subArgs, "brief-path"),
+                    rationale: flagValue(subArgs, "rationale"),
+                    confidence: flagValue(subArgs, "confidence"),
+                    closest: flagValue(subArgs, "closest"),
                 });
                 return "exit";
             }
-            assertOnlyKnownFlags(args, ["request", "requirements", "prototype", "surface", "surface-path", "no-requirements", "no-write"], "creative");
+            assertOnlyKnownFlags(args, ["request", "requirements", "prototype", "surface", "surface-path", "no-requirements", "no-write", "ranking-preview"], "creative");
             if (hasFlag(args, "no-requirements") && flagValue(args, "requirements")) {
                 throw new Error("creative accepts either --requirements <path> or --no-requirements, not both.");
             }
@@ -158,10 +171,82 @@ async function handleCli(args) {
                 surfacePath: flagValue(args, "surface") ?? flagValue(args, "surface-path"),
                 requirementsPath: hasFlag(args, "no-requirements") ? "none" : flagValue(args, "requirements"),
                 prototypePath: flagValue(args, "prototype"),
+                rankingPreview: hasFlag(args, "ranking-preview"),
                 write: !hasFlag(args, "no-write"),
             });
             return "exit";
         }
+        if (command === "ux-harness") {
+            assertOnlyKnownFlags(args, ["surface", "surface-path", "no-write"], "ux-harness");
+            await printToolResult(uxHarnessTool, {
+                repoPath: positionalRepoPath(args.slice(1)),
+                surfacePath: flagValue(args, "surface") ?? flagValue(args, "surface-path"),
+                write: !hasFlag(args, "no-write"),
+            });
+            return "exit";
+        }
+        if (command === "experience-report" || command === "experience_report") {
+            assertOnlyKnownFlags(args, ["no-write"], "experience-report");
+            await printToolResult(experienceReportTool, {
+                repoPath: positionalRepoPath(args.slice(1)),
+                write: !hasFlag(args, "no-write"),
+            });
+            return "exit";
+        }
+        if (command === "learning" || command === "learn") {
+            const sub = args[1];
+            const subArgs = args.slice(2);
+            if (sub === "record") {
+                assertOnlyKnownFlags(subArgs, ["kind", "sentiment", "variant", "variant-id", "note", "metric", "no-write"], "learning record");
+                await printToolResult(recordLearningTool, {
+                    repoPath: positionalRepoPath(subArgs),
+                    kind: flagValue(subArgs, "kind"),
+                    sentiment: flagValue(subArgs, "sentiment"),
+                    variantId: flagValue(subArgs, "variant") ?? flagValue(subArgs, "variant-id"),
+                    note: flagValue(subArgs, "note"),
+                    metrics: keyValueFlag(subArgs, "metric"),
+                    write: !hasFlag(subArgs, "no-write"),
+                });
+                return "exit";
+            }
+            if (sub === "show" || sub === "summary") {
+                assertOnlyKnownFlags(subArgs, [], `learning ${sub}`);
+                await printToolResult(showLearningTool, {
+                    repoPath: positionalRepoPath(subArgs),
+                });
+                return "exit";
+            }
+            console.error(`Unknown learning subcommand: ${sub ?? "(none)"}. Expected "record" or "show".`);
+            process.exitCode = 1;
+            return "exit";
+        }
+        if (command === "experience") {
+            const sub = args[1];
+            const subArgs = args.slice(2);
+            if (sub === "compile") {
+                assertOnlyKnownFlags(subArgs, ["request", "surface", "surface-path", "registry", "no-write"], "experience compile");
+                await printToolResult(compileExperienceTool, {
+                    repoPath: positionalRepoPath(subArgs),
+                    request: flagValue(subArgs, "request"),
+                    surfacePath: flagValue(subArgs, "surface") ?? flagValue(subArgs, "surface-path"),
+                    registryPath: flagValue(subArgs, "registry"),
+                    write: !hasFlag(subArgs, "no-write"),
+                });
+                return "exit";
+            }
+            if (sub === "sensors") {
+                assertOnlyKnownFlags(subArgs, ["surface", "surface-path", "no-write"], "experience sensors");
+                await printToolResult(experienceSensorsTool, {
+                    repoPath: positionalRepoPath(subArgs),
+                    surfacePath: flagValue(subArgs, "surface") ?? flagValue(subArgs, "surface-path"),
+                    write: !hasFlag(subArgs, "no-write"),
+                });
+                return "exit";
+            }
+            console.error(`Unknown experience subcommand: ${sub ?? "(none)"}. Expected "compile" or "sensors".`);
+            process.exitCode = 1;
+            return "exit";
+        }
         if (command === "debug") {
             assertOnlyKnownFlags(args, ["error", "error-file", "brief"], "debug");
             let errorMessage = flagValue(args, "error");
@@ -231,7 +316,7 @@ async function handleCli(args) {
             return "exit";
         }
         if (command === "run-sensors" || command === "run_sensor" || command === "run-sensor") {
-            await printToolResult(runSensorsTool, {
+            const printed = await printToolResult(runSensorsTool, {
                 repoPath: positionalRepoPath(args.slice(1)),
                 request: flagValue(args, "request"),
                 include: flagValues(args, "include"),
@@ -239,6 +324,13 @@ async function handleCli(args) {
                 dryRun: hasFlag(args, "dry-run"),
                 surfacePath: flagValue(args, "surface") ?? flagValue(args, "surface-path"),
             });
+            // Reflect sensor outcome in the exit code so `vise run-sensors` is usable as a CI gate.
+            // Previously it always exited 0, so a failed/timed-out build silently read as green.
+            // dry-run / passed / no-sensors stay 0; only real failures fail.
+            const status = toolResultStatus(printed);
+            if (status === "failed" || status === "timed-out") {
+                process.exitCode = 1;
+            }
             return "exit";
         }
         if (command === "resolve") {
@@ -250,7 +342,7 @@ async function handleCli(args) {
             return "exit";
         }
         if (command === "sdk-facts" || command === "sdk_facts") {
-            assertOnlyKnownFlags(args, ["platform", "capability", "surface-dir", "format", "include-symbols"], "sdk-facts");
+            assertOnlyKnownFlags(args, ["platform", "capability", "surface-dir", "format", "include-symbols", "include-models"], "sdk-facts");
             const format = flagValue(args, "format") ?? "json";
             if (format !== "json") {
                 throw new Error("sdk-facts currently supports --format json only.");
@@ -260,6 +352,7 @@ async function handleCli(args) {
                 capability: flagValue(args, "capability"),
                 surfaceDir: flagValue(args, "surface-dir"),
                 includeSymbols: hasFlag(args, "include-symbols"),
+                includeModels: hasFlag(args, "include-models"),
             });
             return "exit";
         }
@@ -490,13 +583,74 @@ Usage:
   vise creative [repoPath] --request "Add engagement" --requirements none
   vise creative [repoPath] --request "Add engagement" --no-requirements
   vise creative [repoPath] --request "Add engagement" --prototype ./prototype.html
+  vise creative [repoPath] --request "Add engagement" --ranking-preview
   vise creative [repoPath] --request "Add engagement" --no-write
   vise creative accept [repoPath] --variant community-first
+  vise creative accept [repoPath] --variant none --rationale "No variant fits X; closest is Y" --closest discovery-first
 
 Output:
   Writes sp-vise/creative-brief.json and sp-vise/creative-brief.md unless --no-write is set.
+  --ranking-preview also writes sp-vise/candidate-ranking-preview.json as an opt-in advisory local preview.
   Requirements are optional; absence or explicit none switches creative mode to exploratory.
-  creative accept writes sp-vise/creative-selection.json for plan/init/workplan feed-forward.`;
+  creative accept writes sp-vise/creative-selection.json for plan/init/workplan feed-forward.
+  creative accept --variant none records sp-vise/catalog-gap.json (a local no-fit signal for human catalog review).`;
+    }
+    if (command === "ux-harness") {
+        return `${packageName} ux-harness
+
+Generate the advisory UX Harness sidecar from an accepted creative selection.
+
+Usage:
+  vise ux-harness [repoPath]
+  vise ux-harness [repoPath] --surface apps/web
+  vise ux-harness [repoPath] --no-write
+
+Output:
+  Writes sp-vise/ux-harness.json by default. The sidecar contains selected UX pattern expectations, tradeoffs, anti-patterns, and advisory conformance hints. It never changes deterministic compliance rules by itself.`;
+    }
+    if (command === "experience-report" || command === "experience_report") {
+        return `${packageName} experience-report
+
+Generate the advisory dimensioned Experience Report from current compliance evidence.
+
+Usage:
+  vise experience-report [repoPath]
+  vise experience-report [repoPath] --no-write
+
+Output:
+  Writes sp-vise/experience-report.json by default. The report summarizes technical compliance, design contract presence, UX Harness advisory evidence, and business alignment without producing a calibrated single score.`;
+    }
+    if (command === "learning" || command === "learn") {
+        return `${packageName} learning
+
+Record and review local-only Engagement Intelligence learning events.
+
+Usage:
+  vise learning record [repoPath] --sentiment positive --note "Customer preferred Community First"
+  vise learning record [repoPath] --kind outcome-snapshot --metric retention_delta=0.12
+  vise learning record [repoPath] --kind report-review --sentiment neutral --no-write
+  vise learning show [repoPath]
+
+Output:
+  record writes sp-vise/learning-events.jsonl and sp-vise/learning-summary.json by default. Learning events are local evidence only; Vise does not change recommendation ranking from them yet.`;
+    }
+    if (command === "experience") {
+        return `${packageName} experience
+
+Compile an accepted Engagement Intelligence variant and summarize experience sensors.
+
+Usage:
+  vise experience compile [repoPath]
+  vise experience compile [repoPath] --request "Make this app social"
+  vise experience compile [repoPath] --registry ./registry/blocks.json
+  vise experience compile [repoPath] --surface apps/web --no-write
+  vise experience sensors [repoPath]
+  vise experience sensors [repoPath] --surface apps/web --no-write
+
+Output:
+  compile writes sp-vise/experience-compiler.json by default. The artifact summarizes install guidance, navigation wiring, per-surface plan/init commands, UX expectations, optional Block Factory bridge candidates, design adaptation, and validation commands. It does not edit source code.
+
+  sensors writes sp-vise/experience-sensors.json by default. The artifact summarizes advisory technical, design, UX, accessibility, and business-alignment evidence without changing vise check exit codes or producing a calibrated score.`;
     }
     if (command === "plan-harness") {
         return `${packageName} plan-harness
@@ -623,10 +777,15 @@ Usage:
         return `${packageName} sdk-facts
 
 Read bundled SDK surface facts for social.plus Block Factory planning. Internal, projectless, and read-only.
+Symbol facts prove existence; --include-models adds extraction-grounded field-level model schemas
+(modelSchemas, plus capability model entries gain a schema). Platforms without grounded field data
+report modelFacts.status=absent instead of fabricated fields.
 
 Usage:
   vise sdk-facts --platform typescript --capability comments --format json
+  vise sdk-facts --platform typescript --capability comments --include-models
   vise sdk-facts --platform react-native --capability reactions --include-symbols
+  vise sdk-facts --platform android --include-models --format json
   vise sdk-facts --platform android --surface-dir ./sdk-surface --format json`;
     }
     if (command === "blocks") {
@@ -745,7 +904,13 @@ Usage:
   vise print-skill                 Print bundled skill markdown
   vise inspect [repoPath]          Inspect platform and design signals
   vise creative [repoPath] --request "..." Create an Engagement Intelligence brief
-  vise creative accept [repoPath] --variant <id> Accept a creative variant
+  vise creative accept [repoPath] --variant <id|none> Accept a creative variant, or record a no-fit catalog gap with --variant none
+  vise ux-harness [repoPath]      Generate UX Harness expectations from creative selection
+  vise experience-report [repoPath] Write the advisory dimensioned Experience Report
+  vise experience compile [repoPath] Compile selected variant into implementation artifacts
+  vise experience sensors [repoPath] Write advisory experience sensor framework
+  vise learning record [repoPath] Record a local-only learning event
+  vise learning show [repoPath]    Show local learning summary
   vise debug [repoPath] --error ... Debug an SDK-specific runtime error and emit a repair brief
   vise plan [repoPath] --request "..." Create an implementation plan
   vise workplan next [repoPath] --request "..." Get the next broad-social surface to implement
@@ -784,7 +949,19 @@ SOCIAL_PLUS_DOCS_ROOT to test against a local social-plus-docs checkout.`;
 }
 async function printToolResult(tool, input) {
     const result = await tool.call(input);
-    console.log(result.content.map((item) => item.text).join("\n"));
+    const text = result.content.map((item) => item.text).join("\n");
+    console.log(text);
+    return { result, text };
+}
+// Parse the `status` field from a tool's printed JSON payload (best-effort).
+function toolResultStatus(printed) {
+    try {
+        const payload = JSON.parse(printed.text);
+        return typeof payload.status === "string" ? payload.status : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 async function installSkill(args) {
     const source = skillSourceDir();
@@ -1021,6 +1198,7 @@ async function workplanStatus(args) {
         request,
         progressPath: workplanProgressPath(repoRoot),
         creativeContext: plan.socialWorkplan?.creativeContext ?? plan.creativeContext,
+        uxHarness: plan.socialWorkplan?.uxHarness ?? plan.uxHarness,
         completed,
         sequence: sequence.map((surface) => ({
             id: surface.id,
@@ -1037,6 +1215,7 @@ async function workplanStatus(args) {
                 label: nextSurface.label,
                 intake: nextSurface.intake,
                 validation: nextSurface.validation,
+                uxHarness: nextSurface.uxHarness,
                 commands: {
                     plan: nextSurface.planCommand,
                     init: nextSurface.initCommand,
@@ -1222,7 +1401,7 @@ function ciCheckResult(result) {
     };
 }
 function positionalRepoPath(args) {
-    const flagsWithValues = new Set(["request", "requirements", "prototype", "variant", "brief", "brief-path", "surface", "surface-path", "platform", "capability", "surface-dir", "format", "include", "timeout-ms", "query", "path", "limit", "answer", "target", "dest", "destination", "rule", "confidence", "signer", "identity", "evidence-file", "rationale", "repo", "reference", "registry", "block", "package-source", "note"]);
+    const flagsWithValues = new Set(["request", "requirements", "prototype", "variant", "variant-id", "brief", "brief-path", "surface", "surface-path", "platform", "capability", "surface-dir", "format", "include", "timeout-ms", "query", "path", "limit", "answer", "target", "dest", "destination", "rule", "confidence", "signer", "identity", "evidence-file", "rationale", "repo", "reference", "registry", "block", "package-source", "note", "kind", "sentiment", "metric"]);
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (!arg) {

package/dist/tools/ast.js

@@ -29,11 +29,21 @@ function loadNativeBindings() {
         const ParserCtor = nodeRequire("tree-sitter");
         const tsGrammars = nodeRequire("tree-sitter-typescript");
         const kotlinGrammar = nodeRequire("tree-sitter-kotlin");
+        // Swift loads in its own try/catch: a missing tree-sitter-swift prebuild on an
+        // exotic platform must degrade ONLY the Swift helpers, not all AST analysis.
+        let swiftGrammar = null;
+        try {
+            swiftGrammar = nodeRequire("tree-sitter-swift");
+        }
+        catch {
+            swiftGrammar = null;
+        }
         nativeBindings = {
             Parser: ParserCtor,
             tsGrammar: tsGrammars.typescript,
             tsxGrammar: tsGrammars.tsx,
             kotlinGrammar,
+            swiftGrammar,
         };
     }
     catch {
@@ -50,6 +60,14 @@ function loadNativeBindings() {
 export function astAvailable() {
     return loadNativeBindings() !== null;
 }
+/**
+ * Whether the Swift grammar specifically is available. tree-sitter-swift is loaded
+ * independently of the core bindings (see loadNativeBindings), so Swift-only
+ * validators can check this and fall back to regex without disabling ts/tsx/kotlin.
+ */
+export function swiftAstAvailable() {
+    return loadNativeBindings()?.swiftGrammar != null;
+}
 /**
  * Strip comments from source code using tree-sitter AST.
  * Replaces comment spans with whitespace (preserving line structure).
@@ -101,6 +119,12 @@ function getParser(language) {
             parser.setLanguage(native.tsxGrammar);
         else if (language === "kotlin")
             parser.setLanguage(native.kotlinGrammar);
+        else if (language === "swift") {
+            if (native.swiftGrammar == null) {
+                throw new Error("tree-sitter-swift unavailable; Swift AST analysis disabled (regex fallback in effect)");
+            }
+            parser.setLanguage(native.swiftGrammar);
+        }
         else
             parser.setLanguage(native.tsGrammar);
         parsers.set(language, parser);
@@ -166,7 +190,10 @@ export function findCallExpressions(tree, calleePattern) {
             results.push({ callee, node, args });
             return;
         }
-        // Kotlin: call_expression = navigation_expression + call_suffix
+        // Kotlin AND Swift: call_expression = navigation_expression + call_suffix.
+        // (tree-sitter-swift descends from the Kotlin grammar, so the node names —
+        // navigation_expression / navigation_suffix / call_suffix / value_arguments —
+        // are identical; only Swift's labeled arguments add a value_argument_label.)
         const navNode = node.namedChild(0);
         const suffixNode = node.namedChild(1);
         if (!navNode || !suffixNode || suffixNode.type !== "call_suffix")
@@ -181,8 +208,11 @@ export function findCallExpressions(tree, calleePattern) {
             for (let i = 0; i < valArgsNode.namedChildCount; i++) {
                 const valArg = valArgsNode.namedChild(i);
                 if (valArg && valArg.type === "value_argument") {
-                    // The actual expression is inside value_argument
-                    const expr = valArg.namedChild(0);
+                    // The actual expression is inside value_argument. Swift labeled arguments
+                    // put a value_argument_label first — the value is the last named child.
+                    // Kotlin behaviour (namedChild(0)) is intentionally unchanged.
+                    const first = valArg.namedChild(0);
+                    const expr = first?.type === "value_argument_label" ? valArg.namedChild(valArg.namedChildCount - 1) : first;
                     if (expr)
                         args.push(expr);
                 }
@@ -233,6 +263,93 @@ export function pickObjectProperty(objectNode, propertyName) {
     }
     return undefined;
 }
+/**
+ * Pick the value of a labeled argument from a Swift call expression node.
+ * E.g., from `client.login(userId: HARDCODED, sessionHandler: handler)`,
+ * pick the value node for label "userId".
+ *
+ * Swift-shaped trees only (call_suffix → value_arguments → value_argument with a
+ * value_argument_label). Returns undefined when the label is absent.
+ */
+export function pickLabeledArgument(callNode, label) {
+    for (let i = 0; i < callNode.namedChildCount; i++) {
+        const suffix = callNode.namedChild(i);
+        if (!suffix || suffix.type !== "call_suffix")
+            continue;
+        const valArgs = suffix.namedChild(0);
+        if (!valArgs || valArgs.type !== "value_arguments")
+            continue;
+        for (let j = 0; j < valArgs.namedChildCount; j++) {
+            const valArg = valArgs.namedChild(j);
+            if (!valArg || valArg.type !== "value_argument")
+                continue;
+            const first = valArg.namedChild(0);
+            if (first?.type !== "value_argument_label" || first.text !== label)
+                continue;
+            const value = valArg.namedChild(valArg.namedChildCount - 1);
+            // namedChild(last) === the label itself when the argument has no value
+            // (selector-reference form) — treat as absent.
+            return value && value !== first ? value : undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Find Swift `let`/`var` declarations whose initializer text matches a pattern AND
+ * which are function-local (declared inside a function/initializer/closure/computed-
+ * property body rather than at type or file scope). Used for retention rules: a
+ * function-local binding dies with the stack frame, while a type-scope property
+ * lives with the object — a distinction regex bridges cannot make reliably.
+ *
+ * Conservative direction: a declaration only counts as local when a KNOWN
+ * function-ish ancestor encloses it, so unknown containers degrade toward
+ * "retained" (quiet), never toward a false positive.
+ */
+export function findSwiftFunctionLocalDeclarations(tree, initializerPattern) {
+    const results = [];
+    walkTree(tree.rootNode, (node) => {
+        if (node.type !== "property_declaration")
+            return;
+        const value = swiftPropertyInitializer(node);
+        if (!value || !initializerPattern.test(value.text))
+            return;
+        if (hasFunctionAncestor(node))
+            results.push(node);
+    });
+    return results;
+}
+const SWIFT_FUNCTION_SCOPES = new Set([
+    "function_declaration",
+    "init_declaration",
+    "deinit_declaration",
+    "lambda_literal",
+    "computed_property",
+    "computed_getter",
+    "computed_setter",
+]);
+function hasFunctionAncestor(node) {
+    let current = node.parent;
+    while (current) {
+        if (SWIFT_FUNCTION_SCOPES.has(current.type))
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+/** The initializer expression of a Swift property_declaration (the value after `=`), if any. */
+function swiftPropertyInitializer(node) {
+    // Shape: property_declaration = value_binding_pattern, pattern, [type_annotation], [value expr]
+    // The initializer (when present) is the last named child and is none of the structural parts.
+    const last = node.namedChild(node.namedChildCount - 1);
+    if (!last)
+        return undefined;
+    if (["value_binding_pattern", "pattern", "type_annotation", "modifiers", "attribute"].includes(last.type))
+        return undefined;
+    // computed_property is a body, not an initializer.
+    if (last.type === "computed_property")
+        return undefined;
+    return last;
+}
 // ── Internal helpers ──────────────────────────────────────────────────────────
 function walkTree(node, visit) {
     visit(node);
@@ -322,6 +439,25 @@ function extractStringLiteral(node) {
             return text.slice(1, -1);
         }
     }
+    // Swift: line_string_literal contains line_str_text chunks; an interpolated
+    // string has >1 named child (line_str_text + interpolated_expression) and is
+    // NOT statically resolvable — mirror the TS template-literal treatment.
+    if (node.type === "line_string_literal") {
+        if (node.namedChildCount === 0)
+            return ""; // empty string ""
+        if (node.namedChildCount === 1 && node.namedChild(0)?.type === "line_str_text") {
+            return node.namedChild(0).text;
+        }
+        return undefined;
+    }
+    // Swift: multi-line """…""" literal. Swift semantics strip the newline after the
+    // opening and before the closing delimiter.
+    if (node.type === "multi_line_string_literal") {
+        if (node.namedChildCount === 1 && node.namedChild(0)?.type === "multi_line_str_text") {
+            return node.namedChild(0).text.replace(/^\n/, "").replace(/\n[ \t]*$/, "");
+        }
+        return undefined;
+    }
     return undefined;
 }
 function resolveIdentifierToLiteral(name, root) {
@@ -345,15 +481,31 @@ function resolveIdentifierToLiteral(name, root) {
         // Kotlin: property_declaration with variable_declaration + string_literal
         if (node.type === "property_declaration") {
             const varDecl = node.namedChildren.find((c) => c.type === "variable_declaration");
-            if (!varDecl)
+            if (varDecl) {
+                const idNode = varDecl.namedChildren.find((c) => c.type === "simple_identifier");
+                if (!idNode || idNode.text !== name)
+                    return;
+                const strLit = node.namedChildren.find((c) => c.type === "string_literal");
+                if (!strLit)
+                    return;
+                const literal = extractStringLiteral(strLit);
+                if (literal !== undefined)
+                    result = literal;
+                return;
+            }
+            // Swift: property_declaration with pattern → simple_identifier; the string
+            // literal must be a DIRECT child (the initializer) — a literal nested inside
+            // e.g. `env["KEY"] ?? ""` is not a static binding and must not resolve.
+            const pattern = node.namedChildren.find((c) => c.type === "pattern");
+            if (!pattern)
                 return;
-            const idNode = varDecl.namedChildren.find((c) => c.type === "simple_identifier");
-            if (!idNode || idNode.text !== name)
+            const swiftId = pattern.namedChildren.find((c) => c.type === "simple_identifier");
+            if (!swiftId || swiftId.text !== name)
                 return;
-            const strLit = node.namedChildren.find((c) => c.type === "string_literal");
-            if (!strLit)
+            const swiftLit = node.namedChildren.find((c) => c.type === "line_string_literal" || c.type === "multi_line_string_literal");
+            if (!swiftLit)
                 return;
-            const literal = extractStringLiteral(strLit);
+            const literal = extractStringLiteral(swiftLit);
             if (literal !== undefined)
                 result = literal;
         }