@phyzess/pappra 0.1.0-beta.13 → 0.1.0-beta.18

package/dist/app/automatic-handoff-events.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { canonicalJson } from '../collab/envelope.js';
+import { readBoundedFile } from './bounded-file.js';
+import { tickAutomaticHandoff, } from './collab-auto-handoff.js';
+export function loadAutomaticHandoffConfig(file) {
+    const loaded = readBoundedFile(file, 64 * 1024);
+    if (!loaded.ok)
+        throw new Error('automatic_handoff_config_unreadable');
+    const value = JSON.parse(loaded.text);
+    if (!value ||
+        value.schema !== 'pappra/automatic-handoff/1' ||
+        !value.transition ||
+        !path.isAbsolute(value.transition.task_root))
+        throw new Error('automatic_handoff_config_invalid');
+    if (value.sourceReadiness !== undefined) {
+        const readiness = value.sourceReadiness;
+        const keys = ['assignmentFile', 'templateFile', 'cardFile'];
+        if (!readiness ||
+            typeof readiness !== 'object' ||
+            Array.isArray(readiness) ||
+            Object.keys(readiness).some((key) => !keys.includes(key)) ||
+            !keys.every((key) => typeof readiness[key] === 'string' && path.isAbsolute(readiness[key])) ||
+            new Set(keys.map((key) => path.resolve(readiness[key]))).size !==
+                keys.length)
+            throw new Error('automatic_handoff_source_readiness_invalid');
+    }
+    return value;
+}
+/** A native settled event or registered task update advances one guarded transition. */
+export function watchAutomaticHandoff(config, runtime, dependencies = {}, onRetirement) {
+    const directory = config.transition.task_root;
+    const pin = fs.lstatSync(directory);
+    if (!pin.isDirectory() ||
+        pin.isSymbolicLink() ||
+        fs.realpathSync(directory) !== directory)
+        throw new Error('automatic_handoff_task_redirected');
+    let closed = false;
+    let pending = false;
+    let running = false;
+    let active = Promise.resolve();
+    let last = null;
+    let error = null;
+    let previousCause = null;
+    let completion = null;
+    let resolveCompleted;
+    const completed = new Promise((resolve) => {
+        resolveCompleted = resolve;
+    });
+    const refresh = () => {
+        if (closed)
+            return active;
+        pending = true;
+        if (running)
+            return active;
+        running = true;
+        active = (async () => {
+            try {
+                while (pending && !closed) {
+                    pending = false;
+                    const now = fs.lstatSync(directory);
+                    if (now.dev !== pin.dev ||
+                        now.ino !== pin.ino ||
+                        now.isSymbolicLink())
+                        throw new Error('automatic_handoff_task_changed');
+                    const task = readBoundedFile(path.join(directory, 'task.json'), 8 * 1024 * 1024);
+                    if (!task.ok)
+                        throw new Error('automatic_handoff_task_unreadable');
+                    const state = JSON.parse(task.text);
+                    delete state.automatic_handoff_journal;
+                    delete state.session_transition_journal;
+                    delete state.state_revision;
+                    delete state.updated_at;
+                    const cause = crypto
+                        .createHash('sha256')
+                        .update(canonicalJson({ state, observation: runtime.observe() }))
+                        .digest('hex');
+                    if (cause === previousCause)
+                        continue;
+                    previousCause = cause;
+                    last = await tickAutomaticHandoff(config, runtime, dependencies);
+                    if (last.status === 'complete') {
+                        try {
+                            await onRetirement?.(last);
+                            completion = { ok: true };
+                        }
+                        catch {
+                            error = 'automatic_handoff_retirement_failed';
+                            completion = { ok: false, code: error };
+                        }
+                        closed = true;
+                        watcher.close();
+                        unsubscribe();
+                        resolveCompleted(completion);
+                    }
+                }
+            }
+            catch {
+                error = 'automatic_handoff_event_failed';
+            }
+            finally {
+                running = false;
+            }
+        })();
+        return active;
+    };
+    const watcher = fs.watch(directory, (_event, name) => {
+        if (name === null || name.toString() === 'task.json')
+            void refresh();
+    });
+    watcher.on('error', () => {
+        error = 'automatic_handoff_watch_failed';
+    });
+    const unsubscribe = runtime.subscribe((event) => {
+        if (typeof event === 'object' &&
+            event !== null &&
+            'type' in event &&
+            event.type === 'agent_settled')
+            void refresh();
+    });
+    // Startup also reconciles a durable prior transition; it never recaptures a reserved summary.
+    void refresh();
+    return {
+        refresh,
+        completed,
+        status: () => ({ result: last, error, completion }),
+        close() {
+            closed = true;
+            watcher.close();
+            unsubscribe();
+        },
+    };
+}

