@north-light/crouter 0.3.312 → 0.3.313

package/dist/core/__tests__/watchdog-abort-arms-retry.test.js

@@ -1,110 +0,0 @@
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { FaultRetry } from '../runtime/broker/fault-retry.js';
-import { admitProviderRetryEpisode, clearFault, readFault, readProviderRetryEpisode, recordPendingProviderRetryFault, } from '../runtime/fault.js';
-let home;
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-watchdog-abort-retry-'));
-    process.env['CRTR_HOME'] = home;
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-});
-test('only a watchdog-stamped aborted settlement records an automatic connection fault', () => {
-    const settleAbort = (nodeId, stagedWatchdogAbort, stagedRefreshAbort, stopReason = 'aborted', errorText) => {
-        const session = {
-            sessionManager: { getLeafId: () => 'leaf-entry' },
-            model: undefined,
-        };
-        const generation = {
-            id: 1,
-            session,
-            fallback: { blocked: false },
-            stagedProviderAgentEnd: {
-                messages: [{
-                        role: 'assistant',
-                        stopReason,
-                        errorMessage: errorText ?? (stopReason === 'error' ? 'This operation was aborted' : 'Request was aborted'),
-                    }],
-            },
-            stagedWatchdogAbort,
-            stagedRefreshAbort,
-            stagedOverflowFailure: null,
-            executingTools: new Set(),
-        };
-        const retry = new FaultRetry({
-            nodeId,
-            currentSession: () => session,
-            installedGeneration: () => generation,
-        });
-        retry.publishSettledProviderFault(generation);
-        return { retry, generation };
-    };
-    const watchdog = settleAbort('watchdog-node', true, false);
-    const fault = readFault('watchdog-node');
-    assert.equal(fault?.link, 'pi→provider');
-    assert.equal(fault?.kind, 'connection');
-    assert.deepEqual(fault?.retry, { disposition: 'auto', by: 'daemon' });
-    assert.equal(watchdog.retry.isActiveAutoFault(fault), true);
-    assert.equal(watchdog.generation.stagedWatchdogAbort, false, 'settlement consumes the one-shot provenance');
-    settleAbort('human-node', false, false);
-    assert.equal(readFault('human-node'), null, 'an otherwise-identical human abort must not arm recovery');
-    // Pi 0.84 currently serializes a host abort from `node yield` as an `error`
-    // settlement.
-    const refresh = settleAbort('refresh-node', false, true, 'error');
-    assert.equal(readFault('refresh-node'), null, 'a refresh-aborted error settlement must not enter provider fault recovery');
-    assert.equal(refresh.generation.stagedRefreshAbort, false, 'settlement consumes the one-shot refresh provenance');
-    // #683 — an abort that lands between requests settles as an error carrying
-    // AbortError text. It stopped because something asked it to; a fatal fault
-    // here parks the node and fans a false permanent-failure notice.
-    settleAbort('aborted-node', false, false, 'error');
-    assert.equal(readFault('aborted-node'), null, 'an abort-shaped error settlement must not record a provider fault');
-    settleAbort('provider-node', false, false, 'error', 'connection reset by peer');
-    const providerFault = readFault('provider-node');
-    assert.equal(providerFault?.kind, 'connection', 'a real provider error still classifies');
-    assert.equal(providerFault?.retry.disposition, 'auto', 'a real provider error still records its fault');
-});
-test('a failed retry settlement carries the episode forward instead of restarting it', () => {
-    // The episode marker a daemon retry records before re-prompting: original
-    // anchor, start time, and the attempt just consumed.
-    const sessionFile = 'retry-episode-session';
-    const admittedFault = recordPendingProviderRetryFault('retry-episode-node', sessionFile, {
-        link: 'pi→provider', op: 'generation turn', kind: 'connection',
-        retry: { disposition: 'auto', by: 'daemon', attempt: 2, max: 8 },
-        message: 'connection reset', since: '2026-01-01T00:00:00.000Z', anchorEntryId: 'original-anchor',
-    });
-    assert.ok(admittedFault, 'the pre-prompt retry fault persists');
-    assert.equal(admitProviderRetryEpisode('retry-episode-node', sessionFile, admittedFault), true, 'the retry is durably admitted before prompt');
-    clearFault('retry-episode-node', { link: 'pi→provider' }); // error turn_end clears its ordinary marker
-    assert.equal(readProviderRetryEpisode('retry-episode-node')?.state, 'admitted', 'error turn_end preserves the admitted retry for settlement');
-    const session = {
-        sessionFile,
-        sessionManager: { getLeafId: () => 'leaf-after-failed-retry' },
-        model: undefined,
-    };
-    const generation = {
-        id: 1,
-        session,
-        fallback: { blocked: false },
-        stagedProviderAgentEnd: {
-            messages: [{ role: 'assistant', stopReason: 'error', errorMessage: 'fetch failed' }],
-        },
-        stagedWatchdogAbort: false,
-        stagedRefreshAbort: false,
-        stagedOverflowFailure: null,
-        executingTools: new Set(),
-    };
-    new FaultRetry({
-        nodeId: 'retry-episode-node',
-        currentSession: () => session,
-        installedGeneration: () => generation,
-    }).publishSettledProviderFault(generation);
-    const fault = readFault('retry-episode-node');
-    assert.equal(fault?.anchorEntryId, 'original-anchor', 'each retry must rewind to the original fork point, not stack prompts');
-    assert.equal(fault?.since, '2026-01-01T00:00:00.000Z', 'the episode start survives a failed retry');
-    assert.equal(fault?.retry.attempt, 2, 'the attempt count accumulates toward exhaustion');
-    assert.equal(readProviderRetryEpisode('retry-episode-node')?.state, 'pending', 'the failed admitted retry becomes the next durable pending attempt');
-});

