@jini-ai/daemon 0.3.8 → 0.5.1

package/dist/routines/scheduler.js

@@ -14,7 +14,7 @@
  * today as its own small, well-scoped task." Its only import was `node:crypto`'s `randomUUID`
  * (unchanged here); its `Routine`/`RoutineSchedule` types were already a documented local mirror,
  * not a product coupling (now `./types.js`); its `RoutinePersistence` injected port and
- * `RoutineRunHandler` callback are unchanged (see `./types.js`'s doc comments for why
+ * `RoutineRunHandler` callback preserve their behavior, with object arguments on the port (see `./types.js`'s doc comments for why
  * `RoutinePersistence` deliberately stays synchronous rather than converted to this package's
  * usual async-port convention). Logic is otherwise unchanged from the OD source — this is a
  * faithful port, not a redesign, per the proposal's own warning against "casually reinventing"
@@ -35,7 +35,7 @@ export class ScheduledRunPersistenceError extends Error {
     routineId;
     slotAt;
     originalError;
-    constructor(routineId, slotAt, originalError) {
+    constructor({ routineId, slotAt, originalError }) {
         super(`Routine ${routineId} scheduled slot ${slotAt} could not be persisted`);
         this.routineId = routineId;
         this.slotAt = slotAt;
@@ -50,30 +50,34 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 export class RoutineService {
-    persistence;
     timers = new Map();
     inflight = new Map();
     runHandler = null;
     started = false;
-    constructor(persistence) {
+    persistence;
+    now;
+    newId;
+    constructor({ persistence }, { now = Date.now, newId = randomUUID } = {}) {
         this.persistence = persistence;
+        this.now = now;
+        this.newId = newId;
     }
-    setRunHandler(handler) {
+    setRunHandler({ handler }) {
         this.runHandler = handler;
     }
-    start() {
+    start(_args) {
         if (this.started)
             return;
         this.started = true;
-        this.rescheduleAll();
+        this.rescheduleAll({});
     }
-    stop() {
+    stop(_args) {
         for (const entry of this.timers.values())
             clearTimeout(entry.timer);
         this.timers.clear();
         this.started = false;
     }
-    rescheduleAll() {
+    rescheduleAll(_args) {
         for (const entry of this.timers.values())
             clearTimeout(entry.timer);
         this.timers.clear();
@@ -83,7 +87,7 @@ export class RoutineService {
             this.scheduleRoutine(routine);
         }
     }
-    rescheduleOne(routineId) {
+    rescheduleOne({ routineId }) {
         const existing = this.timers.get(routineId);
         if (existing) {
             clearTimeout(existing.timer);
@@ -95,7 +99,7 @@ export class RoutineService {
         if (routine)
             this.scheduleRoutine(routine);
     }
-    unschedule(routineId) {
+    unschedule({ routineId }) {
         const existing = this.timers.get(routineId);
         if (existing) {
             clearTimeout(existing.timer);
@@ -105,7 +109,7 @@ export class RoutineService {
     scheduleRoutine(routine) {
         if (!routine.enabled)
             return;
-        const fireAt = nextRunAtForSchedule(routine.schedule);
+        const fireAt = nextRunAtForSchedule({ schedule: routine.schedule }, { now: new Date(this.now()) });
         if (!fireAt)
             return;
         this.scheduleRoutineAt(routine, fireAt);
@@ -122,14 +126,14 @@ export class RoutineService {
         // setTimeout can't carry past 2^31 ms (~24.8 days); we cap and use a chained re-schedule.
         // Routines fire within hours/days, but a misconfigured "next month" weekly value could
         // otherwise overflow.
-        const delay = Math.max(1_000, Math.min(2_000_000_000, fireAt.getTime() - Date.now()));
+        const delay = Math.max(1_000, Math.min(2_000_000_000, fireAt.getTime() - this.now()));
         const timer = setTimeout(() => {
             this.timers.delete(routine.id);
             const slotAt = fireAt.getTime();
             this.start_(routine.id, 'scheduled', { scheduledSlotAt: slotAt })
                 .then(() => {
                 // Always reschedule so a single fire keeps the cadence alive.
-                this.rescheduleOne(routine.id);
+                this.rescheduleOne({ routineId: routine.id });
             })
                 .catch((error) => {
                 console.error(`[@jini-ai/daemon] routine ${routine.id} scheduled run failed:`, error instanceof ScheduledRunPersistenceError
@@ -143,7 +147,7 @@ export class RoutineService {
                     this.retryScheduledSlot(routine.id, fireAt);
                 }
                 else {
-                    this.rescheduleOne(routine.id);
+                    this.rescheduleOne({ routineId: routine.id });
                 }
             });
         }, delay);
@@ -151,10 +155,10 @@ export class RoutineService {
             timer.unref();
         this.timers.set(routine.id, { routineId: routine.id, timer, fireAt });
     }
-    nextRunAt(routineId) {
+    nextRunAt({ routineId }) {
         return this.timers.get(routineId)?.fireAt ?? null;
     }
-    async runNow(routineId) {
+    async runNow({ routineId }) {
         return this.start_(routineId, 'manual');
     }
     /**
@@ -166,7 +170,7 @@ export class RoutineService {
         const slotAt = attempt.scheduledSlotAt;
         if (slotAt == null)
             return error;
-        return new ScheduledRunPersistenceError(attempt.routine.id, slotAt, error);
+        return new ScheduledRunPersistenceError({ routineId: attempt.routine.id, slotAt: slotAt, originalError: error });
     }
     /**
      * Tear-down for when the durable routine_run row was never inserted (insertRun threw, or another
@@ -192,7 +196,7 @@ export class RoutineService {
     claimRunRow(attempt) {
         let inserted = true;
         try {
-            inserted = this.persistence.insertRun(attempt.run, attempt.insertOptions) !== false;
+            inserted = this.persistence.insertRun({ run: attempt.run }, attempt.insertOptions) !== false;
         }
         catch (error) {
             this.discardUnstartedRun(attempt);
@@ -217,11 +221,11 @@ export class RoutineService {
         handlerStart.conversationId = run.conversationId;
         handlerStart.agentRunId = run.agentRunId;
         if (attempt.scheduledSlotAt != null || preparedIdsChanged) {
-            this.persistence.updateRun(attempt.runId, {
-                projectId: run.projectId,
-                conversationId: run.conversationId,
-                agentRunId: run.agentRunId,
-            });
+            this.persistence.updateRun({ id: attempt.runId, patch: {
+                    projectId: run.projectId,
+                    conversationId: run.conversationId,
+                    agentRunId: run.agentRunId,
+                } });
         }
     }
     /**
@@ -251,37 +255,37 @@ export class RoutineService {
         run.projectId = clearRoutinePlaceholderId(run.projectId);
         run.conversationId = clearRoutinePlaceholderId(run.conversationId);
         run.agentRunId = clearRoutinePlaceholderId(run.agentRunId);
-        this.persistence.updateRun(attempt.runId, {
-            status: 'failed',
-            completedAt: Date.now(),
-            summary: null,
-            error: errorMessage(error),
-            errorCode: null,
-            projectId: run.projectId,
-            conversationId: run.conversationId,
-            agentRunId: run.agentRunId,
-        });
+        this.persistence.updateRun({ id: attempt.runId, patch: {
+                status: 'failed',
+                completedAt: this.now(),
+                summary: null,
+                error: errorMessage(error),
+                errorCode: null,
+                projectId: run.projectId,
+                conversationId: run.conversationId,
+                agentRunId: run.agentRunId,
+            } });
     }
     /** Persists the terminal row once the host's run completes (or its completion promise rejects). */
     wireRunCompletion(attempt) {
         attempt.handlerStart.completion
             .then((completion) => {
-            this.persistence.updateRun(attempt.runId, {
-                status: completion.status,
-                completedAt: Date.now(),
-                summary: completion.summary ?? null,
-                error: completion.error ?? null,
-                errorCode: completion.errorCode ?? null,
-            });
+            this.persistence.updateRun({ id: attempt.runId, patch: {
+                    status: completion.status,
+                    completedAt: this.now(),
+                    summary: completion.summary ?? null,
+                    error: completion.error ?? null,
+                    errorCode: completion.errorCode ?? null,
+                } });
         })
             .catch((error) => {
-            this.persistence.updateRun(attempt.runId, {
-                status: 'failed',
-                completedAt: Date.now(),
-                summary: null,
-                error: errorMessage(error),
-                errorCode: null,
-            });
+            this.persistence.updateRun({ id: attempt.runId, patch: {
+                    status: 'failed',
+                    completedAt: this.now(),
+                    summary: null,
+                    error: errorMessage(error),
+                    errorCode: null,
+                } });
         });
     }
     /** Hands control to the host's `start()`, finalizing the row as failed if it throws synchronously. */
@@ -290,13 +294,13 @@ export class RoutineService {
             attempt.handlerStart.start?.();
         }
         catch (error) {
-            this.persistence.updateRun(attempt.runId, {
-                status: 'failed',
-                completedAt: Date.now(),
-                summary: null,
-                error: errorMessage(error),
-                errorCode: null,
-            });
+            this.persistence.updateRun({ id: attempt.runId, patch: {
+                    status: 'failed',
+                    completedAt: this.now(),
+                    summary: null,
+                    error: errorMessage(error),
+                    errorCode: null,
+                } });
             throw error;
         }
     }
@@ -309,8 +313,8 @@ export class RoutineService {
         const routine = this.persistence.list().find((r) => r.id === routineId);
         if (!routine)
             throw new Error(`Routine ${routineId} not found`);
-        const startedAt = Date.now();
-        const runId = `routine-run-${randomUUID()}`;
+        const startedAt = this.now();
+        const runId = `routine-run-${this.newId()}`;
         const promise = (async () => {
             const handler = this.runHandler;
             if (!handler)

package/dist/routines/types.d.ts

@@ -122,10 +122,17 @@ export type RoutineRunHandler = (input: {
  */
 export interface RoutinePersistence {
     list(): Routine[];
-    insertRun(run: RoutineRun, options?: {
+    insertRun(args: {
+        readonly run: RoutineRun;
+    }, optionalArgs?: {
         scheduledSlotAt?: number;
     }): boolean | void;
-    updateRun(id: string, patch: Partial<RoutineRun>): void;
-    getLatestRun(routineId: string): RoutineRun | null;
+    updateRun(args: {
+        readonly id: string;
+        readonly patch: Partial<RoutineRun>;
+    }): void;
+    getLatestRun(args: {
+        readonly routineId: string;
+    }): RoutineRun | null;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/run/core/result.d.ts

@@ -13,7 +13,9 @@ export interface RunStatusForAnalytics {
  * @param status - Raw status string from the run record (e.g. 'succeeded', 'canceled').
  * @returns 'success', 'cancelled', or 'failed'.
  */
-export declare function runResultFromStatus(status: string | undefined): RunResult;
+export declare function runResultFromStatus({ status }: {
+    readonly status: string | undefined;
+}): RunResult;
 /**
  * Derives a non-empty `error_code` for analytics whenever `result === 'failed'`.
  * Prefers the structured code stamped on the run; falls back to signal, exit
@@ -21,5 +23,7 @@ export declare function runResultFromStatus(status: string | undefined): RunResu
  * @param status - Run status fields including any stamped error code, exit code, and signal.
  * @returns An error code string, or `undefined` when the run succeeded.
  */
-export declare function deriveRunErrorCode(status: RunStatusForAnalytics): string | undefined;
+export declare function deriveRunErrorCode({ status }: {
+    readonly status: RunStatusForAnalytics;
+}): string | undefined;
 //# sourceMappingURL=result.d.ts.map

package/dist/run/core/result.js

@@ -14,7 +14,7 @@
  * @param status - Raw status string from the run record (e.g. 'succeeded', 'canceled').
  * @returns 'success', 'cancelled', or 'failed'.
  */
-export function runResultFromStatus(status) {
+export function runResultFromStatus({ status }) {
     if (status === 'succeeded')
         return 'success';
     if (status === 'canceled')
@@ -28,8 +28,8 @@ export function runResultFromStatus(status) {
  * @param status - Run status fields including any stamped error code, exit code, and signal.
  * @returns An error code string, or `undefined` when the run succeeded.
  */
-export function deriveRunErrorCode(status) {
-    const result = runResultFromStatus(status.status);
+export function deriveRunErrorCode({ status }) {
+    const result = runResultFromStatus({ status: status.status });
     if (result === 'success')
         return undefined;
     // Cancellation usually carries no error; only forward an explicit one

package/dist/run/core/retry.d.ts

@@ -19,7 +19,12 @@ export declare const MAX_RETRY_BACKOFF_DELAY_MS = 8000;
  * @param random - Optional jitter source; defaults to `Math.random` for production use.
  * @returns Backoff duration in milliseconds, capped at `MAX_RETRY_BACKOFF_DELAY_MS`.
  */
-export declare function computeRetryBackoffMs(attemptIndex: number, category: RunFailureCategory | undefined, random?: () => number): number;
+export declare function computeRetryBackoffMs({ attemptIndex, category }: {
+    readonly attemptIndex: number;
+    readonly category: RunFailureCategory | undefined;
+}, { random }?: {
+    readonly random?: () => number;
+}): number;
 /** Failure signal fields extracted from a run's error state, used by the retry policy. */
 export interface RunRetryFailureSignal {
     failure_category?: RunFailureCategory;
@@ -70,7 +75,10 @@ export type RunRetryPolicyDecision = {
  * @returns A `RunRetryFailureSignal` suitable for {@link decideSafeRunRetry}.
  * @complexity O(1).
  */
-export declare function classifyProcessExitFailure(code: number | null, signal: string | null): RunRetryFailureSignal;
+export declare function classifyProcessExitFailure({ code, signal }: {
+    readonly code: number | null;
+    readonly signal: string | null;
+}): RunRetryFailureSignal;
 /**
  * `@jini-ai/daemon`'s `ClassifyFailure` port needs a plain `boolean`, not a full
  * {@link RunRetryPolicyDecision} — gap 4 only sets a failed run's `resumable` flag (informational
@@ -95,12 +103,17 @@ export declare function classifyProcessExitFailure(code: number | null, signal:
  * behavior for any other caller.
  * @complexity O(1).
  */
-export declare function resumableFromProcessExit(code: number | null, signal: string | null, sideEffects?: Pick<RunRetrySideEffectState, 'userVisibleOutputSeen' | 'toolCallSeen'>): boolean;
+export declare function resumableFromProcessExit({ code, signal }: {
+    readonly code: number | null;
+    readonly signal: string | null;
+}, { sideEffects }?: {
+    readonly sideEffects?: Pick<RunRetrySideEffectState, 'userVisibleOutputSeen' | 'toolCallSeen'>;
+}): boolean;
 /**
  * Decides whether a failed run should be automatically retried and, if so, schedules the delay.
  * Suppresses retries when the run was cancelled, emitted user-visible output, or hit a non-transient failure.
  * @param input - Run outcome, failure classification, attempt count, and observable side effects.
  * @returns A `RunRetryPolicyDecision` with `shouldRetry: true` and a delay, or `shouldRetry: false` with a suppression reason.
  */
-export declare function decideSafeRunRetry(input: RunRetryPolicyInput): RunRetryPolicyDecision;
+export declare function decideSafeRunRetry(requiredArgs: Pick<RunRetryPolicyInput, "result" | "attemptCount">, optionalArgs?: Pick<RunRetryPolicyInput, "failure" | "maxAttempts" | "sideEffects" | "random">): RunRetryPolicyDecision;
 //# sourceMappingURL=retry.d.ts.map

package/dist/run/core/retry.js

@@ -37,7 +37,7 @@ function backoffBaseDelayMs(category) {
  * @param random - Optional jitter source; defaults to `Math.random` for production use.
  * @returns Backoff duration in milliseconds, capped at `MAX_RETRY_BACKOFF_DELAY_MS`.
  */
-export function computeRetryBackoffMs(attemptIndex, category, random = Math.random) {
+export function computeRetryBackoffMs({ attemptIndex, category }, { random = Math.random } = {}) {
     const exponent = Math.max(0, Math.floor(attemptIndex) - 1);
     const raw = backoffBaseDelayMs(category) * RETRY_BACKOFF_MULTIPLIER ** exponent;
     const capped = Math.min(raw, MAX_RETRY_BACKOFF_DELAY_MS);
@@ -57,7 +57,7 @@ export function computeRetryBackoffMs(attemptIndex, category, random = Math.rand
  * @returns A `RunRetryFailureSignal` suitable for {@link decideSafeRunRetry}.
  * @complexity O(1).
  */
-export function classifyProcessExitFailure(code, signal) {
+export function classifyProcessExitFailure({ code, signal }) {
     if (signal !== null) {
         return { failure_category: 'process_exit', failure_detail: 'signal_killed', retryable: true };
     }
@@ -90,13 +90,8 @@ export function classifyProcessExitFailure(code, signal) {
  * behavior for any other caller.
  * @complexity O(1).
  */
-export function resumableFromProcessExit(code, signal, sideEffects) {
-    const decision = decideSafeRunRetry({
-        result: 'failed',
-        failure: classifyProcessExitFailure(code, signal),
-        attemptCount: 0,
-        ...(sideEffects !== undefined ? { sideEffects } : {}),
-    });
+export function resumableFromProcessExit({ code, signal }, { sideEffects } = {}) {
+    const decision = decideSafeRunRetry({ result: 'failed', attemptCount: 0 }, { failure: classifyProcessExitFailure({ code: code, signal: signal }), ...(sideEffects !== undefined ? { sideEffects } : {}) });
     return decision.shouldRetry;
 }
 function normalizeAttemptCount(attemptCount) {
@@ -171,7 +166,8 @@ function transientSuppressedReason(category, detail, stage) {
  * @param input - Run outcome, failure classification, attempt count, and observable side effects.
  * @returns A `RunRetryPolicyDecision` with `shouldRetry: true` and a delay, or `shouldRetry: false` with a suppression reason.
  */
-export function decideSafeRunRetry(input) {
+export function decideSafeRunRetry(requiredArgs, optionalArgs = {}) {
+    const input = { ...requiredArgs, ...optionalArgs };
     const attemptCount = normalizeAttemptCount(input.attemptCount);
     const retryMaxAttempts = normalizeMaxAttempts(input.maxAttempts);
     const retryAttemptIndex = attemptCount + 1;
@@ -216,7 +212,7 @@ export function decideSafeRunRetry(input) {
         ...base,
         shouldRetry: true,
         retryReason: 'transient_failure',
-        retryDelayMs: computeRetryBackoffMs(retryAttemptIndex, failure.failure_category, input.random),
+        retryDelayMs: computeRetryBackoffMs({ attemptIndex: retryAttemptIndex, category: failure.failure_category }, input.random === undefined ? {} : { random: input.random }),
     };
 }
 //# sourceMappingURL=retry.js.map

package/dist/run/diagnostics/diagnostics.d.ts

@@ -6,7 +6,9 @@
  * `redactSecrets`). Defaults to identity so a caller that has already scrubbed —
  * or genuinely wants the raw tail — need not pass one.
  */
-export type TailRedactor = (text: string) => string;
+export type TailRedactor = (args: {
+    text: string;
+}) => string;
 /** A recorded run event entry passed to diagnostics collection functions for scanning. */
 export interface RunEventForDiagnostics {
     event: string;
@@ -48,7 +50,9 @@ export type StdoutTailSummary = StreamTailSummary;
  * @param count - Total number of non-empty lines in the stream.
  * @returns A `StderrLineCountBucket` string for use in analytics payloads.
  */
-export declare function stderrLineCountBucket(count: number): StderrLineCountBucket;
+export declare function stderrLineCountBucket({ count }: {
+    readonly count: number;
+}): StderrLineCountBucket;
 /**
  * Collects the tail of the stderr stream from a run's event list, scrubbed by the
  * supplied redactor. Returns `undefined` when no stderr output was recorded.
@@ -56,7 +60,10 @@ export declare function stderrLineCountBucket(count: number): StderrLineCountBuc
  * @param redact - Secret/PII scrubber applied to the joined tail; defaults to identity.
  * @returns A `StderrTailSummary` with the last 20 lines (capped at 4 KB) and a truncation flag, or `undefined`.
  */
-export declare function collectStderrTailSummary(events?: RunEventForDiagnostics[], redact?: TailRedactor): StderrTailSummary | undefined;
+export declare function collectStderrTailSummary(_requiredArgs: Record<string, never>, { events, redact }?: {
+    readonly events?: RunEventForDiagnostics[];
+    readonly redact?: TailRedactor;
+}): StderrTailSummary | undefined;
 /**
  * Collects the tail of the stdout stream from a run's event list, scrubbed by the
  * supplied redactor. Returns `undefined` when no stdout output was recorded.
@@ -64,7 +71,10 @@ export declare function collectStderrTailSummary(events?: RunEventForDiagnostics
  * @param redact - Secret/PII scrubber applied to the joined tail; defaults to identity.
  * @returns A `StdoutTailSummary` with the last 20 lines (capped at 4 KB) and a truncation flag, or `undefined`.
  */
-export declare function collectStdoutTailSummary(events?: RunEventForDiagnostics[], redact?: TailRedactor): StdoutTailSummary | undefined;
+export declare function collectStdoutTailSummary(_requiredArgs: Record<string, never>, { events, redact }?: {
+    readonly events?: RunEventForDiagnostics[];
+    readonly redact?: TailRedactor;
+}): StdoutTailSummary | undefined;
 /**
  * Produces the full `RunDiagnosticsAnalytics` payload for a completed run by scanning its event stream
  * and combining observed flags (tool calls, artifact writes, first token) with process-level signals.

package/dist/run/diagnostics/diagnostics.js

@@ -1,5 +1,5 @@
 /** @module run/diagnostics/diagnostics — Stderr/stdout tail collection and diagnostic analytics summarization for completed runs. */
-const identityRedactor = (text) => text;
+const identityRedactor = ({ text }) => text;
 const STDERR_TAIL_MAX_LINES = 20;
 const STDERR_TAIL_MAX_BYTES = 4 * 1024;
 function readStderrChunk(data) {
@@ -36,7 +36,7 @@ function countLines(text) {
  * @param count - Total number of non-empty lines in the stream.
  * @returns A `StderrLineCountBucket` string for use in analytics payloads.
  */
-export function stderrLineCountBucket(count) {
+export function stderrLineCountBucket({ count }) {
     if (count <= 0)
         return 'none';
     if (count <= 5)
@@ -72,7 +72,7 @@ function collectStreamTailSummary(events, eventName, readChunk, redact) {
     const lines = streamText.trimEnd().split(/\r?\n/);
     const tailLines = lines.slice(-STDERR_TAIL_MAX_LINES);
     const lineTruncated = lines.length > tailLines.length;
-    const redacted = redact(tailLines.join('\n'));
+    const redacted = redact({ text: tailLines.join('\n') });
     const byteCapped = truncateUtf8(redacted, STDERR_TAIL_MAX_BYTES);
     return {
         tail: byteCapped.value,
@@ -87,7 +87,7 @@ function collectStreamTailSummary(events, eventName, readChunk, redact) {
  * @param redact - Secret/PII scrubber applied to the joined tail; defaults to identity.
  * @returns A `StderrTailSummary` with the last 20 lines (capped at 4 KB) and a truncation flag, or `undefined`.
  */
-export function collectStderrTailSummary(events = [], redact = identityRedactor) {
+export function collectStderrTailSummary(_requiredArgs, { events = [], redact = identityRedactor } = {}) {
     return collectStreamTailSummary(events, 'stderr', readStderrChunk, redact);
 }
 /**
@@ -97,7 +97,7 @@ export function collectStderrTailSummary(events = [], redact = identityRedactor)
  * @param redact - Secret/PII scrubber applied to the joined tail; defaults to identity.
  * @returns A `StdoutTailSummary` with the last 20 lines (capped at 4 KB) and a truncation flag, or `undefined`.
  */
-export function collectStdoutTailSummary(events = [], redact = identityRedactor) {
+export function collectStdoutTailSummary(_requiredArgs, { events = [], redact = identityRedactor } = {}) {
     return collectStreamTailSummary(events, 'stdout', readStdoutChunk, redact);
 }
 /** The set of `rpc_close_reason` strings a `runtime_close` diagnostic may legitimately carry. */
@@ -254,9 +254,9 @@ export function summarizeRunDiagnosticsForAnalytics(args) {
             exitCode: args.exitCode,
         }),
         stderr_present: stderrPresent,
-        stderr_line_count_bucket: stderrLineCountBucket(stderrLineCount),
+        stderr_line_count_bucket: stderrLineCountBucket({ count: stderrLineCount }),
         stdout_present: stdoutPresent,
-        stdout_line_count_bucket: stderrLineCountBucket(stdoutLineCount),
+        stdout_line_count_bucket: stderrLineCountBucket({ count: stdoutLineCount }),
         rpc_close_reason: resolveRpcCloseReason(observed.recordedCloseReason, args),
         first_token_seen: args.firstTokenSeen === true,
         user_visible_output_seen: observed.userVisibleOutputSeen,

package/dist/run/index.d.ts

@@ -7,7 +7,7 @@
  * daemon's run capability barrel. Product telemetry (runtime-type / usage /
  * timing analytics), the vendor-specific failure classifier, artifact
  * filesystem snapshotting, and MCP tool-bundle resolution are deliberately
- * out of scope here — see `source-map.md`.
+ * out of scope here — see `archived provenance ledger`.
  */
 export { runResultFromStatus, deriveRunErrorCode, DEFAULT_SAFE_RUN_RETRY_MAX_ATTEMPTS, SAFE_RUN_RETRY_STRATEGY, RATE_LIMIT_RETRY_BASE_DELAY_MS, TRANSIENT_RETRY_BASE_DELAY_MS, RETRY_BACKOFF_MULTIPLIER, MAX_RETRY_BACKOFF_DELAY_MS, computeRetryBackoffMs, decideSafeRunRetry, classifyProcessExitFailure, resumableFromProcessExit, } from './core/index.js';
 export type { RunResult, RunStatusForAnalytics, RunFailureResult, RunFailureCategory, RunFailureDetail, RunFailureStage, RunRetryStrategy, RunRetrySuppressedReason, RunRetryFailureSignal, RunRetrySideEffectState, RunRetryPolicyInput, RunRetryPolicyDecision, } from './core/index.js';

package/dist/run/index.js

@@ -7,7 +7,7 @@
  * daemon's run capability barrel. Product telemetry (runtime-type / usage /
  * timing analytics), the vendor-specific failure classifier, artifact
  * filesystem snapshotting, and MCP tool-bundle resolution are deliberately
- * out of scope here — see `source-map.md`.
+ * out of scope here — see `archived provenance ledger`.
  */
 // core — result derivation, failure taxonomy, and retry policy
 export { runResultFromStatus, deriveRunErrorCode, DEFAULT_SAFE_RUN_RETRY_MAX_ATTEMPTS, SAFE_RUN_RETRY_STRATEGY, RATE_LIMIT_RETRY_BASE_DELAY_MS, TRANSIENT_RETRY_BASE_DELAY_MS, RETRY_BACKOFF_MULTIPLIER, MAX_RETRY_BACKOFF_DELAY_MS, computeRetryBackoffMs, decideSafeRunRetry, classifyProcessExitFailure, resumableFromProcessExit, } from './core/index.js';