package/dist/app/bounded-file.d.ts

@@ -0,0 +1,2 @@
+/** Shared descriptor-bounded reads live in infrastructure. */
+export * from '../infra/bounded-file.js';

package/dist/app/bounded-file.js

@@ -0,0 +1,2 @@
+/** Shared descriptor-bounded reads live in infrastructure. */
+export * from '../infra/bounded-file.js';

package/dist/app/capability-evidence/claude.d.ts

@@ -0,0 +1,37 @@
+import type { Assignment, CapabilityCard } from '../../collab/contracts.js';
+import { type CapabilityDerivation } from './shared.js';
+interface ClaudeCall {
+    readonly id: string;
+    readonly name: string;
+    readonly input?: Record<string, unknown>;
+}
+interface ClaudeResult {
+    readonly is_error?: boolean;
+}
+export interface ClaudeNativeExecution {
+    readonly rows: Record<string, unknown>[];
+    readonly execution: Record<string, unknown>;
+    readonly init: Record<string, unknown>;
+    readonly result: Record<string, unknown>;
+    readonly calls: Map<string, ClaudeCall>;
+    readonly results: Map<string, ClaudeResult>;
+    readonly injections: Map<string, string>;
+    readonly evidenceRecords: {
+        ref: string;
+        digest: string;
+    }[];
+}
+export interface ClaudeEvidenceOptions {
+    readonly eventsFile: string;
+    readonly executionFile: string;
+    readonly sessionId: string;
+    readonly cwd: string;
+}
+export declare function readClaudeExecution(options: ClaudeEvidenceOptions): ClaudeNativeExecution;
+export declare function deriveClaudeCard(options: {
+    readonly assignment: Assignment;
+    readonly template: CapabilityCard;
+    readonly eventsFile: string;
+    readonly executionFile: string;
+}): CapabilityDerivation;
+export {};

package/dist/app/capability-evidence/claude.js