package/dist/core/canvas/human-deliveries.d.ts

@@ -1,39 +0,0 @@
-import type { DeliveryFailure, DeliverySettlement } from './delivery-contract.js';
-export type ActionDeliveryState = 'pending' | 'running' | 'accepted' | 'permanent_failed';
-export type ActionDeliveryFailure = DeliveryFailure;
-export interface ActionDeliveryRecord {
-    requestId: string;
-    state: ActionDeliveryState;
-    attempt: number;
-    argv: string[];
-    cwd: string;
-    completion: unknown;
-    nextAttemptAt: number;
-    claimedAt: number | null;
-    claimOwner: string | null;
-    acceptedAt: number | null;
-    permanentFailedAt: number | null;
-    lastFailure: ActionDeliveryFailure | null;
-    createdAt: number;
-    updatedAt: number;
-}
-/** Insert the one delivery row for a settled action-bound request. Idempotent
- *  on requestId: a replayed settlement must not create a second row. */
-export declare function enqueueActionDelivery(row: {
-    requestId: string;
-    argv: string[];
-    cwd: string;
-    /** Complete HumanCompletionV1 with delivery.attempt set to 0. */
-    completion: unknown;
-}): void;
-/** Delivery state for `GET /v1/human/requests/:id`; null when no row exists. */
-export declare function readActionDelivery(requestId: string): ActionDeliveryRecord | null;
-/** Due pending records in deterministic order for the daemon's serial tick. */
-export declare function dueActionDeliveries(now: number): ActionDeliveryRecord[];
-/** Atomically start one due delivery attempt. A null result lost the claim. */
-export declare function claimActionDelivery(requestId: string, now: number, claimOwner: string): ActionDeliveryRecord | null;
-export type ActionDeliverySettlement = DeliverySettlement;
-/** Settle only the still-owned running attempt, so a stale process cannot overwrite a newer claim. */
-export declare function settleActionDelivery(requestId: string, attempt: number, claimOwner: string, settlement: ActionDeliverySettlement, now: number): boolean;
-/** A new daemon deliberately redelivers interrupted completions at least once. */
-export declare function recoverRunningActionDeliveries(now: number): number;

package/dist/core/canvas/human-deliveries.js

