Variable PROMPT_CONTRACTSConst

PROMPT_CONTRACTS: readonly [
    {
        arguments: {
            document: PromptArgumentContract;
            feature: PromptArgumentContract;
            procedure: PromptArgumentContract;
            provider_id: PromptArgumentContract;
            target_path: PromptArgumentContract;
        };
        description: "Trace one feature from artifact and symbol discovery into bounded function evidence while preserving observations, inferences, and residual unknowns.";
        name: "investigate_feature";
        objective: "Explain how the requested feature is represented and connected without claiming recovery of original source or behavior not supported by complete evidence.";
        steps: readonly [
            {
                instruction: "Inspect provider availability and effects first. For an approved JavaScript/Electron artifact, reconstruct its application graph without execution; otherwise open target_path only when no matching target is active.";
                tools: readonly [
                    "binary_session",
                    "open_binary",
                    "analyze_javascript_application",
                ];
            },
            {
                instruction: "Select an explicitly discovered document, then establish bounded binary, language, segment, and procedure context.";
                tools: readonly [
                    "list_documents",
                    "set_current_document",
                    "binary_overview",
                ];
            },
            {
                instruction: "Search in literal mode first, follow every continuation needed for the stated scope, and resolve selected procedures to canonical addresses.";
                tools: readonly [
                    "search_strings",
                    "search_procedures",
                    "procedure_address",
                ];
            },
            {
                instruction: "When authenticated application-graph Evidence exists, trace a typed literal route, API, channel, module, string, or native export through a bounded cross-layer subgraph before native localization.";
                tools: readonly ["trace_application_feature"];
            },
            {
                instruction: "Build function dossiers and corroborate references and call relationships. Keep indirect or truncated paths unknown.";
                tools: readonly [
                    "analyze_function",
                    "xrefs",
                    "procedure_callers",
                    "procedure_callees",
                    "trace_feature",
                ];
            },
            {
                instruction: "Cite retained Evidence IDs. Record residual unknowns only after separate explicit approval for registry mutation.";
                tools: readonly ["export_evidence_bundle", "record_unknown"];
            },
        ];
        title: "Investigate a feature";
    },
    {
        arguments: {
            focus_occurrence_id: PromptArgumentContract;
            left_manifest_id: PromptArgumentContract;
            left_target_path: PromptArgumentContract;
            right_manifest_id: PromptArgumentContract;
            right_target_path: PromptArgumentContract;
        };
        description: "Compare two shipped application artifacts through complete inventory and optional static or runtime evidence without equating missing data with unchanged behavior.";
        name: "compare_application_versions";
        objective: "Identify evidence-backed artifact, function, and observed runtime differences between two versions and preserve every unresolved comparison frontier.";
        steps: readonly [
            {
                instruction: "Inventory each target independently before extraction. Follow nodes, occurrences, and edges to completion and retain every Evidence page for each manifest.";
                tools: readonly ["inventory_artifact"];
            },
            {
                instruction: "For JavaScript/Electron versions, reconstruct each approved artifact independently, optionally reconcile separately retained passive runtime Evidence, then compare authenticated graphs with unique-only identity tiers. Keep ambiguous and incomplete matches unknown.";
                tools: readonly [
                    "analyze_javascript_application",
                    "reconcile_javascript_runtime",
                    "compare_application_versions",
                ];
            },
            {
                instruction: "Resolve any supplied manifest IDs to retained inventory Evidence, validate graph commitments, then compare the complete left and right Evidence page sets.";
                tools: readonly ["export_evidence_bundle", "compare_artifacts"];
            },
            {
                instruction: "When code-level localization is required, analyze explicitly matched functions under equal limits on each target before comparing their Evidence.";
                tools: readonly ["open_binary", "analyze_function", "compare_functions"];
            },
            {
                instruction: "Keep optional controlled runtime comparisons separate from static candidates, then aggregate only compatible, complete comparison Evidence.";
                tools: readonly ["compare_process_captures", "find_changed_behavior"];
            },
            {
                instruction: "Preserve unmatched paths, incomplete pages, provider differences, and causal uncertainty; mutate the unknown registry only with explicit approval.";
                tools: readonly ["record_unknown"];
            },
        ];
        title: "Compare application versions";
    },
    {
        arguments: {
            comparison_evidence_id: PromptArgumentContract;
            provider_id: PromptArgumentContract;
            reconstruction_goal: PromptArgumentContract;
        };
        description: "Evaluate a finite reconstruction specification against retained Evidence v2 comparisons without broadening pass results into global equivalence claims.";
        name: "verify_reconstruction";
        objective: "Produce per-claim pass, fail, or unknown results backed by compatible comparison Evidence and exact authority requirements.";
        steps: readonly [
            {
                instruction: "Load the current canonical bundle and verify that every selected comparison Evidence ID is present and compatible with the intended claim.";
                tools: readonly ["export_evidence_bundle"];
            },
            {
                instruction: "Produce any missing bounded comparison Evidence under equal scopes; incomplete comparison dimensions must remain unknown.";
                tools: readonly [
                    "compare_artifacts",
                    "compare_functions",
                    "compare_process_captures",
                ];
            },
            {
                instruction: "Construct a finite typed specification and verify it against the complete bundle. Interpret pass only for the declared claim and dimension.";
                tools: readonly ["verify_reconstruction"];
            },
            {
                instruction: "Report verification unknowns and the authority needed to resolve them. Persist new registry entries only with explicit approval.";
                tools: readonly ["list_unknowns", "record_unknown"];
            },
        ];
        title: "Verify a reconstruction";
    },
    {
        arguments: {
            capture_evidence_id: PromptArgumentContract;
            crash_signal: PromptArgumentContract;
            document: PromptArgumentContract;
            procedure: PromptArgumentContract;
            target_path: PromptArgumentContract;
        };
        description: "Correlate a crash symptom with bounded static call and reference evidence plus optional approved Process Capture v4 observations.";
        name: "trace_crash";
        objective: "Localize plausible crash paths while separating observed runtime failure, static reachability, inferred causality, and unobserved paths.";
        steps: readonly [
            {
                instruction: "Confirm target and provider state before opening or analyzing the crash target.";
                tools: readonly ["binary_session", "open_binary", "binary_overview"];
            },
            {
                instruction: "Resolve crash text or addresses to bounded function dossiers; do not infer a source location from symbol similarity alone.";
                tools: readonly [
                    "search_strings",
                    "search_procedures",
                    "resolve_containing_procedure",
                    "analyze_function",
                ];
            },
            {
                instruction: "Trace corroborated references and caller paths, preserving indirect-call, depth, and pagination frontiers as unknown.";
                tools: readonly ["xrefs", "procedure_callers", "build_call_path"];
            },
            {
                instruction: "Reuse a retained capture when supplied. Otherwise capture only after operator policy and per-call approval, then correlate through explicit hypotheses rather than timing or name coincidence.";
                tools: readonly [
                    "export_evidence_bundle",
                    "capture_process_scenario",
                    "correlate_static_and_runtime",
                ];
            },
            {
                instruction: "Separate the observed crash from inferred cause and record missing reproduction or authority only with explicit registry approval.";
                tools: readonly ["record_unknown"];
            },
        ];
        title: "Trace a crash";
    },
    {
        arguments: {
            audit_scope: PromptArgumentContract;
            evidence_id: PromptArgumentContract;
            unknown_id: PromptArgumentContract;
        };
        description: "Review current residual-unknown heads against retained evidence, revision integrity, and declared authority without silently closing unanswered questions.";
        name: "audit_residual_unknowns";
        objective: "Determine which unknowns remain open, contradicted, blocked, or truthfully resolved and identify the smallest evidence-producing next probes.";
        steps: readonly [
            {
                instruction: "List current heads first and select only active, session-owned unknown IDs. Preserve their exact revision and requirements.";
                tools: readonly ["list_unknowns"];
            },
            {
                instruction: "Inspect cited supporting, contradicting, and mutation Evidence, then validate any resolved head against bundle integrity and authority requirements.";
                tools: readonly ["export_evidence_bundle", "verify_unknown_resolution"];
            },
            {
                instruction: "Propose a full compare-and-swap update only when evidence supports it. Require explicit approval and the current expected_revision before mutation.";
                tools: readonly ["update_unknown"];
            },
            {
                instruction: "When the audit exposes a distinct unanswered question, recommend bounded probes first and create a new record only with explicit approval.";
                tools: readonly ["record_unknown"];
            },
        ];
        title: "Audit residual unknowns";
    },
    {
        arguments: {
            behavior_question: PromptArgumentContract;
            executable: PromptArgumentContract;
            prior_capture_evidence_id: PromptArgumentContract;
            working_directory: PromptArgumentContract;
        };
        description: "Design an approval-gated Process Capture v4 scenario with exact executable, filesystem, environment, network, replay, timeout, and cleanup boundaries.";
        name: "prepare_bounded_process_capture";
        objective: "Prepare and, only after authorization, run the smallest controlled process experiment that can answer the stated behavioral question.";
        steps: readonly [
            {
                instruction: "Inspect capture capability, declared effects, and limits before proposing execution. An unavailable capability is not permission to widen policy.";
                tools: readonly ["binary_session"];
            },
            {
                instruction: "Review any prior capture for unanswered dimensions, truncation, scenario commitments, and descendant settlement before designing a repeat.";
                tools: readonly ["export_evidence_bundle"];
            },
            {
                instruction: "Present exact executable and working roots, filesystem roots, environment names without secret values, host-network effects, scripted events, replay peers, byte/time/process limits, and cleanup expectations. Run only with operator policy plus approved: true.";
                tools: readonly ["capture_process_scenario"];
            },
            {
                instruction: "When a prior compatible capture exists, compare complete Process Capture v4 observations under recorded normalization and freshness requirements.";
                tools: readonly ["compare_process_captures"];
            },
            {
                instruction: "Treat sampling gaps, truncated output, external behavior, and cleanup uncertainty as residual unknowns; persist them only with separate explicit approval.";
                tools: readonly ["record_unknown"];
            },
        ];
        title: "Prepare a bounded process capture";
    },
] = ...