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

package/dist/hosts/pi/rpc.js

@@ -1,4 +1,4 @@
-import { errorCode, object, parseJson } from '../../collab/validation.js';
+import { errorCode, object, parseJson } from '../../infra/validation.js';
 import { isAssignment } from '../../collab/contracts.js';
 import { isPiRecord } from './protocol.js';
 function errorDetail(error) {
@@ -15,6 +15,7 @@ import { admitLaunch, claimCovers, classifyIdentity, hasPendingCancellation, res
 import { describeResource } from '../../collab/canonical.js';
 import { buildMessage, sha256File } from '../../collab/envelope.js';
 import { submitMessage } from '../../collab/messages.js';
+import { readMessageFromTaskRoot } from '../../collab/persisted-messages.js';
 import { findAttempt } from '../../collab/lifecycle.js';
 import { createNonce, nowIso, readRecord } from '../../collab/store.js';
 // Gated, owned Pi RPC lifecycle. One launch, one frozen prompt, repeated native queries and an
@@ -37,14 +38,19 @@ import { createNonce, nowIso, readRecord } from '../../collab/store.js';
 const RPC_SCHEMA = 'harness-collab/pi-rpc/1';
 const EXECUTION_SCHEMA = 'harness-collab/native-execution/1';
 const DEFAULT_REQUEST_TIMEOUT_MS = 15000;
-const DEFAULT_OPERATION_TIMEOUT_MS = 120000;
+const DEFAULT_OPERATION_TIMEOUT_MS = 30 * 60 * 1000;
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
 const DEFAULT_SIGNAL_GRACE_MS = 2000;
 const DEFAULT_STREAM_CLOSE_GRACE_MS = 500;
 const DEFAULT_MAX_BYTES = 16 * 1024 * 1024;
+const DEFAULT_MAX_LOG_BYTES = 16 * 1024 * 1024;
+const MAX_CAPTURE_BYTES = 256 * 1024 * 1024;
+const MAX_RETAINED_RECORDS = 256;
+const MAX_RETAINED_BYTES = 1024 * 1024;
+const MAX_REQUESTS = 4096;
 const DEFAULT_MAX_STDERR_BYTES = 64 * 1024;
 const MAX_REQUEST_TIMEOUT_MS = 60000;
-const MAX_OPERATION_TIMEOUT_MS = 600000;
+const MAX_OPERATION_TIMEOUT_MS = 24 * 60 * 60 * 1000;
 const MAX_PROMPT_BYTES = 20000;
 const HEADER_READ_BYTES = 64 * 1024;
 const PHASES = new Set([
@@ -127,10 +133,16 @@ function attachTransport(child, options = {}) {
     const decoder = new StringDecoder('utf8');
     const records = [];
     const pending = new Map();
+    const expiredRequests = new Map();
     const eventWaiters = [];
     let drainQueue = [];
     let text = '';
     let bytes = 0;
+    let recordCount = 0;
+    let retainedBytes = 0;
+    let historyTruncated = false;
+    let lateResponses = 0;
+    let lastSettled = null;
     let stderrBytes = 0;
     const stderrChunks = [];
     let sequence = 0;
@@ -169,10 +181,16 @@ function attachTransport(child, options = {}) {
             resolve();
     }
     function findRecord(predicate, fromOrdinal) {
-        for (let index = fromOrdinal; index < records.length; index += 1) {
-            if (predicate(records[index], index))
-                return { record: records[index], ordinal: index };
+        for (const found of records) {
+            if (found.ordinal >= fromOrdinal &&
+                predicate(found.record, found.ordinal))
+                return found;
         }
+        // The only awaited lifecycle event must survive noisy tool/token traffic.
+        if (lastSettled &&
+            lastSettled.ordinal >= fromOrdinal &&
+            predicate(lastSettled.record, lastSettled.ordinal))
+            return lastSettled;
         return null;
     }
     function settleWaiters() {
@@ -197,6 +215,8 @@ function attachTransport(child, options = {}) {
         }
     }
     function handleLine(line) {
+        if (fatal)
+            return;
         const trimmed = line.endsWith('\r') ? line.slice(0, -1) : line;
         if (!trimmed.length)
             return;
@@ -221,10 +241,27 @@ function attachTransport(child, options = {}) {
             fail('invalid', 'malformed_record', 'a stdout record is not a JSON object');
             return;
         }
-        records.push(record);
+        const ordinal = recordCount++;
+        const recordBytes = Buffer.byteLength(trimmed);
+        records.push({ record, ordinal, bytes: recordBytes });
+        retainedBytes += recordBytes;
+        if (record.type === 'agent_settled')
+            lastSettled = { record: { type: 'agent_settled' }, ordinal };
+        while (records.length > MAX_RETAINED_RECORDS ||
+            retainedBytes > MAX_RETAINED_BYTES) {
+            retainedBytes -= records.shift().bytes;
+            historyTruncated = true;
+        }
         if (record.type === 'response') {
             const waiter = record.id !== undefined ? pending.get(record.id) : null;
             if (!waiter) {
+                if (record.id !== undefined &&
+                    expiredRequests.get(record.id) === record.command) {
+                    expiredRequests.delete(record.id);
+                    lateResponses++;
+                    settleWaiters();
+                    return;
+                }
                 fail('invalid', record.command === 'parse'
                     ? 'rpc_parse_error'
                     : 'unexpected_response_id', `a response arrived for ${record.id ?? 'no request id'}`);
@@ -299,19 +336,27 @@ function attachTransport(child, options = {}) {
     child.stdin.on('drain', flushDrains);
     child.stdout.on('data', (chunk) => {
         bytes += chunk.length;
-        if (bytes > maxBytes) {
-            fail('invalid', 'rpc_response_too_large', `${bytes} bytes of stdout exceeds ${maxBytes}`);
-            child.kill('SIGKILL');
+        if (fatal)
             return;
-        }
         text += decoder.write(chunk);
         let index = text.indexOf('\n');
         while (index !== -1) {
             const line = text.slice(0, index);
             text = text.slice(index + 1);
+            if (Buffer.byteLength(line) > maxBytes)
+                break;
             handleLine(line);
+            if (fatal) {
+                text = '';
+                return;
+            }
             index = text.indexOf('\n');
         }
+        if (index !== -1 || Buffer.byteLength(text) > maxBytes) {
+            fail('invalid', 'rpc_response_too_large', `one stdout record exceeds ${maxBytes} bytes`);
+            text = '';
+            child.kill('SIGKILL');
+        }
     });
     child.stderr.on('data', (chunk) => {
         if (stderrBytes < maxStderrBytes)
@@ -346,11 +391,14 @@ function attachTransport(child, options = {}) {
             return Promise.reject(fatal);
         if (streamsClosed)
             return Promise.reject(new PiRpcRefusal('rpc_exited_early', 'needs_input'));
+        if (sequence >= MAX_REQUESTS)
+            return Promise.reject(new PiRpcRefusal('rpc_request_limit', 'needs_input'));
         const id = `pirpc-${nonce}-${sequence}`;
         sequence += 1;
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 pending.delete(id);
+                expiredRequests.set(id, type);
                 reject(new PiRpcRefusal('rpc_response_deadline', 'needs_input', `no response to ${type} within ${timeoutMs}ms`));
             }, timeoutMs);
             pending.set(id, { type, resolve, reject, timer });
@@ -370,6 +418,8 @@ function attachTransport(child, options = {}) {
             return Promise.reject(fatal);
         if (streamsClosed)
             return Promise.reject(new PiRpcRefusal('rpc_exited_early', 'needs_input'));
+        if (eventWaiters.length >= MAX_RETAINED_RECORDS)
+            return Promise.reject(new PiRpcRefusal('rpc_waiter_limit', 'needs_input'));
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 const index = eventWaiters.findIndex((waiter) => waiter.resolve === resolve);
@@ -441,8 +491,17 @@ function attachTransport(child, options = {}) {
         };
     }
     return {
-        records,
-        recordCount: () => records.length,
+        recordCount: () => recordCount,
+        capture: () => ({
+            stdout_bytes: bytes,
+            received_records: recordCount,
+            retained_records: records.length,
+            retained_bytes: retainedBytes,
+            history_truncated: historyTruncated,
+            late_responses: lateResponses,
+            stderr_bytes: stderrBytes,
+            stderr_truncated: stderrBytes > maxStderrBytes,
+        }),
         fatal: () => fatal,
         parentExited: () => declared(),
         streamsDetached: () => streamsDetached,
@@ -652,6 +711,18 @@ export async function startOwnedPiRpc(options) {
         stop_scope: 'owned RPC child only; no arbitrary background or descendant stop guarantee',
     };
     let namespaceLost = false;
+    let logBytes = 0;
+    let omittedLogRecords = 0;
+    const logCapture = () => ({
+        max_bytes: opts.maxLogBytes,
+        written_bytes: logBytes,
+        omitted_records: omittedLogRecords,
+        complete: omittedLogRecords === 0 &&
+            !namespaceLost &&
+            rpc.fatal() === null &&
+            rpc.parentExited() &&
+            !rpc.streamsDetached(),
+    });
     const rpc = attachTransport(child, {
         requestTimeoutMs: opts.requestTimeoutMs,
         shutdownTimeoutMs: opts.shutdownTimeoutMs,
@@ -661,6 +732,11 @@ export async function startOwnedPiRpc(options) {
         onRecord: (line) => {
             if (namespaceLost)
                 return;
+            const lineBytes = Buffer.byteLength(line) + 1;
+            if (omittedLogRecords > 0 || logBytes + lineBytes > opts.maxLogBytes) {
+                omittedLogRecords++;
+                return;
+            }
             try {
                 assertNamespaceGuard(opts);
             }
@@ -670,9 +746,11 @@ export async function startOwnedPiRpc(options) {
             }
             try {
                 fs.appendFileSync(artifacts.eventsFile, `${line}\n`);
+                logBytes += lineBytes;
             }
-            catch {
+            catch (error) {
                 namespaceLost = true;
+                throw new PiRpcRefusal('evidence_write_failed', 'failed', errorDetail(error));
             }
         },
     });
@@ -684,15 +762,18 @@ export async function startOwnedPiRpc(options) {
     let lastPromptOrdinal = 0;
     let operationError = null;
     let finishPromise = null;
+    let operationTimer;
     const setOperationError = (error) => {
         operationError = operationError ?? error;
     };
-    async function request(type, fields = {}) {
+    async function request(type, fields = {}, cleanup = false) {
         const remaining = opts.deadlineAt - Date.now();
-        if (remaining <= 0)
+        if (!cleanup && remaining <= 0)
             throw new PiRpcRefusal('operation_deadline', 'needs_input');
         return rpc.request(type, fields, {
-            timeoutMs: Math.min(opts.requestTimeoutMs, remaining),
+            timeoutMs: cleanup
+                ? opts.requestTimeoutMs
+                : Math.min(opts.requestTimeoutMs, remaining),
         });
     }
     /** Bound an event wait by the remaining total operation budget as well as its own limit. */
@@ -776,13 +857,78 @@ export async function startOwnedPiRpc(options) {
             }
         }
     }
+    async function verifyCancellationIntent(intent) {
+        if (intent === null ||
+            typeof intent !== 'object' ||
+            typeof intent.messageId !== 'string' ||
+            intent.messageId.trim() === '' ||
+            typeof intent.contentDigest !== 'string' ||
+            typeof intent.fileDigest !== 'string' ||
+            !/^sha256:[0-9a-f]{64}$/.test(intent.contentDigest) ||
+            !/^sha256:[0-9a-f]{64}$/.test(intent.fileDigest))
+            throw new PiRpcRefusal('cancel_intent_reference_invalid', 'needs_input');
+        assertNamespaceGuard(opts);
+        assertCurrentAuthority({ requireResources: false });
+        const registered = await readMessageFromTaskRoot(opts.taskRoot, intent.messageId);
+        if (!registered.ok)
+            throw new PiRpcRefusal('cancel_intent_not_registered', 'needs_input', registered.code);
+        assertNamespaceGuard(opts);
+        const { message, entry, digest } = registered.value;
+        const record = readRecord(opts.taskRoot);
+        const attempt = record
+            ? findAttempt(record, opts.assignmentId, opts.attempt)
+            : null;
+        const coordinator = record?.coordinator ?? null;
+        const assignee = attempt?.assignee ?? null;
+        const sameIdentity = (left, right) => left !== null &&
+            left !== undefined &&
+            right !== null &&
+            right !== undefined &&
+            left.agent_id === right.agent_id &&
+            left.session_id === right.session_id &&
+            (left.harness ?? null) === (right.harness ?? null);
+        if (digest !== intent.fileDigest ||
+            message.message_id !== intent.messageId ||
+            message.content_digest !== intent.contentDigest ||
+            message.type !== 'CANCEL' ||
+            message.task_id !== opts.assignment.task_id ||
+            message.subtask_id !== opts.assignmentId ||
+            message.attempt !== opts.attempt ||
+            message.owner_epoch !== opts.assignment.coordinator.owner_epoch ||
+            message.owner_epoch !== protocol.ownerEpoch ||
+            entry === null ||
+            entry.message_id !== message.message_id ||
+            entry.type !== 'CANCEL' ||
+            entry.state !== 'applied' ||
+            entry.subtask_id !== message.subtask_id ||
+            entry.attempt !== message.attempt ||
+            entry.owner_epoch !== message.owner_epoch ||
+            entry.content_digest !== intent.contentDigest ||
+            !sameIdentity(entry.from, message.from) ||
+            !sameIdentity(entry.to, message.to) ||
+            record === null ||
+            record.task_id !== message.task_id ||
+            coordinator === null ||
+            coordinator.owner_epoch !== message.owner_epoch ||
+            !sameIdentity(coordinator, message.from) ||
+            !sameIdentity(coordinator, protocol.coordinator) ||
+            !sameIdentity(coordinator, opts.assignment.coordinator) ||
+            assignee === null ||
+            !sameIdentity(assignee, message.to) ||
+            !sameIdentity(assignee, opts.assignment.assignee) ||
+            !sameIdentity(assignee, protocol.assignee))
+            throw new PiRpcRefusal('cancel_intent_mismatch', 'needs_input');
+        assertNamespaceGuard(opts);
+        assertCurrentAuthority({ requireResources: false });
+        return { message, fileDigest: digest };
+    }
     /**
      * Read `get_state` and bind the exact native session file. The id alone is not enough: the
      * reported file must exist, its header must carry the contracted id and cwd, and once bound it
      * may not switch to a different path.
      */
-    async function assertIdentity({ requireBinding = false } = {}) {
-        const response = await request('get_state');
+    async function assertIdentity({ requireBinding = false, cleanup = false, } = {}) {
+        const response = await request('get_state', {}, cleanup);
         const data = response.data;
         if (!isObject(data) || typeof data.sessionId !== 'string')
             throw new PiRpcRefusal('state_malformed');
@@ -956,7 +1102,7 @@ export async function startOwnedPiRpc(options) {
             }
         },
         /** Bounded wait for the run started by `prompt` to settle. Used by the run helper. */
-        async awaitSettled({ timeoutMs = opts.settleTimeoutMs } = {}) {
+        async awaitSettled({ timeoutMs = opts.operationTimeoutMs } = {}) {
             try {
                 if (proof.prompt?.disposition === 'handled')
                     return null;
@@ -975,11 +1121,25 @@ export async function startOwnedPiRpc(options) {
          * Explicit cancellation of this owned runtime. It never sends a prompt, never sends
          * CANCELLED and never releases claims: a caller must reconcile the stop externally.
          */
-        async cancel({ reason = 'bounded RPC cancellation request' } = {}) {
+        async cancel(options = {}) {
+            const intent = options.intent;
             try {
                 assertNamespaceGuard(opts);
+                let verifiedIntent = intent === undefined ? null : await verifyCancellationIntent(intent);
+                const reason = verifiedIntent &&
+                    typeof verifiedIntent.message.body.reason === 'string'
+                    ? verifiedIntent.message.body.reason
+                    : (options.reason ?? 'bounded RPC cancellation request');
+                if (verifiedIntent === null)
+                    assertCurrentAuthority({ requireResources: false });
+                const before = await assertIdentity({
+                    requireBinding: true,
+                    cleanup: true,
+                });
+                if (intent !== undefined)
+                    verifiedIntent = await verifyCancellationIntent(intent);
+                assertNamespaceGuard(opts);
                 assertCurrentAuthority({ requireResources: false });
-                const before = await assertIdentity({ requireBinding: true });
                 const ordinalBeforeAbort = rpc.recordCount();
                 const entry = {
                     at: nowIso(),
@@ -989,17 +1149,28 @@ export async function startOwnedPiRpc(options) {
                     reconciliation_required: true,
                     stop_scope: 'owned RPC child only; a native abort response is not proof that arbitrary descendants stopped',
                 };
-                // Recorded immediately, so partial cancellation evidence survives a later failure.
+                // Record cancellation evidence before queue clearing or abort so partial failure remains inspectable.
                 proof.cancel = entry;
-                const cancel = protocolMessage({
-                    type: 'CANCEL',
-                    from: protocol.coordinator,
-                    to: protocol.assignee,
-                    owner_epoch: protocol.ownerEpoch,
-                    body: { reason },
-                });
-                entry.cancel_message_id = cancel.message_id;
-                const clear = await request('clear_queue');
+                if (verifiedIntent === null) {
+                    const cancel = protocolMessage({
+                        type: 'CANCEL',
+                        from: protocol.coordinator,
+                        to: protocol.assignee,
+                        owner_epoch: protocol.ownerEpoch,
+                        body: { reason },
+                    });
+                    entry.cancel_message_id = cancel.message_id;
+                }
+                else {
+                    entry.cancel_message_id = verifiedIntent.message.message_id;
+                    entry.cancel_intent = {
+                        content_digest: verifiedIntent.message.content_digest,
+                        file_digest: verifiedIntent.fileDigest,
+                    };
+                }
+                assertNamespaceGuard(opts);
+                assertCurrentAuthority({ requireResources: false });
+                const clear = await request('clear_queue', {}, true);
                 entry.clear_queue = {
                     id: clear.id,
                     steering: Array.isArray(clear.data?.steering)
@@ -1009,7 +1180,7 @@ export async function startOwnedPiRpc(options) {
                         ? clear.data.followUp
                         : [],
                 };
-                const abort = await request('abort');
+                const abort = await request('abort', {}, true);
                 entry.abort = {
                     id: abort.id,
                     success: abort.success === true,
@@ -1022,7 +1193,7 @@ export async function startOwnedPiRpc(options) {
                     // sufficient because retries/compaction/follow-ups can still follow it.
                     settledEvent = await rpc.waitForEvent((record) => record.type === 'agent_settled', {
                         fromOrdinal: ordinalBeforeAbort,
-                        timeoutMs: eventTimeout(opts.settleTimeoutMs),
+                        timeoutMs: opts.settleTimeoutMs,
                     });
                 }
                 catch (error) {
@@ -1033,7 +1204,10 @@ export async function startOwnedPiRpc(options) {
                 if (settledEvent)
                     entry.agent_settled = { ordinal: settledEvent.ordinal, at: nowIso() };
                 try {
-                    const after = await assertIdentity({ requireBinding: true });
+                    const after = await assertIdentity({
+                        requireBinding: true,
+                        cleanup: true,
+                    });
                     entry.native_idle =
                         after.data.isStreaming === false &&
                             after.data.isCompacting === false &&
@@ -1069,6 +1243,7 @@ export async function startOwnedPiRpc(options) {
         finish() {
             if (finishPromise)
                 return finishPromise;
+            clearTimeout(operationTimer);
             finishPromise = (async () => {
                 let exit = null;
                 let shutdownError = null;
@@ -1143,6 +1318,8 @@ export async function startOwnedPiRpc(options) {
                         shutdown_timeout_ms: opts.shutdownTimeoutMs,
                         stream_close_grace_ms: opts.streamCloseGraceMs,
                         max_bytes: opts.maxBytes,
+                        max_log_bytes: opts.maxLogBytes,
+                        cancel_settle_timeout_ms: opts.settleTimeoutMs,
                         model_override: null,
                         effort_override: null,
                     },
@@ -1164,6 +1341,7 @@ export async function startOwnedPiRpc(options) {
                     },
                     planned_outcome: outcome,
                     rpc_child_pid: child.pid ?? null,
+                    rpc_capture: { ...rpc.capture(), log: logCapture() },
                 };
                 let namespaceError = null;
                 const checkNamespace = () => {
@@ -1212,7 +1390,7 @@ export async function startOwnedPiRpc(options) {
                     evidenceError === null &&
                     checkNamespace()) {
                     try {
-                        fs.writeFileSync(artifacts.proofFile, `${JSON.stringify({ ...proof, finished_at: finishedAt, exit }, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+                        fs.writeFileSync(artifacts.proofFile, `${JSON.stringify({ ...proof, finished_at: finishedAt, exit, rpc_capture: { ...rpc.capture(), log: logCapture() } }, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
                     }
                     catch (error) {
                         evidenceError = errorDetail(error) ?? 'proof_write_failed';
@@ -1345,6 +1523,8 @@ export async function startOwnedPiRpc(options) {
                     evidence: {
                         evidence_dir: opts.evidenceDir,
                         events_file: artifacts.eventsFile,
+                        events_complete: logCapture().complete,
+                        events_omitted_records: omittedLogRecords,
                         execution_file: namespaceError === null && !evidenceError
                             ? artifacts.executionFile
                             : null,
@@ -1368,6 +1548,12 @@ export async function startOwnedPiRpc(options) {
             return finishPromise;
         },
     };
+    operationTimer = setTimeout(() => {
+        setOperationError(new PiRpcRefusal('operation_deadline', 'needs_input'));
+        void session.finish().catch(() => { });
+    }, Math.max(1, opts.deadlineAt - Date.now()));
+    if (typeof operationTimer.unref === 'function')
+        operationTimer.unref();
     // Accepted alias for callers of the earlier revision; like `finish` it takes no arguments,
     // so it cannot override the authoritative outcome.
     // Bind the contracted identity and native session header before returning a live handle.
@@ -1375,6 +1561,7 @@ export async function startOwnedPiRpc(options) {
         await assertIdentity({ requireBinding: false });
     }
     catch (error) {
+        setOperationError(error);
         const failure = await session.finish();
         return {
             ok: false,
@@ -1516,11 +1703,16 @@ function normalizeOwnedOptions(options) {
     const streamCloseGraceMs = boundedTimeout(options.streamCloseGraceMs, DEFAULT_STREAM_CLOSE_GRACE_MS, MAX_REQUEST_TIMEOUT_MS, 'stream_close_grace_out_of_range');
     const maxBytes = options.maxBytes === undefined
         ? DEFAULT_MAX_BYTES
-        : Number.isSafeInteger(options.maxBytes) && options.maxBytes > 0
+        : Number.isSafeInteger(options.maxBytes) &&
+            options.maxBytes > 0 &&
+            options.maxBytes <= MAX_CAPTURE_BYTES
             ? options.maxBytes
             : (() => {
                 throw new PiRpcRefusal('max_bytes_out_of_range');
             })();
+    const maxLogBytes = options.maxLogBytes === undefined
+        ? DEFAULT_MAX_LOG_BYTES
+        : boundedTimeout(options.maxLogBytes, DEFAULT_MAX_LOG_BYTES, MAX_CAPTURE_BYTES, 'max_log_bytes_out_of_range');
     const maxAgeMinutes = options.maxAgeMinutes === undefined ? 30 : options.maxAgeMinutes;
     if (!Number.isFinite(maxAgeMinutes) || maxAgeMinutes < 0)
         throw new PiRpcRefusal('invalid_max_age');
@@ -1554,6 +1746,7 @@ function normalizeOwnedOptions(options) {
         signalGraceMs,
         streamCloseGraceMs,
         maxBytes,
+        maxLogBytes,
         maxAgeMinutes,
         namespaceGuard: options.namespaceGuard,
         deadlineAt: Date.now() + operationTimeoutMs,