@@ -1,75 +0,0 @@
-// Durable action-completion delivery state. The terminal ticket is composed
-// before this row exists; this module schedules its already-complete document.
-import { openDb, withCanvasWrite } from './db.js';
-function actionDeliveryFrom(row) {
-    return {
-        requestId: row.request_id,
-        state: row.state,
-        attempt: row.attempt,
-        argv: JSON.parse(row.argv_json),
-        cwd: row.cwd,
-        completion: JSON.parse(row.completion_json),
-        nextAttemptAt: row.next_attempt_at,
-        claimedAt: row.claimed_at,
-        claimOwner: row.claim_owner,
-        acceptedAt: row.accepted_at,
-        permanentFailedAt: row.permanent_failed_at,
-        lastFailure: row.last_failure_json === null ? null : JSON.parse(row.last_failure_json),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-/** Insert the one delivery row for a settled action-bound request. Idempotent
- *  on requestId: a replayed settlement must not create a second row. */
-export function enqueueActionDelivery(row) {
-    const now = Date.now();
-    withCanvasWrite((db) => {
-        db.prepare(`INSERT INTO human_action_deliveries
-        (request_id, state, attempt, argv_json, cwd, completion_json, next_attempt_at, created_at, updated_at)
-       VALUES (?, 'pending', 0, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(request_id) DO NOTHING`).run(row.requestId, JSON.stringify(row.argv), row.cwd, JSON.stringify(row.completion), now, now, now);
-    });
-}
-/** Delivery state for `GET /v1/human/requests/:id`; null when no row exists. */
-export function readActionDelivery(requestId) {
-    const row = openDb()
-        .prepare('SELECT * FROM human_action_deliveries WHERE request_id = ?')
-        .get(requestId);
-    return row === undefined ? null : actionDeliveryFrom(row);
-}
-/** Due pending records in deterministic order for the daemon's serial tick. */
-export function dueActionDeliveries(now) {
-    return openDb()
-        .prepare(`SELECT * FROM human_action_deliveries
-         WHERE state = 'pending' AND next_attempt_at <= ?
-         ORDER BY next_attempt_at, created_at, request_id`)
-        .all(now).map(actionDeliveryFrom);
-}
-/** Atomically start one due delivery attempt. A null result lost the claim. */
-export function claimActionDelivery(requestId, now, claimOwner) {
-    return withCanvasWrite((db) => {
-        const claimed = db.prepare(`UPDATE human_action_deliveries
-       SET state = 'running', attempt = attempt + 1, claimed_at = ?, claim_owner = ?, updated_at = ?
-       WHERE request_id = ? AND state = 'pending' AND next_attempt_at <= ?`).run(now, claimOwner, now, requestId, now);
-        if (Number(claimed.changes) === 0)
-            return null;
-        const row = db.prepare('SELECT * FROM human_action_deliveries WHERE request_id = ?').get(requestId);
-        return actionDeliveryFrom(row);
-    });
-}
-/** Settle only the still-owned running attempt, so a stale process cannot overwrite a newer claim. */
-export function settleActionDelivery(requestId, attempt, claimOwner, settlement, now) {
-    const failure = settlement.state === 'accepted' ? null : JSON.stringify(settlement.failure);
-    const result = withCanvasWrite((db) => db.prepare(`UPDATE human_action_deliveries
-     SET state = ?, next_attempt_at = ?, claimed_at = NULL, claim_owner = NULL,
-         accepted_at = ?, permanent_failed_at = ?, last_failure_json = ?, updated_at = ?
-     WHERE request_id = ? AND state = 'running' AND attempt = ? AND claim_owner = ?`).run(settlement.state, settlement.state === 'pending' ? settlement.nextAttemptAt : now, settlement.state === 'accepted' ? now : null, settlement.state === 'permanent_failed' ? now : null, failure, now, requestId, attempt, claimOwner));
-    return Number(result.changes) === 1;
-}
-/** A new daemon deliberately redelivers interrupted completions at least once. */
-export function recoverRunningActionDeliveries(now) {
-    const result = withCanvasWrite((db) => db.prepare(`UPDATE human_action_deliveries
-     SET state = 'pending', next_attempt_at = ?, claimed_at = NULL, claim_owner = NULL, updated_at = ?
-     WHERE state = 'running'`).run(now, now));
-    return Number(result.changes);
-}

package/dist/core/canvas/node-outcome-deliveries.d.ts

@@ -1,64 +0,0 @@
-import type { DeliveryFailure, DeliverySettlement } from './delivery-contract.js';
-import { type NodeOutcomeKind, type TerminalReason } from './types.js';
-export type OutcomeDeliveryState = 'armed' | 'pending' | 'running' | 'accepted' | 'permanent_failed';
-export type OutcomeDeliveryFailure = DeliveryFailure;
-export interface OutcomeDeliveryRecord {
-    nodeId: string;
-    state: OutcomeDeliveryState;
-    attempt: number;
-    actionName: string;
-    argv: string[];
-    cwd: string;
-    configOrigin: string;
-    payload: unknown | null;
-    document: unknown | null;
-    nextAttemptAt: number;
-    claimedAt: number | null;
-    claimOwner: string | null;
-    acceptedAt: number | null;
-    permanentFailedAt: number | null;
-    lastFailure: OutcomeDeliveryFailure | null;
-    createdAt: number;
-    updatedAt: number;
-}
-export interface OutcomeDocumentSnapshot {
-    kind: NodeOutcomeKind;
-    reason: TerminalReason;
-    at: string;
-    revision: number;
-    detailJson: string | null;
-}
-/** Compose every delivery document from the hydrated identity and the immutable outcome latch. */
-export declare function composeOutcomeDeliveryDocument(args: {
-    nodeId: string;
-    outcome: OutcomeDocumentSnapshot;
-    action: {
-        name: string;
-        payload: unknown;
-    };
-    finalReport?: string | null;
-    structuredResult?: unknown;
-}): string;
-/** Register a target atomically against the outcome latch. A still-armed target
- * is replaceable; a settled registration is not. When the outcome already
- * exists, the row is born pending with its complete immutable document. */
-export declare function armOutcomeDelivery(row: {
-    nodeId: string;
-    actionName: string;
-    argv: string[];
-    cwd: string;
-    configOrigin: string;
-    payload?: unknown;
-    now?: number;
-}): OutcomeDeliveryRecord | null;
-export declare function readOutcomeDelivery(nodeId: string): OutcomeDeliveryRecord | null;
-export declare function dueOutcomeDeliveries(now: number): OutcomeDeliveryRecord[];
-export declare function claimOutcomeDelivery(nodeId: string, now: number, claimOwner: string): OutcomeDeliveryRecord | null;
-export type OutcomeDeliverySettlement = DeliverySettlement;
-/** Settle only the still-owned running attempt, fencing stale delivery processes. */
-export declare function settleOutcomeDelivery(nodeId: string, attempt: number, claimOwner: string, settlement: OutcomeDeliverySettlement, now: number): boolean;
-export declare function recoverRunningOutcomeDeliveries(now: number): number;
-/** Disarming is deliberately limited to registrations that have not started delivery. */
-export declare function disarmOutcomeDelivery(nodeId: string): boolean;
-/** A canonical final is the one allowed outcome supersede: discard any old claim and retry state. */
-export declare function resetOutcomeDeliveryForSupersede(nodeId: string, documentJson: string | null, now: number): boolean;

package/dist/core/canvas/node-outcome-deliveries.js

@@ -1,159 +0,0 @@
-// Durable delivery registration and attempt state for a node's terminal outcome.
-import { openDb, withCanvasWrite } from './db.js';
-import { getNode } from './canvas.js';
-import { OUTCOME_PAYLOAD_MAX_BYTES } from './types.js';
-import { composeNodeOutcomeDocument } from '../runtime/outcome-document.js';
-function serializedPayload(payload) {
-    if (payload === undefined)
-        return null;
-    const json = JSON.stringify(payload);
-    if (json === undefined)
-        throw new TypeError('outcome delivery payload must be JSON-serializable');
-    if (Buffer.byteLength(json, 'utf8') > OUTCOME_PAYLOAD_MAX_BYTES) {
-        throw new RangeError(`outcome delivery payload exceeds ${OUTCOME_PAYLOAD_MAX_BYTES} bytes`);
-    }
-    return json;
-}
-function outcomeDeliveryFrom(row) {
-    return {
-        nodeId: row.node_id,
-        state: row.state,
-        attempt: row.attempt,
-        actionName: row.action_name,
-        argv: JSON.parse(row.argv_json),
-        cwd: row.cwd,
-        configOrigin: row.config_origin,
-        payload: row.payload_json === null ? null : JSON.parse(row.payload_json),
-        document: row.document_json === null ? null : JSON.parse(row.document_json),
-        nextAttemptAt: row.next_attempt_at,
-        claimedAt: row.claimed_at,
-        claimOwner: row.claim_owner,
-        acceptedAt: row.accepted_at,
-        permanentFailedAt: row.permanent_failed_at,
-        lastFailure: row.last_failure_json === null ? null : JSON.parse(row.last_failure_json),
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-/** The latch, rather than a later mutable row, defines the terminal view in a delivery document. */
-function nodeAtOutcome(node, outcome) {
-    let status;
-    let intent;
-    if (outcome.kind === 'result' || outcome.reason === 'finished' || outcome.reason === 'declined') {
-        status = 'done';
-        intent = 'done';
-    }
-    else if (outcome.reason === 'parked') {
-        status = 'done';
-        intent = 'parked';
-    }
-    else if (outcome.reason === 'closed' || outcome.reason === 'retired' || outcome.reason === 'stranded' || outcome.reason === 'deadline_exceeded') {
-        status = 'canceled';
-        intent = null;
-    }
-    else {
-        status = 'dead';
-        intent = null;
-    }
-    return { ...node, status, intent, terminal_reason: outcome.reason };
-}
-/** Compose every delivery document from the hydrated identity and the immutable outcome latch. */
-export function composeOutcomeDeliveryDocument(args) {
-    const node = getNode(args.nodeId);
-    if (node === null)
-        throw new Error(`unknown node ${args.nodeId}`);
-    return JSON.stringify(composeNodeOutcomeDocument({
-        node: nodeAtOutcome(node, args.outcome),
-        outcome: args.outcome,
-        action: args.action,
-        ...(args.finalReport === undefined ? {} : { finalReport: args.finalReport }),
-        ...(args.structuredResult === undefined ? {} : { structuredResult: args.structuredResult }),
-    }));
-}
-/** Register a target atomically against the outcome latch. A still-armed target
- * is replaceable; a settled registration is not. When the outcome already
- * exists, the row is born pending with its complete immutable document. */
-export function armOutcomeDelivery(row) {
-    const now = row.now ?? Date.now();
-    const payloadJson = serializedPayload(row.payload);
-    return withCanvasWrite((db) => {
-        const node = db.prepare('SELECT * FROM nodes WHERE node_id = ?').get(row.nodeId);
-        if (node === undefined)
-            throw new Error(`unknown node ${row.nodeId}`);
-        const settled = node.outcome_at !== null;
-        if (settled && (node.outcome_kind === null || node.outcome_reason === null)) {
-            throw new Error(`outcome latch is incomplete for node ${row.nodeId}`);
-        }
-        const documentJson = !settled
-            ? null
-            : composeOutcomeDeliveryDocument({
-                nodeId: row.nodeId,
-                outcome: {
-                    kind: node.outcome_kind,
-                    reason: node.outcome_reason,
-                    at: node.outcome_at,
-                    revision: node.outcome_revision,
-                    detailJson: node.outcome_detail_json,
-                },
-                action: { name: row.actionName, payload: row.payload ?? null },
-                finalReport: node.final_report,
-            });
-        const state = settled ? 'pending' : 'armed';
-        const inserted = db.prepare(`INSERT INTO node_outcome_deliveries
-        (node_id, state, action_name, argv_json, cwd, config_origin, payload_json, document_json, next_attempt_at, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-       ON CONFLICT(node_id) DO UPDATE SET
-         state = excluded.state, action_name = excluded.action_name, argv_json = excluded.argv_json,
-         cwd = excluded.cwd, config_origin = excluded.config_origin, payload_json = excluded.payload_json,
-         document_json = excluded.document_json, next_attempt_at = excluded.next_attempt_at,
-         updated_at = excluded.updated_at
-       WHERE node_outcome_deliveries.state = 'armed'`).run(row.nodeId, state, row.actionName, JSON.stringify(row.argv), row.cwd, row.configOrigin, payloadJson, documentJson, settled ? now : 0, now, now);
-        if (Number(inserted.changes) === 0)
-            return null;
-        return outcomeDeliveryFrom(db.prepare('SELECT * FROM node_outcome_deliveries WHERE node_id = ?').get(row.nodeId));
-    });
-}
-export function readOutcomeDelivery(nodeId) {
-    const row = openDb().prepare('SELECT * FROM node_outcome_deliveries WHERE node_id = ?').get(nodeId);
-    return row === undefined ? null : outcomeDeliveryFrom(row);
-}
-export function dueOutcomeDeliveries(now) {
-    return openDb().prepare(`SELECT * FROM node_outcome_deliveries
-     WHERE state = 'pending' AND next_attempt_at <= ?
-     ORDER BY next_attempt_at, created_at, node_id`).all(now).map(outcomeDeliveryFrom);
-}
-export function claimOutcomeDelivery(nodeId, now, claimOwner) {
-    return withCanvasWrite((db) => {
-        const claimed = db.prepare(`UPDATE node_outcome_deliveries
-       SET state = 'running', attempt = attempt + 1, claimed_at = ?, claim_owner = ?, updated_at = ?
-       WHERE node_id = ? AND state = 'pending' AND next_attempt_at <= ?`).run(now, claimOwner, now, nodeId, now);
-        if (Number(claimed.changes) === 0)
-            return null;
-        return outcomeDeliveryFrom(db.prepare('SELECT * FROM node_outcome_deliveries WHERE node_id = ?').get(nodeId));
-    });
-}
-/** Settle only the still-owned running attempt, fencing stale delivery processes. */
-export function settleOutcomeDelivery(nodeId, attempt, claimOwner, settlement, now) {
-    const failure = settlement.state === 'accepted' ? null : JSON.stringify(settlement.failure);
-    return withCanvasWrite((db) => Number(db.prepare(`UPDATE node_outcome_deliveries
-     SET state = ?, next_attempt_at = ?, claimed_at = NULL, claim_owner = NULL,
-         accepted_at = ?, permanent_failed_at = ?, last_failure_json = ?, updated_at = ?
-     WHERE node_id = ? AND state = 'running' AND attempt = ? AND claim_owner = ?`).run(settlement.state, settlement.state === 'pending' ? settlement.nextAttemptAt : now, settlement.state === 'accepted' ? now : null, settlement.state === 'permanent_failed' ? now : null, failure, now, nodeId, attempt, claimOwner).changes) === 1);
-}
-export function recoverRunningOutcomeDeliveries(now) {
-    return withCanvasWrite((db) => Number(db.prepare(`UPDATE node_outcome_deliveries
-     SET state = 'pending', next_attempt_at = ?, claimed_at = NULL, claim_owner = NULL, updated_at = ?
-     WHERE state = 'running'`).run(now, now).changes));
-}
-/** Disarming is deliberately limited to registrations that have not started delivery. */
-export function disarmOutcomeDelivery(nodeId) {
-    return withCanvasWrite((db) => Number(db.prepare("DELETE FROM node_outcome_deliveries WHERE node_id = ? AND state = 'armed'").run(nodeId).changes) === 1);
-}
-/** A canonical final is the one allowed outcome supersede: discard any old claim and retry state. */
-export function resetOutcomeDeliveryForSupersede(nodeId, documentJson, now) {
-    return withCanvasWrite((db) => Number(db.prepare(`UPDATE node_outcome_deliveries
-     SET state = 'pending', attempt = 0, document_json = ?, next_attempt_at = ?,
-         claimed_at = NULL, claim_owner = NULL, accepted_at = NULL, permanent_failed_at = NULL,
-         last_failure_json = NULL, updated_at = ?
-     WHERE node_id = ?`).run(documentJson, now, now, nodeId).changes) === 1);
-}

package/dist/core/feed/passive.d.ts

@@ -1,3 +0,0 @@
-import { type InboxEntry, type InboxEntryInput } from './inbox.js';
-/** Atomically append one finalized entry to `nodes/<nodeId>/passive.jsonl`. */
-export declare function appendPassive(nodeId: string, entry: InboxEntryInput): InboxEntry;

package/dist/core/feed/passive.js

@@ -1,53 +0,0 @@
-// Per-node passive-subscription accumulator for the pi-native canvas runtime.
-//
-// A PASSIVE subscription (the `active=false` flavor of a subscribes_to edge)
-// must never WAKE its subscriber. So when `push` fans out, a passive
-// subscriber's pointer is written here — to nodes/<id>/passive.jsonl — instead
-// of inbox.jsonl. The inbox-watcher polls only inbox.jsonl, so nothing here
-// triggers a turn.
-//
-// The accumulator is drained the moment the node is next MESSAGED: the
-// canvas-passive-context extension reads + clears this file on pi's `input`
-// event and injects every entry as timestamped XML pre-text before the message
-// reaches the LLM. Until then entries simply pile up, oldest first.
-//
-// Same entry shape as the inbox (InboxEntry) so the two stores stay symmetric
-// and a passive edge can be flipped active without reshaping data.
-import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { passivePath } from '../canvas/index.js';
-import { emitEvent } from '../events/emit.js';
-import { errorClassFromError } from '../events/errors.js';
-import { finalizeInboxEntry } from './inbox.js';
-/** Atomically append one finalized entry to `nodes/<nodeId>/passive.jsonl`. */
-export function appendPassive(nodeId, entry) {
-    const full = finalizeInboxEntry(entry);
-    try {
-        const line = JSON.stringify(full) + '\n';
-        const dir = dirname(passivePath(nodeId));
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        appendFileSync(passivePath(nodeId), line, { encoding: 'utf8', flag: 'a' });
-        return full;
-    }
-    catch (error) {
-        emitPassiveAppendFailure(nodeId, full, error);
-        throw error;
-    }
-}
-function emitPassiveAppendFailure(nodeId, entry, error) {
-    try {
-        emitEvent({
-            level: 'error',
-            event: 'inbox.delivery.failed',
-            operation_id: entry.operation_id,
-            outcome: 'failed',
-            error,
-            error_class: errorClassFromError(error),
-            fields: { stage: 'append', channel: 'passive', target_node_id: nodeId },
-        });
-    }
-    catch {
-        // Event emission is observational; the original append failure remains authoritative.
-    }
-}

package/dist/core/human/__tests__/inbox-cancel-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/human/__tests__/inbox-cancel-worker.js

@@ -1,7 +0,0 @@
-import { existsSync, writeFileSync } from 'node:fs';
-import { cancelTicket } from '../tickets.js';
-const [dir, barrier, ready] = process.argv.slice(2);
-writeFileSync(ready, 'ready');
-while (!existsSync(barrier))
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1);
-process.stdout.write(JSON.stringify(cancelTicket(dir)));

package/dist/core/human/__tests__/inbox-claim-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/human/__tests__/inbox-claim-worker.js

@@ -1,17 +0,0 @@
-import { existsSync, writeFileSync } from 'node:fs';
-import { claimTicket } from '../claim.js';
-const [dir, barrier, ready, result, release] = process.argv.slice(2);
-const spin = (path) => { while (!existsSync(path))
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1); };
-writeFileSync(ready, 'ready');
-spin(barrier);
-const claim = claimTicket(dir);
-writeFileSync(result, JSON.stringify(claim));
-process.stdout.write(JSON.stringify(claim));
-// Stay alive until the parent has read BOTH results and releases us. A same-host
-// claim is reclaimable the instant its holder's pid dies, so a winner that exited
-// early would legitimately free its claim for the peer — that is designed
-// stale-recovery, not a double-claim. Blocking here keeps both pids live across
-// the peer's attempt, so the assertion tests exclusion, not exit timing.
-if (release !== undefined)
-    spin(release);

package/dist/core/human/__tests__/inbox-stale-claim-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/human/__tests__/inbox-stale-claim-worker.js

@@ -1,8 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { claimTicket } from '../claim.js';
-// Writes a genuine claim from a SEPARATE process, as a remote host whose
-// heartbeat is already older than the remote-stale window, then exits. The
-// parent process then recovers the ticket, proving cross-process stale recovery.
-const [dir, ready] = process.argv.slice(2);
-const claim = claimTicket(dir, { host: 'other-host', pid: 1, now: new Date(Date.now() - 31_000) });
-writeFileSync(ready, JSON.stringify(claim));

package/dist/core/human/__tests__/integration/inbox-core.test.d.ts

@@ -1 +0,0 @@
-export {};