rea-agents 6.2.0 → 6.4.0

package/dist/contracts/advertisedInputExamples.js

@@ -0,0 +1,48 @@
+import { evidenceSchema } from "../domain/evidence.js";
+/** The Evidence identifier of a complete Evidence record, or undefined. */
+const evidenceRecordId = (value) => typeof value.evidence_id === "string" &&
+    Object.hasOwn(value, "normalized_result") &&
+    evidenceSchema.safeParse(value).success
+    ? value.evidence_id
+    : undefined;
+/** Replace each embedded complete Evidence record with its exact retained reference. */
+const referenceEmbeddedEvidence = (value) => {
+    if (Array.isArray(value)) {
+        const items = value.map(referenceEmbeddedEvidence);
+        return {
+            value: items.map((item) => item.value),
+            embedsEvidence: items.some((item) => item.embedsEvidence),
+        };
+    }
+    if (value === null || typeof value !== "object")
+        return { value, embedsEvidence: false };
+    const evidenceId = evidenceRecordId(value);
+    if (evidenceId !== undefined)
+        return {
+            value: { kind: "retained-evidence", evidence_id: evidenceId },
+            embedsEvidence: true,
+        };
+    const entries = Object.entries(value).map(([key, child]) => [key, referenceEmbeddedEvidence(child)]);
+    return {
+        value: Object.fromEntries(entries.map(([key, child]) => [key, child.value])),
+        embedsEvidence: entries.some(([, child]) => child.embedsEvidence),
+    };
+};
+/**
+ * Examples advertised in a tool's input schema. Embedded complete Evidence is
+ * shown as its exact same-session retained reference when the canonical input
+ * schema accepts that form; an example that can only carry inline Evidence
+ * stays in the canonical contract and its executable tests but leaves the
+ * advertisement. Every advertised example is a distinct valid canonical input.
+ */
+export const advertisedInputExamples = (contract) => {
+    const advertised = new Map();
+    for (const { input } of contract.examples) {
+        const projection = referenceEmbeddedEvidence(input);
+        if (projection.embedsEvidence &&
+            !contract.inputSchema.safeParse(projection.value).success)
+            continue;
+        advertised.set(JSON.stringify(projection.value), projection.value);
+    }
+    return [...advertised.values()];
+};

package/dist/contracts/analysisDetail.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { analysisViewResultSchema } from "../domain/analysisView/analysisView.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+/** Caller-selected delivery of completed analysis Evidence that supports retained views. */
+export const analysisDetailSchema = z
+    .enum(["complete", "summary"])
+    .default("complete")
+    .describe("complete returns the complete analysis Evidence inline. summary retains that complete Evidence in this session and returns its inspect_analysis_view summary; inspect pages, items or facets through normalized_result.parent_evidence_id.");
+/** Complete analysis Evidence, or the summary view of its retained record. */
+export const analysisDetailOutputSchemaOf = (analysis) => evidenceResultOf(z.union([analysis, analysisViewResultSchema]));

package/dist/contracts/analysisViewToolContracts.js