@@ -0,0 +1,206 @@
+import path from 'node:path';
+import { assertTemplateIdentity, deriveOutcome, evidenceRecords, fail, fingerprintTemplateSkill, isTimestamp, parseExecution, readNativeEvidence, realPath, record, samePath, } from './shared.js';
+/**
+ * Derive a runtime capability card from a saved Claude CLI stream.
+ *
+ * Preserved maintained semantics: a discovery/bootstrap execution may only use
+ * Read and Skill; successful call/result correlation is required for `verified`;
+ * a skill is `verified` only when the injected base directory matches the
+ * fingerprinted skill source. Unknown or unobserved states stay unknown.
+ */
+const MAX_CLAUDE_EVENTS = 10000;
+function stringArray(value) {
+    if (!Array.isArray(value) ||
+        value.some((item) => typeof item !== 'string') ||
+        new Set(value).size !== value.length)
+        return fail('unsupported_native_tools');
+    return value;
+}
+export function readClaudeExecution(options) {
+    const eventsBytes = readNativeEvidence(options.eventsFile);
+    const executionBytes = readNativeEvidence(options.executionFile);
+    let rows;
+    let execution;
+    try {
+        const lines = eventsBytes.text.trim().split('\n');
+        if (lines.length > MAX_CLAUDE_EVENTS)
+            fail('event_limit');
+        rows = lines.map((line) => {
+            const value = JSON.parse(line);
+            if (!record(value))
+                fail('unsupported_event_shape');
+            return value;
+        });
+        execution = parseExecution(executionBytes.text);
+    }
+    catch {
+        return fail('invalid_native_json');
+    }
+    if (execution.status !== 'exited' || execution.exit_code !== 0)
+        fail('native_process_not_successfully_exited');
+    if (!isTimestamp(execution.started_at) ||
+        !isTimestamp(execution.finished_at) ||
+        Date.parse(execution.finished_at) <
+            Date.parse(execution.started_at))
+        fail('invalid_execution_clock');
+    if (rows.some((row) => typeof row.type !== 'string'))
+        fail('unsupported_event_shape');
+    const inits = rows.filter((row) => row.type === 'system' && row.subtype === 'init');
+    const terminals = rows.filter((row) => row.type === 'result');
+    if (inits.length !== 1 ||
+        terminals.length !== 1 ||
+        rows[rows.length - 1] !== terminals[0])
+        fail('ambiguous_native_lifecycle');
+    const init = inits[0];
+    const result = terminals[0];
+    if (result.is_error !== false || result.subtype !== 'success')
+        fail('native_result_failed');
+    if (init.session_id !== options.sessionId ||
+        result.session_id !== options.sessionId)
+        fail('native_identity_mismatch');
+    if (typeof init.cwd !== 'string' || !samePath(init.cwd, options.cwd))
+        fail('native_cwd_mismatch');
+    const tools = stringArray(init.tools);
+    const calls = new Map();
+    const results = new Map();
+    const injections = new Map();
+    let initialized = false;
+    let pendingSkill;
+    for (const row of rows) {
+        if (row === init)
+            initialized = true;
+        if (row.type !== 'assistant' && row.type !== 'user')
+            continue;
+        if (!initialized)
+            fail('message_before_native_init');
+        if (row.session_id !== options.sessionId || row.parent_tool_use_id != null)
+            fail('foreign_or_nested_session_event');
+        const message = record(row.message) ? row.message : null;
+        if (!message || !Array.isArray(message.content))
+            fail('unsupported_message_shape');
+        for (const item of message.content) {
+            if (!record(item))
+                continue;
+            if (item.type === 'tool_use') {
+                if (row.type !== 'assistant' ||
+                    typeof item.id !== 'string' ||
+                    !item.id ||
+                    calls.has(item.id) ||
+                    typeof item.name !== 'string' ||
+                    !tools.includes(item.name))
+                    fail('unsupported_tool_call');
+                const call = {
+                    id: item.id,
+                    name: item.name,
+                    ...(record(item.input) ? { input: item.input } : {}),
+                };
+                calls.set(item.id, call);
+                pendingSkill = undefined;
+            }
+            else if (item.type === 'tool_result') {
+                if (row.type !== 'user' ||
+                    typeof item.tool_use_id !== 'string' ||
+                    !calls.has(item.tool_use_id) ||
+                    results.has(item.tool_use_id) ||
+                    (item.is_error !== undefined && typeof item.is_error !== 'boolean'))
+                    fail('unsupported_tool_result');
+                const outcome = item.is_error === undefined ? {} : { is_error: item.is_error };
+                results.set(item.tool_use_id, outcome);
+                const call = calls.get(item.tool_use_id);
+                pendingSkill =
+                    call.name === 'Skill' && !outcome.is_error ? call : undefined;
+            }
+            else if (row.type === 'user' &&
+                row.isSynthetic === true &&
+                item.type === 'text' &&
+                typeof item.text === 'string' &&
+                item.text.startsWith('Base directory for this skill: ')) {
+                const base = item.text
+                    .split('\n')[0]
+                    .slice('Base directory for this skill: '.length)
+                    .trim();
+                if (!pendingSkill || !path.isAbsolute(base))
+                    fail('ambiguous_skill_injection');
+                injections.set(pendingSkill.id, realPath(base));
+                pendingSkill = undefined;
+            }
+        }
+    }
+    if ([...calls.keys()].some((id) => !results.has(id)))
+        fail('incomplete_tool_results');
+    return {
+        rows,
+        execution,
+        init,
+        result,
+        calls,
+        results,
+        injections,
+        evidenceRecords: evidenceRecords(eventsBytes, options.eventsFile, executionBytes, options.executionFile),
+    };
+}
+export function deriveClaudeCard(options) {
+    return deriveOutcome(options.assignment, options.template, () => {
+        if (options.assignment.assignee.harness !== 'claude' ||
+            options.assignment.assignee.surface !== 'cli')
+            fail('unsupported_harness_surface');
+        assertTemplateIdentity(options.assignment, options.template, 'claude');
+        const native = readClaudeExecution({
+            eventsFile: options.eventsFile,
+            executionFile: options.executionFile,
+            sessionId: options.template.session_id,
+            cwd: options.template.cwd,
+        });
+        if (!['bootstrap', 'discovery'].includes(String(native.execution.phase)))
+            fail('not_a_discovery_execution');
+        if ([...native.calls.values()].some((call) => !['Read', 'Skill'].includes(call.name)))
+            fail('discovery_performed_unexpected_action');
+        const successful = (name) => [...native.calls.values()].some((call) => call.name === name && !native.results.get(call.id)?.is_error);
+        const card = structuredClone(options.template);
+        card.evidence_level = 'runtime';
+        card.observed_at = native.execution.finished_at;
+        card.evidence_records = native.evidenceRecords;
+        card.native_observation = {
+            model: native.init.model,
+            tools: native.init.tools,
+            source: 'claude-cli-stream',
+        };
+        card.tools = card.tools.map((tool) => ({
+            ...tool,
+            state: !stringArray(native.init.tools).includes(tool.id)
+                ? 'unknown'
+                : successful(tool.id)
+                    ? 'verified'
+                    : 'callable',
+            evidence_ref: options.eventsFile,
+        }));
+        card.skills = card.skills.map((skill) => {
+            const snapshot = fingerprintTemplateSkill(skill);
+            const pinned = skill;
+            const nativeName = typeof pinned.native_name === 'string'
+                ? pinned.native_name
+                : path.basename(path.dirname(snapshot.entry));
+            const discoveredNames = [
+                ...(Array.isArray(native.init.skills) ? native.init.skills : []),
+                ...(Array.isArray(native.init.slash_commands)
+                    ? native.init.slash_commands
+                    : []),
+            ];
+            const discovered = discoveredNames.includes(nativeName);
+            const loaded = [...native.calls.values()].filter((call) => call.name === 'Skill' &&
+                call.input?.skill === nativeName &&
+                !native.results.get(call.id)?.is_error);
+            const sourceMatched = loaded.some((call) => native.injections.get(call.id) === snapshot.directory);
+            return {
+                ...skill,
+                state: sourceMatched
+                    ? 'verified'
+                    : discovered
+                        ? 'discovered'
+                        : 'unknown',
+                evidence_ref: options.eventsFile,
+            };
+        });
+        return { card };
+    });
+}

