@slicedearth/whoisleuth-cli 2.0.1 → 2.2.0

package/cli/history-command-runner.mjs

@@ -0,0 +1,132 @@
+import { Buffer } from 'node:buffer';
+import { boundedCliErrorMessage, CliUsageError } from "./errors.mjs";
+import EXIT_CODES from "./exit-codes.mjs";
+import { buildCliEvidenceExport, formatCliEvidenceExport } from "./export-evidence.mjs";
+import { formatJsonDocument } from "./formatters/json.mjs";
+import { formatLookupEvidenceHtml } from "./formatters/html.mjs";
+import { formatLookupEvidenceMarkdown } from "./formatters/markdown.mjs";
+import { MAX_LOOKUP_RECONCILIATION_INPUT_BYTES, buildCliLookupReconciliation, formatCliLookupReconciliation, } from "./lookup-reconcile.mjs";
+import { MAX_LOOKUP_TIMELINE_INPUT_BYTES, buildCliLookupTimeline, formatCliLookupTimeline, } from "./lookup-timeline.mjs";
+import { MAX_RETAINED_ARTIFACT_DIFF_BYTES, buildCliRetainedArtifactDiff, formatCliRetainedArtifactDiff, } from "./retained-artifact-diff.mjs";
+import { MAX_SAVED_LOOKUP_INPUT_BYTES } from "./saved-lookup.mjs";
+import { HISTORY_INLINE_COMMANDS } from "./inline-command-families.mjs";
+import { runDiscriminatedCommandHandler } from "./discriminated-command-handlers.mjs";
+async function runRetainedDiffCommand(args, dependencies, context) {
+    context.setFailureLabel('Retained artifact diff');
+    const readDiffInput = dependencies.readDiffInput
+        || ((source) => context.readInput(source, MAX_RETAINED_ARTIFACT_DIFF_BYTES, 'Retained diff input'));
+    let leftInput;
+    let rightInput;
+    try {
+        [leftInput, rightInput] = await Promise.all([
+            readDiffInput(args.leftSource),
+            readDiffInput(args.rightSource),
+        ]);
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read retained diff input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    const document = buildCliRetainedArtifactDiff(leftInput, rightInput, { leftSessionId: args.leftSessionId, rightSessionId: args.rightSessionId }, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(document)
+            : context.terminal(formatCliRetainedArtifactDiff(document), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runReconciliationCommand(args, dependencies, context) {
+    context.setFailureLabel('Lookup observation reconciliation');
+    const readReconciliationInput = dependencies.readDiffInput
+        || ((source) => context.readInput(source, MAX_SAVED_LOOKUP_INPUT_BYTES, 'Lookup reconciliation input'));
+    const inputs = [];
+    let totalBytes = 0;
+    try {
+        for (const source of args.sources) {
+            const input = await readReconciliationInput(source);
+            totalBytes += Buffer.byteLength(input, 'utf8');
+            if (totalBytes > MAX_LOOKUP_RECONCILIATION_INPUT_BYTES) {
+                throw new CliUsageError(`Lookup reconciliation input is limited to ${MAX_LOOKUP_RECONCILIATION_INPUT_BYTES} bytes in total.`);
+            }
+            inputs.push(input);
+        }
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read Lookup reconciliation input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    const document = buildCliLookupReconciliation(inputs, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(document)
+            : context.terminal(formatCliLookupReconciliation(document), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runTimelineCommand(args, dependencies, context) {
+    context.setFailureLabel('Lookup observation timeline');
+    const readTimelineInput = dependencies.readDiffInput
+        || ((source) => context.readInput(source, MAX_SAVED_LOOKUP_INPUT_BYTES, 'Lookup timeline input'));
+    const inputs = [];
+    let totalBytes = 0;
+    try {
+        for (const source of args.sources) {
+            const input = await readTimelineInput(source);
+            totalBytes += Buffer.byteLength(input, 'utf8');
+            if (totalBytes > MAX_LOOKUP_TIMELINE_INPUT_BYTES) {
+                throw new CliUsageError(`Lookup timeline input is limited to ${MAX_LOOKUP_TIMELINE_INPUT_BYTES} bytes in total.`);
+            }
+            inputs.push(input);
+        }
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read Lookup timeline input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    const document = buildCliLookupTimeline(inputs, context.now());
+    if (!args.quiet) {
+        context.writeStdout(args.output === 'json'
+            ? formatJsonDocument(document)
+            : context.terminal(formatCliLookupTimeline(document), args.color));
+    }
+    return EXIT_CODES.SUCCESS;
+}
+async function runExportCommand(args, dependencies, context) {
+    context.setFailureLabel('Evidence export');
+    let input;
+    try {
+        input = dependencies.readExportInput
+            ? await dependencies.readExportInput(args.source)
+            : await context.readInput(args.source, MAX_SAVED_LOOKUP_INPUT_BYTES, 'Evidence export input');
+    }
+    catch (error) {
+        if (error instanceof CliUsageError)
+            throw error;
+        throw new CliUsageError(`Could not read evidence export input: ${boundedCliErrorMessage(error, 'Input could not be read')}`);
+    }
+    if (!input.trim())
+        throw new CliUsageError('export requires one lookup JSON file or a lookup document on stdin.');
+    const loadEvidence = dependencies.loadEvidenceExport || (() => import("../lib/evidence-export.mjs"));
+    const evidenceModule = await loadEvidence();
+    const document = buildCliEvidenceExport(input, evidenceModule, context.now());
+    const output = args.format === 'markdown'
+        ? formatLookupEvidenceMarkdown(document, { includeAttribution: args.includeAttribution })
+        : args.format === 'html'
+            ? formatLookupEvidenceHtml(document, { includeAttribution: args.includeAttribution })
+            : formatCliEvidenceExport(document, args.compact);
+    context.writeStdout(output);
+    return EXIT_CODES.SUCCESS;
+}
+const HISTORY_COMMAND_HANDLERS = Object.freeze({
+    'diff': runRetainedDiffCommand,
+    'reconcile': runReconciliationCommand,
+    'timeline': runTimelineCommand,
+    'export': runExportCommand,
+});
+function runHistoryCommand(args, dependencies, context) {
+    return runDiscriminatedCommandHandler(HISTORY_COMMAND_HANDLERS, args, dependencies, context);
+}
+export { HISTORY_COMMAND_HANDLERS, runHistoryCommand };

package/cli/inline-command-families.mjs

@@ -0,0 +1,45 @@
+const SUPPORT_INLINE_COMMANDS = Object.freeze([
+    'completion',
+    'commands',
+    'manual',
+    'doctor',
+    'registry-support',
+    'registry-doctor',
+    'registry-cohort',
+    'registry-scaffold',
+    'risk-calibrate',
+    'lookalike-calibrate',
+]);
+const REVIEW_INLINE_COMMANDS = Object.freeze([
+    'verify-artifact',
+    'interchange-report',
+    'source-report',
+    'compare',
+    'page-compare',
+    'mail-review',
+    'review-evidence',
+    'brief',
+    'case-pack',
+]);
+const ASSURANCE_INLINE_COMMANDS = Object.freeze([
+    'manifest',
+    'map-observations',
+    'oam-export',
+    'domain-control',
+    'assurance',
+    'change-packet',
+    'sharing-review',
+    'ct-intake',
+]);
+const WORKFLOW_INLINE_COMMANDS = Object.freeze([
+    'monitor-once',
+    'workflow-plan',
+    'workflow-run',
+]);
+const HISTORY_INLINE_COMMANDS = Object.freeze([
+    'diff',
+    'reconcile',
+    'timeline',
+    'export',
+]);
+export { ASSURANCE_INLINE_COMMANDS, HISTORY_INLINE_COMMANDS, REVIEW_INLINE_COMMANDS, SUPPORT_INLINE_COMMANDS, WORKFLOW_INLINE_COMMANDS, };

package/cli/inline-command-runner.mjs

@@ -0,0 +1,55 @@
+import { CLI_COMMANDS, commandDefinition } from "./command-reference.mjs";
+import { ASSURANCE_INLINE_COMMANDS, HISTORY_INLINE_COMMANDS, REVIEW_INLINE_COMMANDS, SUPPORT_INLINE_COMMANDS, WORKFLOW_INLINE_COMMANDS, } from "./inline-command-families.mjs";
+const FAMILY_COMMANDS = Object.freeze([
+    Object.freeze({ family: 'support', commands: SUPPORT_INLINE_COMMANDS }),
+    Object.freeze({ family: 'review', commands: REVIEW_INLINE_COMMANDS }),
+    Object.freeze({ family: 'assurance', commands: ASSURANCE_INLINE_COMMANDS }),
+    Object.freeze({ family: 'workflow', commands: WORKFLOW_INLINE_COMMANDS }),
+    Object.freeze({ family: 'history', commands: HISTORY_INLINE_COMMANDS }),
+]);
+function buildInlineCommandOwnership() {
+    const ownership = new Map();
+    for (const { family, commands } of FAMILY_COMMANDS) {
+        for (const command of commands) {
+            if (ownership.has(command))
+                throw new Error(`Inline CLI command ${command} has more than one command-family owner.`);
+            ownership.set(command, family);
+        }
+    }
+    return ownership;
+}
+const INLINE_COMMAND_OWNERSHIP = buildInlineCommandOwnership();
+const INLINE_CLI_COMMANDS = Object.freeze(CLI_COMMANDS.filter((command) => commandDefinition(command).execution.handlerOwner === 'inline'));
+function validateInlineCommandOwnership() {
+    const missing = INLINE_CLI_COMMANDS.filter((command) => !INLINE_COMMAND_OWNERSHIP.has(command));
+    const unexpected = [...INLINE_COMMAND_OWNERSHIP.keys()].filter((command) => !INLINE_CLI_COMMANDS.includes(command));
+    if (missing.length || unexpected.length) {
+        throw new Error(`Inline CLI command-family ownership is inconsistent (missing: ${missing.join(', ') || 'none'}; unexpected: ${unexpected.join(', ') || 'none'}).`);
+    }
+}
+validateInlineCommandOwnership();
+async function runInlineCommand(args, dependencies, context) {
+    const family = INLINE_COMMAND_OWNERSHIP.get(args.action);
+    if (family === 'support') {
+        const { runSupportCommand } = await import("./support-command-runner.mjs");
+        return runSupportCommand(args, dependencies, context);
+    }
+    if (family === 'review') {
+        const { runReviewCommand } = await import("./review-command-runner.mjs");
+        return runReviewCommand(args, dependencies, context);
+    }
+    if (family === 'assurance') {
+        const { runAssuranceCommand } = await import("./assurance-command-runner.mjs");
+        return runAssuranceCommand(args, dependencies, context);
+    }
+    if (family === 'workflow') {
+        const { runWorkflowCommand } = await import("./workflow-command-runner.mjs");
+        return runWorkflowCommand(args, dependencies, context);
+    }
+    if (family === 'history') {
+        const { runHistoryCommand } = await import("./history-command-runner.mjs");
+        return runHistoryCommand(args, dependencies, context);
+    }
+    throw new Error('No inline CLI command-family route is registered for the parsed command.');
+}
+export { FAMILY_COMMANDS, INLINE_CLI_COMMANDS, runInlineCommand, };

package/cli/investigation-plan.mjs

@@ -13,7 +13,10 @@ const RECIPES = Object.freeze({
         subjectRequirement: 'domain',
         objective: 'Collect and preserve separately attributed registration, DNS, HTTP, TLS, page, and network-context evidence.',
         runnable: true,
-        limitations: Object.freeze(['Collection remains analyst-triggered and source limitations remain explicit.']),
+        limitations: Object.freeze([
+            'Collection remains analyst-triggered and source limitations remain explicit.',
+            'Disposition, reviewed response actions, monitoring, and closure continue in the browser-local Case workspace; this CLI recipe does not submit reports.',
+        ]),
         steps: (domain) => Object.freeze([
             step('collect', 'Collect a Deep lookup', 'lookup', [domain, '--deep', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.lookup', 'Review source health and limitations before using missing fields.'),
             step('export', 'Create a portable evidence report', 'export', ['<saved-lookup.json>'], 'offline', 'analyst_selection', 'whoisleuth.lookup-evidence', 'Select the reviewed lookup file; the plan never guesses a path.'),
@@ -26,7 +29,10 @@ const RECIPES = Object.freeze({
         subjectRequirement: 'brand_or_domain',
         objective: 'Generate a bounded candidate queue, collect only the selected scope, and retain a reviewed candidate lookup.',
         runnable: true,
-        limitations: Object.freeze(['Candidate generation does not establish registration, control, intent, or maliciousness.']),
+        limitations: Object.freeze([
+            'Candidate generation does not establish registration, control, intent, or maliciousness.',
+            'Official-reference collection and page comparison require analyst-selected saved evidence; use page-compare after retaining the reference and candidate observations.',
+        ]),
         steps: (subject) => Object.freeze([
             step('generate', 'Generate candidates offline', 'discover', [subject, '--preset', 'all', '--json'], 'offline', 'none', 'whoisleuth.cli.discover', 'Review mutation families and suppressions before collection.'),
             step('scan', 'Collect a bounded candidate queue', 'discover-scan', [subject, '--fast', '--scan-limit', '50', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.discovery-scan', 'Fast collection is a triage boundary; partial or inconclusive authority evidence remains explicit.'),
@@ -238,6 +244,7 @@ export function buildInvestigationPlan(recipeId, subjectValue, generatedAtValue
         execution: 'plan_only',
         steps,
         limitations: Object.freeze([
+            ...recipe.limitations,
             'This document is a fixed plan. It does not execute commands, expand placeholders, make requests, read files, change cases, or submit reports.',
             'Network steps require deliberate execution and disclose the selected target to the sources described by that command.',
             'Analyst-selection steps require reviewed local artefacts; placeholders are never interpreted as file paths by this planner.',

package/cli/investigation-run.mjs

@@ -1,11 +1,15 @@
 import { Buffer } from 'node:buffer';
 import { buildInvestigationPlan, isRunnableInvestigationRecipe, } from "./investigation-plan.mjs";
 import { CliUsageError } from "./errors.mjs";
+import { hasUnsafeCliText } from "./errors.mjs";
 import EXIT_CODES from "./exit-codes.mjs";
 import { scanBoundedJson } from "../lib/bounded-json.mjs";
 export const CLI_INVESTIGATION_RUN_SCHEMA = 'whoisleuth.cli.investigation-run';
-export const CLI_INVESTIGATION_RUN_VERSION = 1;
+export const CLI_INVESTIGATION_RUN_VERSION = 2;
 export const MAX_INVESTIGATION_RUN_BYTES = 24 * 1024 * 1024;
+export const MAX_INVESTIGATION_RUN_SELECTIONS = 16;
+export const MAX_INVESTIGATION_RUN_SELECTION_LENGTH = 1_024;
+const PLACEHOLDER_PATTERN = /^<[^>]+>$/u;
 function boundedResult(value) {
     if (Buffer.byteLength(value, 'utf8') > MAX_INVESTIGATION_RUN_BYTES) {
         throw new CliUsageError(`Investigation step output is limited to ${MAX_INVESTIGATION_RUN_BYTES} bytes.`);
@@ -31,9 +35,95 @@ function sameArguments(left, right) {
         && left.length === right.length
         && left.every((value, index) => typeof value === 'string' && value === right[index]);
 }
+function selectedArguments(step, values) {
+    let selectionIndex = 0;
+    return Object.freeze(step.arguments.map((argument) => {
+        if (!PLACEHOLDER_PATTERN.test(argument))
+            return argument;
+        const selected = values[selectionIndex];
+        selectionIndex += 1;
+        return selected ?? argument;
+    }));
+}
+function selectedStep(step, values) {
+    return Object.freeze({ ...step, arguments: selectedArguments(step, values) });
+}
+function placeholderCount(step) {
+    return step.arguments.filter((argument) => PLACEHOLDER_PATTERN.test(argument)).length;
+}
+function validateSelectionValue(value) {
+    return typeof value === 'string'
+        && value.length > 0
+        && value.length <= MAX_INVESTIGATION_RUN_SELECTION_LENGTH
+        && Boolean(value.trim())
+        && !value.startsWith('-')
+        && !hasUnsafeCliText(value);
+}
+function normalizeRetainedSelections(plan, value, label) {
+    if (!Array.isArray(value) || value.length > MAX_INVESTIGATION_RUN_SELECTIONS) {
+        throw new CliUsageError(`${label} must contain at most ${MAX_INVESTIGATION_RUN_SELECTIONS} bounded analyst selections.`);
+    }
+    const plannedById = new Map(plan.steps.map((step) => [step.id, step]));
+    const seen = new Set();
+    const retained = [];
+    for (const itemValue of value) {
+        if (!itemValue || typeof itemValue !== 'object' || Array.isArray(itemValue)) {
+            throw new CliUsageError(`${label} contains a malformed analyst selection.`);
+        }
+        const item = itemValue;
+        if (Object.keys(item).length !== 2 || !Object.hasOwn(item, 'stepId') || !Object.hasOwn(item, 'values')) {
+            throw new CliUsageError(`${label} contains a malformed analyst selection.`);
+        }
+        const stepId = typeof item.stepId === 'string' ? item.stepId : '';
+        const planned = plannedById.get(stepId);
+        if (!planned || seen.has(stepId) || placeholderCount(planned) === 0 || !Array.isArray(item.values)) {
+            throw new CliUsageError(`${label} does not match the installed fixed recipe.`);
+        }
+        if (item.values.length === 0 || item.values.length > placeholderCount(planned)
+            || item.values.some((selection) => !validateSelectionValue(selection))) {
+            throw new CliUsageError(`${label} contains an invalid value for step ${stepId}.`);
+        }
+        seen.add(stepId);
+        retained.push(Object.freeze({ stepId, values: Object.freeze([...item.values]) }));
+    }
+    return plan.steps.flatMap((step) => {
+        const selection = retained.find((item) => item.stepId === step.id);
+        return selection ? [selection] : [];
+    });
+}
+function normalizeInvocationSelections(plan, selections) {
+    if (!Array.isArray(selections) || selections.length > MAX_INVESTIGATION_RUN_SELECTIONS) {
+        throw new CliUsageError(`workflow-run accepts at most ${MAX_INVESTIGATION_RUN_SELECTIONS} analyst selections.`);
+    }
+    const grouped = new Map();
+    for (const item of selections) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)
+            || typeof item.stepId !== 'string' || !validateSelectionValue(item.value)) {
+            throw new CliUsageError('workflow-run selections must use bounded <step-id>=<path-or-value> entries whose values do not start with a hyphen.');
+        }
+        const values = grouped.get(item.stepId) ?? [];
+        values.push(item.value);
+        grouped.set(item.stepId, values);
+    }
+    return normalizeRetainedSelections(plan, [...grouped].map(([stepId, values]) => ({ stepId, values })), 'workflow-run selections');
+}
+function mergeSelections(plan, retained, supplied, completed) {
+    const merged = new Map(retained.map((item) => [item.stepId, item.values]));
+    for (const item of supplied) {
+        const completedStep = completed.find((step) => step.id === item.stepId);
+        if (completedStep && !sameArguments(completedStep.arguments, selectedArguments(plan.steps.find((step) => step.id === item.stepId), item.values))) {
+            throw new CliUsageError(`workflow-run cannot change analyst selections for completed step ${item.stepId}.`);
+        }
+        merged.set(item.stepId, item.values);
+    }
+    return plan.steps.flatMap((step) => {
+        const values = merged.get(step.id);
+        return values ? [Object.freeze({ stepId: step.id, values: Object.freeze([...values]) })] : [];
+    });
+}
 function parseResumeState(input, plan) {
     if (!input)
-        return [];
+        return Object.freeze({ completed: Object.freeze([]), selections: Object.freeze([]) });
     if (Buffer.byteLength(input, 'utf8') > MAX_INVESTIGATION_RUN_BYTES)
         throw new CliUsageError('Investigation resume state exceeds the 24 MiB limit.');
     const normalizedInput = input.replace(/^\uFEFF/u, '');
@@ -54,15 +144,25 @@ function parseResumeState(input, plan) {
         throw new CliUsageError('Investigation resume state must be valid JSON.');
     }
     const root = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
-    if (root.schema !== CLI_INVESTIGATION_RUN_SCHEMA || root.version !== CLI_INVESTIGATION_RUN_VERSION || root.recipe !== plan.recipe.id || root.subject !== plan.subject || !Array.isArray(root.completedSteps)) {
+    if (root.schema !== CLI_INVESTIGATION_RUN_SCHEMA
+        || (root.version !== 1 && root.version !== CLI_INVESTIGATION_RUN_VERSION)
+        || root.recipe !== plan.recipe.id || root.subject !== plan.subject || !Array.isArray(root.completedSteps)) {
         throw new CliUsageError('Investigation resume state must match this versioned recipe and subject.');
     }
+    const selections = root.version === 1
+        ? Object.freeze([])
+        : Object.freeze(normalizeRetainedSelections(plan, root.selections, 'Investigation resume state'));
+    if (root.version === 1 && root.selections !== undefined) {
+        throw new CliUsageError('Investigation resume state version 1 cannot contain analyst selections.');
+    }
+    const selectionsByStep = new Map(selections.map((item) => [item.stepId, item.values]));
     if (root.completedSteps.length > plan.steps.length) {
         throw new CliUsageError('Investigation resume state contains more steps than the installed fixed recipe.');
     }
     const completed = [];
     for (const [index, value] of root.completedSteps.entries()) {
-        const planned = plan.steps[index];
+        const baseStep = plan.steps[index];
+        const planned = baseStep ? selectedStep(baseStep, selectionsByStep.get(baseStep.id) ?? []) : null;
         if (!planned || !value || typeof value !== 'object' || Array.isArray(value)) {
             throw new CliUsageError('Investigation resume state contains a malformed or out-of-order step.');
         }
@@ -93,7 +193,7 @@ function parseResumeState(input, plan) {
             result: item.result,
         }));
     }
-    return completed;
+    return Object.freeze({ completed: Object.freeze(completed), selections });
 }
 export async function runInvestigationRecipe(recipe, subjectValue, options) {
     if (!isRunnableInvestigationRecipe(recipe)) {
@@ -101,11 +201,15 @@ export async function runInvestigationRecipe(recipe, subjectValue, options) {
     }
     const plan = buildInvestigationPlan(recipe, subjectValue, options.generatedAt);
     const prior = parseResumeState(options.resumeInput, plan);
-    const completed = [...prior];
+    const suppliedSelections = normalizeInvocationSelections(plan, options.selections ?? []);
+    const selections = mergeSelections(plan, prior.selections, suppliedSelections, prior.completed);
+    const selectionsByStep = new Map(selections.map((item) => [item.stepId, item.values]));
+    const completed = [...prior.completed];
     let state = 'complete';
     let currentStep = null;
-    for (const step of plan.steps) {
+    for (const baseStep of plan.steps) {
         options.signal?.throwIfAborted();
+        const step = selectedStep(baseStep, selectionsByStep.get(baseStep.id) ?? []);
         if (completed.some((item) => item.id === step.id))
             continue;
         currentStep = step;
@@ -147,12 +251,13 @@ export async function runInvestigationRecipe(recipe, subjectValue, options) {
         subject: plan.subject,
         state,
         networkApprovedForThisRun: options.approveNetwork,
+        selections: Object.freeze(selections),
         completedSteps: Object.freeze(completed),
         currentStep,
         limitations: Object.freeze([
             'Only commands and arguments from the installed fixed recipe can execute; no shell, script, arbitrary command, or enforcement action is accepted.',
-            'Network steps run only with --approve-network for the current invocation. Analyst-selection placeholders always pause and are never interpreted as paths or values.',
-            'A resume file is a local checkpoint, not proof that prior evidence remains current or that a human reviewed each stored result.',
+            'Network steps run only with --approve-network for the current invocation. Unresolved analyst selections pause; supplied values replace exact placeholders and are passed as arguments without shell interpretation.',
+            'A resume file is a local checkpoint and can retain selected local paths or values. It is not proof that prior evidence remains current or that a human reviewed each stored result.',
         ]),
     });
 }