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

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

@@ -0,0 +1,117 @@
+import { readBoundedFile } from '../bounded-file.js';
+import { deriveClaudeCard } from './claude.js';
+import { deriveCodexCard } from './codex.js';
+import { derivePiCard } from './pi.js';
+import { MAX_ASSIGNMENT_BYTES } 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 const CAPABILITIES_SCHEMA = 'pappra/collaboration-capabilities/1';
+export const CAPABILITY_LIMITS = [
+    'reported_native_evidence_only',
+    'evidence_not_authenticated',
+    'no_dispatch',
+];
+function readConfiguration(file, kind) {
+    const read = readBoundedFile(file, MAX_ASSIGNMENT_BYTES);
+    if (!read.ok) {
+        switch (read.code) {
+            case 'path_not_absolute':
+                return { ok: false, error: `${kind}_path_must_be_absolute` };
+            case 'symlink':
+            case 'not_regular':
+                return { ok: false, error: `${kind}_must_be_regular_file` };
+            case 'too_large':
+                return { ok: false, error: `${kind}_exceeds_1_mib` };
+            default:
+                return { ok: false, error: `${kind}_unreadable` };
+        }
+    }
+    try {
+        return { ok: true, value: JSON.parse(read.text) };
+    }
+    catch {
+        return { ok: false, error: `${kind}_invalid_json` };
+    }
+}
+function invalid(harness, errors) {
+    return {
+        schema: CAPABILITIES_SCHEMA,
+        ok: false,
+        status: 'invalid',
+        harness,
+        errors,
+        limits: CAPABILITY_LIMITS,
+    };
+}
+export function deriveCapabilityCard(options) {
+    if (options.live && options.harness !== 'pi')
+        return invalid(options.harness, ['live_only_supported_for_pi']);
+    if (options.live && options.executionFile)
+        return invalid(options.harness, ['live_execution_conflict']);
+    if (!options.live && !options.executionFile)
+        return invalid(options.harness, ['execution_required']);
+    const assignment = readConfiguration(options.assignmentFile, 'assignment');
+    if (!assignment.ok)
+        return invalid(options.harness, [assignment.error]);
+    const template = readConfiguration(options.templateFile, 'template');
+    if (!template.ok)
+        return invalid(options.harness, [template.error]);
+    let outcome;
+    if (options.harness === 'pi') {
+        if (!options.sessionFile)
+            return invalid(options.harness, ['session_required_for_pi']);
+        outcome = derivePiCard({
+            assignment: assignment.value,
+            template: template.value,
+            sessionFile: options.sessionFile,
+            executionFile: options.executionFile ?? null,
+            live: options.live ?? false,
+        });
+    }
+    else if (options.harness === 'codex') {
+        if (!options.eventsFile)
+            return invalid(options.harness, ['events_required_for_codex']);
+        outcome = deriveCodexCard({
+            assignment: assignment.value,
+            template: template.value,
+            eventsFile: options.eventsFile,
+            executionFile: options.executionFile,
+        });
+    }
+    else {
+        if (!options.eventsFile)
+            return invalid(options.harness, ['events_required_for_claude']);
+        outcome = deriveClaudeCard({
+            assignment: assignment.value,
+            template: template.value,
+            eventsFile: options.eventsFile,
+            executionFile: options.executionFile,
+        });
+    }
+    if (outcome.status === 'derived') {
+        return {
+            schema: CAPABILITIES_SCHEMA,
+            ok: true,
+            status: 'derived',
+            harness: options.harness,
+            card: outcome.card,
+            limits: CAPABILITY_LIMITS,
+            ...(outcome.limitations === undefined
+                ? {}
+                : { limitations: outcome.limitations }),
+        };
+    }
+    return {
+        schema: CAPABILITIES_SCHEMA,
+        ok: false,
+        status: outcome.status,
+        harness: options.harness,
+        blockers: outcome.blockers,
+        limits: CAPABILITY_LIMITS,
+    };
+}

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

@@ -0,0 +1,73 @@
+import type { Assignment, CapabilityCard } from '../../collab/contracts.js';
+import { type CapabilityDerivation } from './shared.js';
+/**
+ * Derive a runtime capability card from a saved native Pi session.
+ *
+ * Observed Pi 1.2/1.3 session shape: a JSONL file whose first record is
+ *   { type: "session", id, cwd, timestamp, version }
+ * followed by { type: "message", id, parentId, timestamp,
+ *   message: { role: "assistant", content: [{ type: "toolCall", id, name, arguments }] } }
+ * and { type: "message", ..., message: { role: "toolResult", toolCallId, toolName, isError, ... } }.
+ *
+ * Only positively observed facts become `verified`. A tool is `verified` when a
+ * call was correlated with a successful result; a skill is `verified` when the
+ * session read its SKILL.md through a successful tool call, which is how Pi loads
+ * a skill. Everything else stays `unknown`.
+ */
+interface PiCall {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: unknown;
+    readonly at: unknown;
+}
+interface PiResult {
+    readonly isError: boolean;
+    readonly at: unknown;
+    readonly toolName: unknown;
+}
+interface PiTurn {
+    readonly model: unknown;
+    readonly provider: unknown;
+    readonly stop_reason: unknown;
+    readonly usage: unknown;
+    readonly timestamp: unknown;
+}
+export interface PiNativeExecution {
+    readonly records: Record<string, unknown>[];
+    readonly execution: Record<string, unknown>;
+    readonly session: Record<string, unknown>;
+    readonly calls: Map<string, PiCall>;
+    readonly results: Map<string, PiResult>;
+    readonly assistantTurns: PiTurn[];
+    readonly lastTurn: PiTurn;
+    readonly evidenceRecords: {
+        ref: string;
+        digest: string;
+    }[];
+}
+export interface PiEvidenceOptions {
+    readonly sessionFile: string;
+    readonly executionFile?: string | null;
+    readonly live?: boolean;
+    readonly sessionId: string;
+    readonly cwd: string;
+}
+export declare function readPiExecution(options: PiEvidenceOptions): PiNativeExecution;
+export declare function derivePiCard(options: {
+    readonly assignment: Assignment;
+    readonly template: CapabilityCard;
+    readonly sessionFile: string;
+    readonly executionFile?: string | null;
+    readonly live?: boolean;
+}): CapabilityDerivation;
+/** Derive startup availability from the native SDK observation, never from model settlement. */
+export declare function derivePiStartupCard(options: {
+    readonly assignment: Assignment;
+    readonly template: CapabilityCard;
+    readonly metadataFile: string;
+    readonly sessionId: string;
+    readonly cwd: string;
+    readonly expectedProvider?: string;
+    readonly expectedModel?: string;
+}): CapabilityDerivation;
+export {};