package/dist/app/capability-evidence/codex.d.ts

@@ -0,0 +1,35 @@
+import type { Assignment, CapabilityCard } from '../../collab/contracts.js';
+import { type CapabilityDerivation } from './shared.js';
+interface CodexToolCall {
+    readonly id: unknown;
+    readonly tool: string;
+    readonly item_type: string;
+    readonly succeeded: boolean;
+    readonly payload: string[];
+}
+export interface CodexNativeExecution {
+    readonly rows: Record<string, unknown>[];
+    readonly execution: Record<string, unknown>;
+    readonly items: Record<string, unknown>[];
+    readonly toolCalls: CodexToolCall[];
+    readonly unknownItemTypes: string[];
+    readonly usage: unknown;
+    readonly evidenceRecords: {
+        ref: string;
+        digest: string;
+    }[];
+}
+export interface CodexEvidenceOptions {
+    readonly eventsFile: string;
+    readonly executionFile: string;
+    readonly sessionId: string;
+    readonly cwd: string;
+}
+export declare function readCodexExecution(options: CodexEvidenceOptions): CodexNativeExecution;
+export declare function deriveCodexCard(options: {
+    readonly assignment: Assignment;
+    readonly template: CapabilityCard;
+    readonly eventsFile: string;
+    readonly executionFile: string;
+}): CapabilityDerivation;
+export {};

package/dist/app/capability-evidence/codex.js