@@ -2,13 +2,13 @@ import { analysisViewResultSchema, inspectAnalysisViewInputSchema, } from "../do
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 const RETAINED_EXAMPLE_ID = `ev_${"a".repeat(64)}`;
-/** Selected views of already completed layout and JavaScript analysis Evidence. */
+/** Selected views of already completed layout, JavaScript and native function Evidence. */
 export const ANALYSIS_VIEW_TOOL_CONTRACTS = [
     {
         name: "inspect_analysis_view",
         ...toolContractMetadata("inspect_analysis_view"),
         kind: "application",
-        description: "Inspect a selected view of completed binary-layout or JavaScript application Evidence without repeating analysis. Use an exact same-session retained evidence_id or portable inline Evidence. Select a summary, layout mitigations/linkage facet, one section/symbol/module, or a stable page with a positive limit. Module pages contain JavaScript assets, bundled modules and source modules; use node_id when paths are ambiguous or unavailable. Returns selected facts inline with artifact identity, parent Evidence ID, a distinct view digest, coverage, limitations and unknowns. Actual serialized size determines MCP transport admission; choose a smaller page or export the retained Evidence when needed.",
+        description: "Inspect selected views of completed binary-layout, JavaScript application or native analyze_function Evidence without repeating analysis. Use an exact same-session retained evidence_id or portable inline Evidence. Select a summary, layout mitigations/linkage facet, one section/symbol/module, or a stable page. Module pages include assets, bundled and source modules; use node_id for ambiguous or unavailable paths. Native views select procedure, pseudocode, assembly, basic blocks, comments, callers/callees, references, unresolved calls, referenced strings/names, native API and high-pcode. Use nonnegative offset and a positive caller-selected limit (defaults 0 and 64); pseudocode uses UTF-16 code units, other native pages use rows. Returns artifact identity, parent Evidence ID, a distinct view digest, coverage, limitations and unknowns. Actual serialized size determines MCP transport admission; choose a smaller page or export the complete retained Evidence if needed.",
         inputSchema: inspectAnalysisViewInputSchema,
         outputSchema: evidenceResultOf(analysisViewResultSchema),
         examples: [
@@ -36,6 +36,21 @@ export const ANALYSIS_VIEW_TOOL_CONTRACTS = [
                     },
                 },
             },
+            {
+                title: "Page native high-pcode operations from retained Evidence",
+                input: {
+                    source: {
+                        kind: "retained-evidence",
+                        evidence_id: RETAINED_EXAMPLE_ID,
+                    },
+                    view: {
+                        kind: "native",
+                        facet: "value_flow_operations",
+                        offset: 0,
+                        limit: 32,
+                    },
+                },
+            },
             {
                 title: "Page module identities from retained application Evidence",
                 input: {

package/dist/contracts/apktool/apktoolToolContracts.js

@@ -0,0 +1,33 @@
+import { apktoolInputSchemas, apktoolResultSchemas, } from "../../domain/apktool/apktoolResourceAnalysis.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "../toolEffects.js";
+/** Apktool resource decoding served by a caller-supplied launcher. */
+export const APKTOOL_TOOL_CONTRACTS = [
+    {
+        name: "inspect_apktool_client",
+        ...toolContractMetadata("inspect_apktool_client"),
+        description: "Inspect the caller-selected apktool launcher: resolved command, selection source, and version. Decodes nothing. REA never installs Apktool or Java; select a launcher with REA_APKTOOL_COMMAND (absolute) or apktool on PATH.",
+        kind: "apktool-provider",
+        inputSchema: apktoolInputSchemas.inspect_apktool_client,
+        outputSchema: evidenceResultOf(apktoolResultSchemas.inspect_apktool_client),
+        examples: [{ title: "Check the Apktool launcher", input: {} }],
+    },
+    {
+        name: "decode_android_resources",
+        ...toolContractMetadata("decode_android_resources"),
+        description: "Decode one local APK's resources with `apktool d --no-src` in a provider-owned workspace that is removed after projection: the readable AndroidManifest.xml, apktool.yml version and SDK facts, the app's string resources (default or one locale, bounded to 2000 entries), available string locales, and the decoded file count. The target APK is digest with SHA-256 before decoding; smali is skipped because Java-source recovery belongs to the JADX family.",
+        kind: "apktool-provider",
+        inputSchema: apktoolInputSchemas.decode_android_resources,
+        outputSchema: evidenceResultOf(apktoolResultSchemas.decode_android_resources),
+        examples: [
+            {
+                title: "Decode an APK's resources",
+                input: { path: "/targets/Example.apk" },
+            },
+            {
+                title: "Decode one locale's strings",
+                input: { path: "/targets/Example.apk", locale: "de" },
+            },
+        ],
+    },
+];

package/dist/contracts/artifactComparisonExample.js

@@ -1,10 +1,10 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 const inventory = (digit) => {
     const sha = digit.repeat(64);
-    const artifactId = `art_${canonicalDigest({ sha256: sha }, "Artifact example")}`;
-    const occurrenceId = `occ_${canonicalDigest({ root: artifactId }, "Artifact example")}`;
+    const artifactId = `art_${digestCanonicalValue({ sha256: sha }, "Artifact example")}`;
+    const occurrenceId = `occ_${digestCanonicalValue({ root: artifactId }, "Artifact example")}`;
     const nodes = [
         {
             artifact_id: artifactId,
@@ -35,7 +35,7 @@ const inventory = (digit) => {
             limitations: [],
         },
     ];
-    const graphSha256 = canonicalDigest({
+    const graphSha256 = digestCanonicalValue({
         nodes,
         occurrences,
         edges: [],
@@ -43,7 +43,7 @@ const inventory = (digit) => {
     }, "Artifact example");
     return jsonValueSchema.parse({
         manifest: {
-            manifest_id: `agm_${canonicalDigest({
+            manifest_id: `agm_${digestCanonicalValue({
                 root_artifact_id: artifactId,
                 graph_sha256: graphSha256,
             }, "Artifact example")}`,

package/dist/contracts/artifactToolContracts.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { artifactOutputSchemas } from "./toolOutputSchemaGroups.js";
+import { artifactIntegrityPolicySchema } from "../domain/artifactIntegrityPolicy.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
@@ -8,12 +9,14 @@ import { dylibResolutionInputSchema } from "../domain/apple/dylibResolution.js";
 import { keyedArchiveInputSchema } from "../domain/apple/keyedArchive.js";
 /** Exact caller boundary for deterministic artifact inventory. */
 export const artifactInventoryInputSchema = z.strictObject({
-    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
+    integrity_policy: artifactIntegrityPolicySchema,
 });
 /** Extraction needs no selector: it materializes every regular child file. */
-export const artifactExtractionInputSchema = z.strictObject({});
+export const artifactExtractionInputSchema = z.strictObject({
+    integrity_policy: artifactIntegrityPolicySchema,
+});
 /** Provider input containing the destination chosen by the local adapter. */
-export const artifactExtractionExecutionSchema = z.strictObject({
+export const artifactExtractionExecutionSchema = artifactExtractionInputSchema.extend({
     output_root: z.string().min(1),
 });
 const exampleInputSchema = z.record(z.string(), jsonValueSchema);
@@ -47,8 +50,8 @@ const artifact = (name, description, inputSchema) => {
 };
 /** Artifact-graph inventory and safe extraction contracts. */
 export const ARTIFACT_TOOL_CONTRACTS = [
-    artifact("inspect_artifact", "Inspect an active archive or application package in one call. Returns the complete content-addressed artifact graph, source Evidence, observations, relationships, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInventoryInputSchema),
-    artifact("extract_artifact", "Extract all regular files from the active archive or application package into a fresh temporary directory chosen by REA. The result includes its location. Rejects traversal and symlink escapes, never overwrites, enforces archive integrity checks, and verifies cleanup.", artifactExtractionInputSchema),
+    artifact("inspect_artifact", "Inspect an active archive or application package in one call. Returns the complete content-addressed artifact graph once, as the nested inventory Evidence, with root and integrity observations, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInventoryInputSchema),
+    artifact("extract_artifact", "Extract all regular files from the active archive or application package into a fresh temporary directory chosen by REA. The result includes its location. Rejects traversal and symlink escapes, never overwrites, and verifies cleanup. Integrity mismatches fail by default; record-and-continue extracts the observed bytes and returns each mismatch as an explicitly untrusted integrity contradiction.", artifactExtractionInputSchema),
     artifact("decode_interface_builder", "Decode compiled storyboard and nib archives inside the active Apple app bundle, including keyed property lists and NIBArchive object tables, into a bounded object, hierarchy, and connection graph. This is static archive parsing; unrecognized archive classes and unresolved code handlers remain explicit unknowns.", z.strictObject({
         max_documents: z.number().int().min(1).max(64).default(64),
         max_objects: z.number().int().min(1).max(20_000).default(20_000),

package/dist/contracts/browserToolContracts.js

@@ -186,7 +186,7 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "compare_web_captures",
         ...toolContractMetadata("compare_web_captures"),
-        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page normalized_result in inspection and an optional complete discover_webmcp_tools normalized_result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario normalized_result objects in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
+        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page normalized_result in inspection and an optional complete discover_webmcp_tools normalized_result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario normalized_result objects in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Network comparison includes observed HTTP requests and WebSocket frame streams; same-URL connections are compared as an unordered collection of ordered streams, retaining connection counts without claiming stable identity between individual connections. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
         kind: "browser-provider",
         inputSchema: browserCaptureComparisonInputSchema,
         outputSchema: captureDiffOutputSchema,

package/dist/contracts/compactInputSchema.js

@@ -0,0 +1,256 @@
+import { schemaArrays, schemaChildren, schemaMaps, } from "./inputSchemaPresentation.js";
+// Kimi expands schema-local references before sending tools to Moonshot.
+// Compact advertisements must fit after expansion, independently of client
+// reference handling. Canonical server-side validation remains unchanged.
+/** Annotation keys that carry guidance but no validation semantics. */
+const annotationKeys = new Set(["description", "examples", "default", "title"]);
+/** Keys whose values are literal data, never nested schemas to rewrite. */
+const dataKeys = new Set(["const", "enum", "examples", "default"]);
+const definitionKeys = new Set(["$defs", "definitions"]);
+// An empty schema accepts every JSON value. Kimi otherwise infers string.
+const jsonValueTypes = [
+    "null",
+    "boolean",
+    "object",
+    "array",
+    "number",
+    "string",
+];
+const isSchemaObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const serializedBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+/** Rewrite every schema-valued position; literal data stays opaque. */
+const rebuildSchemaPositions = (node, rebuild) => {
+    if (Array.isArray(node))
+        return node.map((child) => rebuild(child));
+    if (!isSchemaObject(node))
+        return node;
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (dataKeys.has(key)) {
+            out[key] = value;
+            continue;
+        }
+        if (schemaMaps.has(key) && isSchemaObject(value)) {
+            out[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [name, rebuild(child)]));
+            continue;
+        }
+        if (schemaArrays.has(key) && Array.isArray(value)) {
+            out[key] = value.map((child) => rebuild(child));
+            continue;
+        }
+        if (schemaChildren.has(key)) {
+            out[key] = Array.isArray(value)
+                ? value.map((child) => rebuild(child))
+                : rebuild(value);
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+};
+/**
+ * Drop annotation prose from every subschema while preserving all validation
+ * keywords. The root keeps its own description because the root-union
+ * projection encodes accepted input groups there; the root's echoed literal
+ * examples leave with the rest of the annotation prose.
+ */
+const stripAnnotations = (schema) => {
+    const rebuilt = rebuildSchemaPositions(schema, stripChildAnnotations);
+    const out = {};
+    for (const [key, value] of Object.entries(rebuilt)) {
+        if (annotationKeys.has(key) && key !== "description")
+            continue;
+        out[key] = value;
+    }
+    return out;
+};
+const stripChildAnnotations = (child) => {
+    const rebuilt = rebuildSchemaPositions(child, stripChildAnnotations);
+    if (!isSchemaObject(rebuilt))
+        return rebuilt;
+    const kept = {};
+    for (const [key, value] of Object.entries(rebuilt))
+        if (!annotationKeys.has(key))
+            kept[key] = value;
+    return kept;
+};
+const resolveLocalReference = (root, reference) => {
+    if (reference === "#")
+        return root;
+    if (!reference.startsWith("#/"))
+        return undefined;
+    let value = root;
+    for (const token of reference.slice(2).split("/")) {
+        const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (!isSchemaObject(value) || !Object.hasOwn(value, key))
+            return undefined;
+        value = value[key];
+    }
+    return value;
+};
+/** Stop serialization at the budget before allocating an expanded schema. */
+const inlineWithinBudget = (root, budgetBytes) => {
+    let resolved = true;
+    function* serialize(value, position, active) {
+        if (Array.isArray(value)) {
+            yield "[";
+            for (const [index, child] of value.entries()) {
+                if (index > 0)
+                    yield ",";
+                yield* serialize(child, position, active);
+            }
+            yield "]";
+        }
+        else if (isSchemaObject(value)) {
+            if (position === "schema" && Object.keys(value).length === 0) {
+                yield JSON.stringify({ type: jsonValueTypes });
+                return;
+            }
+            if (position === "schema" && typeof value.$ref === "string") {
+                const target = resolveLocalReference(root, value.$ref);
+                if (target === undefined || active.has(value.$ref)) {
+                    resolved = false;
+                    return;
+                }
+                const { $ref, ...siblings } = value;
+                // Reference siblings are independent constraints in draft 2020-12.
+                // Merging their keys into the target would overwrite validation rules.
+                yield* serialize(Object.keys(siblings).length === 0
+                    ? target
+                    : { allOf: [target, siblings] }, "schema", new Set([...active, $ref]));
+                return;
+            }
+            yield "{";
+            let first = true;
+            for (const [key, child] of Object.entries(value)) {
+                if (position === "schema" && definitionKeys.has(key))
+                    continue;
+                if (!first)
+                    yield ",";
+                first = false;
+                yield JSON.stringify(key) + ":";
+                const childPosition = position === "map"
+                    ? "schema"
+                    : position === "schema" && schemaMaps.has(key)
+                        ? "map"
+                        : position === "schema" &&
+                            (schemaArrays.has(key) || schemaChildren.has(key))
+                            ? "schema"
+                            : "data";
+                yield* serialize(child, childPosition, active);
+            }
+            yield "}";
+        }
+        else {
+            yield JSON.stringify(value);
+        }
+    }
+    const chunks = [];
+    let bytes = 0;
+    for (const chunk of serialize(root, "schema", new Set())) {
+        bytes += Buffer.byteLength(chunk, "utf8");
+        if (bytes > budgetBytes || !resolved)
+            return undefined;
+        chunks.push(chunk);
+    }
+    return resolved
+        ? JSON.parse(chunks.join(""))
+        : undefined;
+};
+/** Preserve every possible type, including referenced and nullable unions. */
+const detectedTypes = (schema, root, active = new Set()) => {
+    if (!isSchemaObject(schema))
+        return undefined;
+    if (typeof schema.$ref === "string") {
+        if (active.has(schema.$ref))
+            return undefined;
+        return detectedTypes(resolveLocalReference(root, schema.$ref), root, new Set([...active, schema.$ref]));
+    }
+    if (typeof schema.type === "string")
+        return [schema.type];
+    if (Array.isArray(schema.type) &&
+        schema.type.every((type) => typeof type === "string"))
+        return schema.type;
+    const alternatives = Array.isArray(schema.anyOf)
+        ? schema.anyOf
+        : Array.isArray(schema.oneOf)
+            ? schema.oneOf
+            : [];
+    if (alternatives.length === 0)
+        return undefined;
+    const types = alternatives.map((branch) => detectedTypes(branch, root, active));
+    if (types.some((type) => type === undefined))
+        return undefined;
+    return [...new Set(types.flatMap((type) => type ?? []))];
+};
+const REDUCED_ANNOTATION = "Advertised in reduced form by the compact input schema profile; the server still validates complete canonical inputs.";
+/**
+ * Present only the root property shape with per-property guidance. Used for
+ * schemas whose validation structure alone exceeds the compact budget; the
+ * canonical schema still rejects malformed calls server-side.
+ */
+const reduceToShallowProperties = (schema) => {
+    const properties = isSchemaObject(schema.properties) ? schema.properties : {};
+    const description = [
+        typeof schema.description === "string" ? schema.description : undefined,
+        REDUCED_ANNOTATION,
+    ]
+        .filter((text) => text !== undefined)
+        .join(" ");
+    const $schema = typeof schema.$schema === "string" ? { $schema: schema.$schema } : {};
+    const shallow = Object.fromEntries(Object.entries(properties).map(([name, value]) => {
+        const types = detectedTypes(value, schema);
+        const type = types?.length === 1 ? types[0] : types;
+        const description = isSchemaObject(value) && typeof value.description === "string"
+            ? { description: value.description }
+            : {};
+        return [
+            name,
+            { ...(type === undefined ? {} : { type }), ...description },
+        ];
+    }));
+    return {
+        ...$schema,
+        type: "object",
+        description,
+        properties: shallow,
+        ...(Array.isArray(schema.required)
+            ? { required: [...schema.required] }
+            : {}),
+        ...(typeof schema.minProperties === "number"
+            ? { minProperties: schema.minProperties }
+            : {}),
+        ...(isSchemaObject(schema.dependentRequired)
+            ? { dependentRequired: { ...schema.dependentRequired } }
+            : {}),
+        ...(schema.additionalProperties === false
+            ? { additionalProperties: false }
+            : {}),
+    };
+};
+/**
+ * Render an advertised input schema within a per-schema byte budget for
+ * providers that validate the literal serialized schema size. Validation
+ * keywords and the canonical contract are preserved; only
+ * annotation prose and, for structurally oversized schemas, nested
+ * validation detail leave the advertised form.
+ */
+export const compactAdvertisedInputSchema = (schema, budgetBytes) => {
+    const inline = inlineWithinBudget(stripAnnotations(schema), budgetBytes);
+    if (inline !== undefined)
+        return { schema: inline, presentation: "inline" };
+    const reduced = reduceToShallowProperties(schema);
+    if (serializedBytes(reduced) <= budgetBytes)
+        return { schema: reduced, presentation: "reduced" };
+    // A future contract with an extreme root-property count still advertises
+    // an honest, budget-fitting shape instead of an oversized one.
+    return {
+        schema: reduceToShallowProperties({
+            type: "object",
+            description: (typeof schema.description === "string"
+                ? `${schema.description} `
+                : "") + REDUCED_ANNOTATION,
+        }),
+        presentation: "reduced",
+    };
+};

package/dist/contracts/errorSchemas.js

@@ -68,7 +68,9 @@ export const analysisCliErrorEnvelopeSchema = z
     .object({
     error: z.string().min(1),
     input_path: z.string().optional(),
-    input_reason: z.enum(["invalid-json", "read-failed"]).optional(),
+    input_reason: z
+        .enum(["invalid-json", "read-failed", "too-large"])
+        .optional(),
 })
     .passthrough()
     .superRefine((value, context) => {

package/dist/contracts/functionComparisonExample.js

@@ -5,6 +5,11 @@ const dossier = (text) => jsonValueSchema.parse({
     procedure: {
         address: "0x1000",
         name: "main",
+        classification: null,
+        body: {
+            available: false,
+            reason: "The fixture omits function-body extent observations.",
+        },
         signature: "int main(void)",
         locals: [],
     },
@@ -18,6 +23,9 @@ const dossier = (text) => jsonValueSchema.parse({
     referenced_strings: [],
     referenced_names: [],
     basic_blocks: [{ start: "0x1000", end: "0x1001", successors: [] }],
+    native_api: null,
+    native_value_flow: null,
+    limitations: ["The fixture omits native API and value-flow observations."],
 });
 const observe = (digit, text) => createEvidence({
     path: `/tmp/function-${digit}`,

package/dist/contracts/functionWorkflowToolContracts.js

@@ -24,6 +24,6 @@ const functionWorkflow = (name, description) => {
 };
 /** Function dossier and native API reconstruction workflow contracts. */
 export const FUNCTION_WORKFLOW_TOOL_CONTRACTS = [
-    functionWorkflow("analyze_function", "Build a dossier for one native function identified by symbol or provider-returned address. Returns identity with complete inclusive body ranges or explicit unknown, provider-specific pseudocode and assembly, comments, calls, references, referenced strings/names, local CFG blocks, and available native API boundary observations."),
+    functionWorkflow("analyze_function", "Build a dossier for one native function identified by symbol or provider-returned address. Returns identity with complete inclusive analyzed body ranges or explicit unknown, provider-specific pseudocode and assembly, comments, calls, references, referenced strings/names, local CFG blocks, and available native API boundary observations. Ghidra terminal-call assumptions that may cut the analyzed body are reported in limitations with available callee identities."),
     functionWorkflow("inspect_native_api", "Analyze a native API boundary in one function identified by symbol or provider-returned address. Returns confidence, evidence, jump-table dispatch/data/case mappings, separately evidenced default targets, unsupported branches, and residual unknowns. Null case values mean unresolved cases, never a known default."),
 ];