@@ -0,0 +1,193 @@
+import { assertTemplateIdentity, deriveOutcome, evidenceRecords, fail, fingerprintTemplateSkill, isTimestamp, MAX_EVENTS, parseExecution, payloadStrings, readNativeEvidence, record, samePath, } from './shared.js';
+/**
+ * Derive a runtime capability card from a saved `codex exec --json` run.
+ *
+ * Observed Codex CLI 0.162.1 event shape:
+ *   {"type":"thread.started","thread_id":"..."}
+ *   {"type":"turn.started"}
+ *   {"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"..."}}
+ *   {"type":"turn.completed","usage":{...}}
+ *
+ * Limits this parser states rather than hides:
+ *   * Only the shapes above are understood. An unknown row type, an unknown item
+ *     type or a bare `turn.failed` fails closed instead of being guessed into a
+ *     success.
+ *   * The exec stream does not report skill invocation in this version, so a skill
+ *     can never be promoted to `verified` here; it stays `unknown` and a required
+ *     skill fails closed.
+ *   * Tool ids are the receiving runtime's own reported item types, mapped
+ *     explicitly by ITEM_TOOL_MAP below; no aliasing by display name.
+ */
+const TERMINAL_ROWS = new Set(['turn.completed']);
+const FAILURE_ROWS = new Set(['turn.failed', 'error']);
+const NON_TOOL_ITEMS = new Set(['agent_message', 'reasoning', 'message']);
+const ITEM_TOOL_MAP = {
+    command_execution: 'shell',
+    file_change: 'apply_patch',
+    mcp_tool_call: 'mcp',
+    web_search: 'web_search',
+};
+/** True when the item reports success: no explicit failure signal and a non-failed status. */
+function itemSucceeded(item) {
+    if (typeof item.status === 'string' && item.status !== 'completed')
+        return false;
+    if (item.exit_code !== undefined &&
+        item.exit_code !== null &&
+        item.exit_code !== 0)
+        return false;
+    return true;
+}
+export function readCodexExecution(options) {
+    const eventsBytes = readNativeEvidence(options.eventsFile);
+    const executionBytes = readNativeEvidence(options.executionFile);
+    let rows;
+    let execution;
+    try {
+        const lines = eventsBytes.text
+            .split('\n')
+            .filter((line) => line.trim().length);
+        if (lines.length > MAX_EVENTS)
+            fail('event_limit');
+        rows = lines.map((line) => {
+            const value = JSON.parse(line);
+            if (!record(value))
+                fail('unsupported_event_shape');
+            return value;
+        });
+        execution = parseExecution(executionBytes.text);
+    }
+    catch {
+        return fail('invalid_native_json');
+    }
+    if (execution.status !== 'exited' || execution.exit_code !== 0)
+        fail('native_process_not_successfully_exited');
+    if (!isTimestamp(execution.started_at) ||
+        !isTimestamp(execution.finished_at) ||
+        Date.parse(execution.finished_at) <
+            Date.parse(execution.started_at))
+        fail('invalid_execution_clock');
+    if (execution.events_file &&
+        !samePath(execution.events_file, options.eventsFile))
+        fail('execution_evidence_mismatch');
+    if (execution.cwd && !samePath(execution.cwd, options.cwd))
+        fail('native_cwd_mismatch');
+    if (rows.some((row) => typeof row.type !== 'string'))
+        fail('unsupported_event_shape');
+    const started = rows.filter((row) => row.type === 'thread.started');
+    if (started.length !== 1 || rows[0] !== started[0])
+        fail('ambiguous_native_lifecycle');
+    const terminal = rows.filter((row) => TERMINAL_ROWS.has(row.type) ||
+        FAILURE_ROWS.has(row.type));
+    if (terminal.length !== 1 || rows[rows.length - 1] !== terminal[0])
+        fail('ambiguous_native_lifecycle');
+    const terminalItem = terminal[0];
+    if (FAILURE_ROWS.has(terminalItem.type) ||
+        terminalItem.success === false)
+        fail('native_result_failed');
+    if (started[0].thread_id !== options.sessionId)
+        fail('native_identity_mismatch');
+    const known = new Set([
+        'thread.started',
+        'turn.started',
+        'item.started',
+        'item.updated',
+        'item.completed',
+        ...TERMINAL_ROWS,
+    ]);
+    const unknownRows = [
+        ...new Set(rows.map((row) => String(row.type)).filter((type) => !known.has(type))),
+    ];
+    if (unknownRows.length)
+        fail(`unsupported_row_types:${unknownRows.join(',')}`);
+    const items = [];
+    const unknownItemTypes = new Set();
+    for (const row of rows) {
+        if (row.type !== 'item.completed' && row.type !== 'item.started')
+            continue;
+        const item = row.item;
+        if (!record(item) || typeof item.type !== 'string')
+            fail('unsupported_item_shape');
+        if (!NON_TOOL_ITEMS.has(item.type) && !ITEM_TOOL_MAP[item.type])
+            unknownItemTypes.add(item.type);
+        items.push({ ...item, __row: row.type });
+    }
+    const completed = items.filter((item) => item.__row === 'item.completed');
+    const toolCalls = completed
+        .filter((item) => typeof item.type === 'string' && ITEM_TOOL_MAP[item.type] !== undefined)
+        .map((item) => ({
+        id: item.id ?? null,
+        tool: ITEM_TOOL_MAP[item.type],
+        item_type: item.type,
+        succeeded: itemSucceeded(item),
+        payload: payloadStrings(item).slice(0, 40),
+    }));
+    return {
+        rows,
+        execution,
+        items,
+        toolCalls,
+        unknownItemTypes: [...unknownItemTypes].sort(),
+        usage: terminalItem.usage ?? null,
+        evidenceRecords: evidenceRecords(eventsBytes, options.eventsFile, executionBytes, options.executionFile),
+    };
+}
+export function deriveCodexCard(options) {
+    return deriveOutcome(options.assignment, options.template, () => {
+        assertTemplateIdentity(options.assignment, options.template, 'codex');
+        const native = readCodexExecution({
+            eventsFile: options.eventsFile,
+            executionFile: options.executionFile,
+            sessionId: options.template.session_id,
+            cwd: options.template.cwd,
+        });
+        const successfulTool = (tool) => native.toolCalls.some((call) => call.tool === tool && call.succeeded);
+        const card = structuredClone(options.template);
+        card.evidence_level = 'runtime';
+        card.observed_at = native.execution.finished_at;
+        card.evidence_records = native.evidenceRecords;
+        card.native_observation = {
+            source: 'codex-exec-json',
+            thread_id: options.template.session_id,
+            cwd: native.execution.cwd,
+            sandbox: native.execution.sandbox ?? null,
+            resumed_from: native.execution.resumed_from ?? null,
+            item_types_observed: [
+                ...new Set(native.items.map((item) => String(item.type))),
+            ].sort(),
+            unmapped_item_types: native.unknownItemTypes,
+            tool_calls: native.toolCalls.map((call) => ({
+                tool: call.tool,
+                item_type: call.item_type,
+                succeeded: call.succeeded,
+            })),
+            usage: native.usage,
+            skill_evidence: 'not_reported_by_this_cli_version: skills stay unknown and can never satisfy a required capability from this stream alone',
+        };
+        card.tools = card.tools.map((tool) => {
+            const known = Object.values(ITEM_TOOL_MAP).includes(tool.id);
+            const verified = known && successfulTool(tool.id);
+            const next = {
+                ...tool,
+                state: verified ? 'verified' : 'unknown',
+            };
+            if (verified)
+                next.evidence_ref = options.eventsFile;
+            return next;
+        });
+        card.skills = card.skills.map((skill) => {
+            fingerprintTemplateSkill(skill);
+            // `codex exec --json` does not report skill invocation and shell payloads
+            // cannot prove that a skill was loaded or followed. Skills therefore never
+            // reach `verified` here; they stay `unknown` so a required skill fails
+            // closed and the caller must use `preferred` or provide in-host evidence.
+            return { ...skill, state: 'unknown' };
+        });
+        return {
+            card,
+            limitations: [
+                'skill_invocation_not_reported_by_codex_exec_json',
+                'unmapped_item_types_are_not_promoted',
+            ],
+        };
+    });
+}

package/dist/app/capability-evidence/index.d.ts

@@ -0,0 +1,33 @@
+import type { CapabilityCard } from '../../collab/contracts.js';
+import { type CapabilityDerivation } from './shared.js';
+/**
+ * Read-only native capability evidence derivation.
+ *
+ * A derived runtime card is a claim derived from the supplied evidence only; no
+ * authentication, process ownership, admission or task completion is implied.
+ * Deriving never writes a file, launches a process or calls a model.
+ */
+export declare const CAPABILITIES_SCHEMA = "pappra/collaboration-capabilities/1";
+export type EvidenceHarness = 'pi' | 'codex' | 'claude';
+export interface DeriveCapabilitiesOptions {
+    readonly harness: EvidenceHarness;
+    readonly assignmentFile: string;
+    readonly templateFile: string;
+    readonly executionFile?: string | null;
+    readonly live?: boolean;
+    readonly sessionFile?: string | null;
+    readonly eventsFile?: string | null;
+}
+export interface CapabilityEvidenceResult {
+    readonly schema: typeof CAPABILITIES_SCHEMA;
+    readonly ok: boolean;
+    readonly status: CapabilityDerivation['status'];
+    readonly harness: EvidenceHarness;
+    readonly card?: CapabilityCard;
+    readonly blockers?: readonly string[];
+    readonly limitations?: readonly string[];
+    readonly errors?: readonly string[];
+    readonly limits: readonly string[];
+}
+export declare const CAPABILITY_LIMITS: readonly ['reported_native_evidence_only', 'evidence_not_authenticated', 'no_dispatch'];
+export declare function deriveCapabilityCard(options: DeriveCapabilitiesOptions): CapabilityEvidenceResult;