@jini-ai/daemon 0.1.0

package/dist/routines/types.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Domain types for the routine scheduler ({@link ./scheduler.js}) and its HTTP-facing
+ * CRUD+history counterpart, {@link RoutineStore} (`./routine-store.js`). Mirrors OD's
+ * `apps/daemon/src/routines.ts` local type block field-for-field — that file's own header
+ * comment already noted these types are "a local mirror... kept here so this service
+ * typechecks under NodeNext," not a product coupling, so the port is a straight lift.
+ */
+export type RoutineRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'canceled';
+export type RoutineRunTrigger = 'manual' | 'scheduled';
+export type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type RoutineSchedule = {
+    kind: 'hourly';
+    minute: number;
+} | {
+    kind: 'daily';
+    time: string;
+    timezone: string;
+} | {
+    kind: 'weekdays';
+    time: string;
+    timezone: string;
+} | {
+    kind: 'weekly';
+    time: string;
+    timezone: string;
+    weekday: Weekday;
+};
+export type RoutineProjectTarget = {
+    mode: 'create_each_run';
+} | {
+    mode: 'reuse';
+    projectId: string;
+};
+/** Opaque scope selection a routine's run inherits — generic ids only, no OD skill/plugin/MCP/connector vocabulary baked in beyond field names already this abstract in the origin. */
+export interface RoutineContextSelection {
+    skillIds?: string[];
+    pluginIds?: string[];
+    mcpServerIds?: string[];
+    connectorIds?: string[];
+}
+export interface Routine {
+    id: string;
+    name: string;
+    prompt: string;
+    schedule: RoutineSchedule;
+    target: RoutineProjectTarget;
+    skillId: string | null;
+    agentId: string | null;
+    context: RoutineContextSelection;
+    enabled: boolean;
+    nextRunAt: number | null;
+    lastRun: unknown;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface RoutineRun {
+    id: string;
+    routineId: string;
+    trigger: RoutineRunTrigger;
+    status: RoutineRunStatus;
+    projectId: string;
+    conversationId: string;
+    agentRunId: string;
+    startedAt: number;
+    completedAt: number | null;
+    summary: string | null;
+    error: string | null;
+    errorCode: string | null;
+}
+export interface RoutineRunHandlerStart {
+    projectId: string;
+    conversationId: string;
+    agentRunId: string;
+    completion: Promise<RoutineRunCompletion>;
+    prepare?: (run: RoutineRun) => void | Promise<void>;
+    start?: () => void;
+    /**
+     * Tear-down for the case where the handler returned a start handle but {@link RoutineService}
+     * later reached `prepare()` and it failed — i.e. the routine_run row exists, prepare may have
+     * partially mutated project/conversation/snapshot state, and the in-memory chat run still
+     * needs to terminate as `canceled`. Callers MUST surface failures rather than swallow them
+     * (the loser-retry path depends on it).
+     */
+    discard?: () => void;
+    /**
+     * Tear-down for the case where the run was NEVER durably inserted — either `insertRun()`
+     * threw, or `insertRun()` returned `false` because a sibling daemon already won the scheduled
+     * slot. Prepare has not run, so no project/conversation/snapshot writes need rolling back. The
+     * in-memory chat run must also be removed from the registry instead of being finalized as
+     * `canceled`, otherwise duplicate-loser slots would surface phantom canceled runs on a run
+     * listing. Falls back to `discard` when the handler does not distinguish the two cases.
+     */
+    discardUnstarted?: () => void;
+}
+export interface RoutineRunCompletion {
+    status: RoutineRunStatus;
+    summary?: string;
+    error?: string;
+    errorCode?: string | null;
+}
+export type RoutineRunHandler = (input: {
+    routine: Routine;
+    trigger: RoutineRunTrigger;
+    startedAt: number;
+    runId: string;
+}) => Promise<RoutineRunHandlerStart>;
+/**
+ * Storage port the scheduler ({@link ./scheduler.js}'s `RoutineService`) is injected with.
+ * Deliberately synchronous — kept faithful to the OD original rather than converted to this
+ * repo's usual async-port convention (see `event-log.ts`'s "ports are async-only from day one"
+ * doc note): the scheduler's `setTimeout`-driven fire path and its race-safe scheduled-slot
+ * claim (`ScheduledRunPersistenceError`) are exactly the "genuinely hard to get right" logic the
+ * porting proposal (`ADS-memory/reports/proposals/
+ * PROP-http-route-packs-automation-routines-2026-07-21.md`) flagged as "not something to
+ * casually reinvent" — a mechanical sync-to-async conversion of every call site inside
+ * `scheduleRoutineAt`'s timer callback risks introducing new races in exactly that logic for no
+ * behavioral gain, since a real backing store can still satisfy this port synchronously (an
+ * in-process cache kept warm by the separately-async {@link RoutineStore}) even when durable
+ * writes underneath are async. Building that bridge is host-level integration wiring, not this
+ * port's job — the same way `runs.ts`'s `onStarted` driver is host-supplied rather than built
+ * into `RunLifecycle` itself.
+ */
+export interface RoutinePersistence {
+    list(): Routine[];
+    insertRun(run: RoutineRun, options?: {
+        scheduledSlotAt?: number;
+    }): boolean | void;
+    updateRun(id: string, patch: Partial<RoutineRun>): void;
+    getLatestRun(routineId: string): RoutineRun | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/routines/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/routines/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE1F,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEhD,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACjD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAEzE,MAAM,MAAM,oBAAoB,GAAG;IAAE,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtG,uLAAuL;AACvL,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,eAAe,CAAC;IAC1B,MAAM,EAAE,oBAAoB,CAAC;IAC7B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,OAAO,EAAE,uBAAuB,CAAC;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC1C,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,IAAI,OAAO,EAAE,CAAC;IAClB,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,GAAG,IAAI,CAAC;IACnF,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IACxD,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;CACpD"}

package/dist/routines/types.js

@@ -0,0 +1,9 @@
+/**
+ * Domain types for the routine scheduler ({@link ./scheduler.js}) and its HTTP-facing
+ * CRUD+history counterpart, {@link RoutineStore} (`./routine-store.js`). Mirrors OD's
+ * `apps/daemon/src/routines.ts` local type block field-for-field — that file's own header
+ * comment already noted these types are "a local mirror... kept here so this service
+ * typechecks under NodeNext," not a product coupling, so the port is a straight lift.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/routines/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/routines/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/run/core/failure-taxonomy.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @module run/core/failure-taxonomy — Neutral run-failure taxonomy.
+ *
+ * Product-neutral string-literal unions describing a run's failure
+ * classification (category / detail / stage / user action) and the safe-retry
+ * decision vocabulary (strategy / suppressed reason). The run-orchestration
+ * retry policy in `./retry.ts` consumes these as its failure-signal contract;
+ * a consumer supplies the concrete signal from its own classifier.
+ *
+ * These were the shared analytics-contract enums an external classifier stamped
+ * on each run. Only the vocabulary is kept here — the engine has no opinion on
+ * how a consumer derives it — with the single vendor-account-balance member
+ * dropped as product-specific.
+ */
+/** Terminal outcome of a run as reported to the retry policy. */
+export type RunFailureResult = 'success' | 'failed' | 'cancelled';
+/** Coarse failure family a terminal failure is bucketed into. */
+export type RunFailureCategory = 'auth' | 'rate_limit' | 'insufficient_balance' | 'model_unavailable' | 'prompt_too_large' | 'upstream_unavailable' | 'timeout' | 'empty_output' | 'tool_error' | 'process_exit' | 'user_cancel' | 'unknown';
+/** Specific failure detail refining a {@link RunFailureCategory}. */
+export type RunFailureDetail = 'auth_required' | 'stale_profile' | 'refresh_token_reused' | 'missing_api_key' | 'invalid_api_key' | 'hard_quota' | 'workspace_credits_exhausted' | 'rate_limit_429' | 'model_not_found' | 'model_not_supported' | 'model_disabled' | 'local_model_not_loaded' | 'cli_version_incompatible' | 'prompt_too_large' | 'upstream_5xx' | 'upstream_client_error' | 'stream_disconnected' | 'network_error' | 'provider_high_demand' | 'provider_routing_error' | 'inactivity_timeout' | 'timeout' | 'empty_output' | 'tool_error' | 'plugin_artifact_missing' | 'cli_not_installed' | 'git_bash_missing' | 'agent_config_invalid' | 'spawn_failed' | 'spawn_enoexec' | 'spawn_ebadf' | 'spawn_eperm' | 'stdin_write_eof' | 'agent_protocol_error' | 'session_resume_expired' | 'fabricated_role_marker' | 'permission_request_not_found' | 'qoder_stop_sequence' | 'signal_killed' | 'process_crashed' | 'interrupted' | 'exit_code' | 'terminated_unknown' | 'stream_error' | 'exit_nonzero' | 'fatal_rpc_error' | 'execution_failed' | 'user_cancelled' | 'unknown';
+/** Lifecycle stage a run had reached when it failed. */
+export type RunFailureStage = 'preflight' | 'spawn' | 'session_init' | 'model_select' | 'prompt_send' | 'first_token_wait' | 'tool_execution' | 'artifact_write' | 'child_close' | 'finalize';
+/** Retry strategy label attached to an automatic same-run transient retry. */
+export type RunRetryStrategy = 'same_run_transient';
+/** Reason an eligible-looking failure was NOT automatically retried. */
+export type RunRetrySuppressedReason = 'not_failed' | 'not_retryable' | 'unsupported_category' | 'non_retryable_category' | 'unsafe_failure_stage' | 'missing_failure_signal' | 'hard_quota' | 'attempt_limit_reached' | 'cancel_requested' | 'user_visible_output_seen' | 'tool_call_seen' | 'artifact_write_seen' | 'live_artifact_seen';
+//# sourceMappingURL=failure-taxonomy.d.ts.map

package/dist/run/core/failure-taxonomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure-taxonomy.d.ts","sourceRoot":"","sources":["../../../src/run/core/failure-taxonomy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,iEAAiE;AACjE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAC;AAElE,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,YAAY,GACZ,sBAAsB,GACtB,mBAAmB,GACnB,kBAAkB,GAClB,sBAAsB,GACtB,SAAS,GACT,cAAc,GACd,YAAY,GACZ,cAAc,GACd,aAAa,GACb,SAAS,CAAC;AAEd,qEAAqE;AACrE,MAAM,MAAM,gBAAgB,GACxB,eAAe,GACf,eAAe,GACf,sBAAsB,GACtB,iBAAiB,GACjB,iBAAiB,GACjB,YAAY,GACZ,6BAA6B,GAC7B,gBAAgB,GAChB,iBAAiB,GACjB,qBAAqB,GACrB,gBAAgB,GAChB,wBAAwB,GACxB,0BAA0B,GAC1B,kBAAkB,GAClB,cAAc,GACd,uBAAuB,GACvB,qBAAqB,GACrB,eAAe,GACf,sBAAsB,GACtB,wBAAwB,GACxB,oBAAoB,GACpB,SAAS,GACT,cAAc,GACd,YAAY,GACZ,yBAAyB,GACzB,mBAAmB,GACnB,kBAAkB,GAClB,sBAAsB,GACtB,cAAc,GACd,eAAe,GACf,aAAa,GACb,aAAa,GACb,iBAAiB,GACjB,sBAAsB,GACtB,wBAAwB,GACxB,wBAAwB,GACxB,8BAA8B,GAC9B,qBAAqB,GACrB,eAAe,GACf,iBAAiB,GACjB,aAAa,GACb,WAAW,GACX,oBAAoB,GACpB,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,gBAAgB,GAChB,SAAS,CAAC;AAEd,wDAAwD;AACxD,MAAM,MAAM,eAAe,GACvB,WAAW,GACX,OAAO,GACP,cAAc,GACd,cAAc,GACd,aAAa,GACb,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,GAChB,aAAa,GACb,UAAU,CAAC;AAEf,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;AAEpD,wEAAwE;AACxE,MAAM,MAAM,wBAAwB,GAChC,YAAY,GACZ,eAAe,GACf,sBAAsB,GACtB,wBAAwB,GACxB,sBAAsB,GACtB,wBAAwB,GACxB,YAAY,GACZ,uBAAuB,GACvB,kBAAkB,GAClB,0BAA0B,GAC1B,gBAAgB,GAChB,qBAAqB,GACrB,oBAAoB,CAAC"}

package/dist/run/core/failure-taxonomy.js

@@ -0,0 +1,16 @@
+/**
+ * @module run/core/failure-taxonomy — Neutral run-failure taxonomy.
+ *
+ * Product-neutral string-literal unions describing a run's failure
+ * classification (category / detail / stage / user action) and the safe-retry
+ * decision vocabulary (strategy / suppressed reason). The run-orchestration
+ * retry policy in `./retry.ts` consumes these as its failure-signal contract;
+ * a consumer supplies the concrete signal from its own classifier.
+ *
+ * These were the shared analytics-contract enums an external classifier stamped
+ * on each run. Only the vocabulary is kept here — the engine has no opinion on
+ * how a consumer derives it — with the single vendor-account-balance member
+ * dropped as product-specific.
+ */
+export {};
+//# sourceMappingURL=failure-taxonomy.js.map

package/dist/run/core/failure-taxonomy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure-taxonomy.js","sourceRoot":"","sources":["../../../src/run/core/failure-taxonomy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

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

@@ -0,0 +1,5 @@
+/** @module run/core — Run result types, error codes, failure taxonomy, and retry backoff policy. */
+export * from './result.js';
+export * from './failure-taxonomy.js';
+export * from './retry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/run/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/run/core/index.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC"}

package/dist/run/core/index.js

@@ -0,0 +1,5 @@
+/** @module run/core — Run result types, error codes, failure taxonomy, and retry backoff policy. */
+export * from './result.js';
+export * from './failure-taxonomy.js';
+export * from './retry.js';
+//# sourceMappingURL=index.js.map

package/dist/run/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/run/core/index.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC"}

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

@@ -0,0 +1,25 @@
+/** @module run/core/result — Run result and status-code primitives shared by all run-domain concerns. */
+/** Terminal outcome of a run as reported in analytics and lifecycle events. */
+export type RunResult = 'success' | 'failed' | 'cancelled';
+/** Minimal run-status shape required to derive analytics result and error codes. */
+export interface RunStatusForAnalytics {
+    status: string;
+    errorCode?: string | null;
+    exitCode?: number | null;
+    signal?: string | null;
+}
+/**
+ * Maps a raw run status string to the canonical `RunResult` used by analytics.
+ * @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;
+/**
+ * Derives a non-empty `error_code` for analytics whenever `result === 'failed'`.
+ * Prefers the structured code stamped on the run; falls back to signal, exit
+ * code, or a sentinel so dashboards never see a blank cell.
+ * @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;
+//# sourceMappingURL=result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/run/core/result.ts"],"names":[],"mappings":"AAYA,yGAAyG;AAEzG,+EAA+E;AAC/E,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE3D,oFAAoF;AACpF,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAIzE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,qBAAqB,GAC5B,MAAM,GAAG,SAAS,CAgBpB"}

package/dist/run/core/result.js

@@ -0,0 +1,52 @@
+// Turns a run's terminal status into the `result` + `error_code` shape that
+// downstream analytics / lifecycle events expect.
+//
+// The invariant this enforces — `result === 'failed'` MUST carry a non-empty
+// `error_code` — is exercisable in isolation. Several failure paths in the
+// child-process lifecycle finish a run as `failed` directly without first
+// emitting an `error` event (fatal RPC, stream-error fall-through, a child
+// error with no diagnostic, etc.), leaving `errorCode === null`. The fallback
+// chain below derives an `AGENT_SIGNAL_*` / `AGENT_EXIT_*` /
+// `AGENT_TERMINATED_UNKNOWN` value for those cases so a failed run always
+// carries an `error_code` and dashboards keyed on it never see a blank cell.
+/**
+ * Maps a raw run status string to the canonical `RunResult` used by analytics.
+ * @param status - Raw status string from the run record (e.g. 'succeeded', 'canceled').
+ * @returns 'success', 'cancelled', or 'failed'.
+ */
+export function runResultFromStatus(status) {
+    if (status === 'succeeded')
+        return 'success';
+    if (status === 'canceled')
+        return 'cancelled';
+    return 'failed';
+}
+/**
+ * Derives a non-empty `error_code` for analytics whenever `result === 'failed'`.
+ * Prefers the structured code stamped on the run; falls back to signal, exit
+ * code, or a sentinel so dashboards never see a blank cell.
+ * @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);
+    if (result === 'success')
+        return undefined;
+    // Cancellation usually carries no error; only forward an explicit one
+    // when the daemon stamped it (e.g. cancel during error recovery).
+    if (result === 'cancelled')
+        return status.errorCode ?? undefined;
+    // Failure path: prefer the structured code stamped on the run. When the run
+    // reached `failed` without going through an `error` emission, derive the best
+    // signal we have.
+    const explicit = status.errorCode;
+    if (explicit)
+        return explicit;
+    if (status.signal)
+        return `AGENT_SIGNAL_${status.signal}`;
+    if (typeof status.exitCode === 'number' && status.exitCode !== 0) {
+        return `AGENT_EXIT_${status.exitCode}`;
+    }
+    return 'AGENT_TERMINATED_UNKNOWN';
+}
+//# sourceMappingURL=result.js.map

package/dist/run/core/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../../src/run/core/result.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,kDAAkD;AAClD,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,0EAA0E;AAC1E,2EAA2E;AAC3E,8EAA8E;AAC9E,6DAA6D;AAC7D,0EAA0E;AAC1E,6EAA6E;AAe7E;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAA0B;IAC5D,IAAI,MAAM,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IAC7C,IAAI,MAAM,KAAK,UAAU;QAAE,OAAO,WAAW,CAAC;IAC9C,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAA6B;IAE7B,MAAM,MAAM,GAAG,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClD,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3C,sEAAsE;IACtE,kEAAkE;IAClE,IAAI,MAAM,KAAK,WAAW;QAAE,OAAO,MAAM,CAAC,SAAS,IAAI,SAAS,CAAC;IACjE,4EAA4E;IAC5E,8EAA8E;IAC9E,kBAAkB;IAClB,MAAM,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC;IAClC,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,IAAI,MAAM,CAAC,MAAM;QAAE,OAAO,gBAAgB,MAAM,CAAC,MAAM,EAAE,CAAC;IAC1D,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;QACjE,OAAO,cAAc,MAAM,CAAC,QAAQ,EAAE,CAAC;IACzC,CAAC;IACD,OAAO,0BAA0B,CAAC;AACpC,CAAC"}

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

@@ -0,0 +1,106 @@
+import type { RunFailureCategory, RunFailureDetail, RunFailureStage, RunFailureResult, RunRetryStrategy, RunRetrySuppressedReason } from './failure-taxonomy.js';
+/** @module run/core/retry — Retry backoff constants and policy decision logic for safe run retries. */
+/** Maximum number of automatic same-run retry attempts allowed per run (not counting the initial attempt). */
+export declare const DEFAULT_SAFE_RUN_RETRY_MAX_ATTEMPTS = 1;
+/** Retry strategy label emitted in analytics for all automatic same-run transient retries. */
+export declare const SAFE_RUN_RETRY_STRATEGY: RunRetryStrategy;
+/** Base backoff delay in milliseconds for rate-limit retries; larger than the transient base because the upstream is explicitly asking us to slow down. */
+export declare const RATE_LIMIT_RETRY_BASE_DELAY_MS = 1000;
+/** Base backoff delay in milliseconds for non-rate-limit transient retries. */
+export declare const TRANSIENT_RETRY_BASE_DELAY_MS = 500;
+/** Exponential multiplier applied per retry attempt index to grow the backoff delay. */
+export declare const RETRY_BACKOFF_MULTIPLIER = 2;
+/** Maximum backoff delay in milliseconds after exponential growth and before jitter is applied. */
+export declare const MAX_RETRY_BACKOFF_DELAY_MS = 8000;
+/**
+ * Computes an exponentially backed-off delay with equal jitter for a retry attempt.
+ * @param attemptIndex - 1-based index of the attempt about to be scheduled.
+ * @param category - Failure category used to select the base delay; rate-limit failures use a larger base.
+ * @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;
+/** Failure signal fields extracted from a run's error state, used by the retry policy. */
+export interface RunRetryFailureSignal {
+    failure_category?: RunFailureCategory;
+    failure_detail?: RunFailureDetail;
+    failure_stage?: RunFailureStage;
+    retryable?: boolean;
+}
+/** Observable side-effects from the current run attempt that can suppress a retry to avoid double-work. */
+export interface RunRetrySideEffectState {
+    cancelRequested?: boolean;
+    userVisibleOutputSeen?: boolean;
+    toolCallSeen?: boolean;
+    artifactWriteSeen?: boolean;
+    liveArtifactSeen?: boolean;
+}
+/** Full input to `decideSafeRunRetry`, combining run outcome, failure signal, attempt count, and side-effect guards. */
+export interface RunRetryPolicyInput {
+    result: RunFailureResult;
+    failure?: RunRetryFailureSignal;
+    attemptCount: number;
+    maxAttempts?: number;
+    sideEffects?: RunRetrySideEffectState;
+    random?: () => number;
+}
+/** Discriminated union output of `decideSafeRunRetry`; either a retry schedule or a suppression reason. */
+export type RunRetryPolicyDecision = {
+    shouldRetry: true;
+    retryAttemptIndex: number;
+    retryMaxAttempts: number;
+    retryStrategy: RunRetryStrategy;
+    retryReason: 'transient_failure';
+    retryDelayMs: number;
+} | {
+    shouldRetry: false;
+    retryAttemptIndex: number;
+    retryMaxAttempts: number;
+    retryStrategy: RunRetryStrategy;
+    retrySuppressedReason: RunRetrySuppressedReason;
+};
+/**
+ * Classifies a terminated child process's raw `code`/`signal` into the `process_exit` category
+ * this module's own policy understands — the only signal cheaply available to
+ * `@jini-ai/daemon`'s `ClassifyFailure` port (see `agent-executor.ts`'s `FailureClassificationContext`
+ * doc for why richer signal, like a detected 429 or protocol error, isn't available there without
+ * new stderr/stdout buffering machinery this pass deliberately does not add).
+ * @param code - The child process's exit code, or `null` if it was terminated by a signal.
+ * @param signal - The OS signal that terminated the child, or `null` if it exited normally.
+ * @returns A `RunRetryFailureSignal` suitable for {@link decideSafeRunRetry}.
+ * @complexity O(1).
+ */
+export declare function classifyProcessExitFailure(code: number | null, 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
+ * metadata a host reads for its own later follow-up run, see `RunEndPayload.sessionRef`'s own doc),
+ * it does not schedule an automatic in-process retry the way {@link decideSafeRunRetry}'s full
+ * `attemptCount`/`sideEffects` machinery is built for. This composes the two: classifies the raw
+ * exit info via {@link classifyProcessExitFailure}, then asks {@link decideSafeRunRetry} whether a
+ * *first* attempt (`attemptCount: 0`) would be safe to retry, and returns that verdict.
+ *
+ * `attemptCount: 0` is always correct here, not a stand-in: no automatic same-run retry *loop*
+ * exists anywhere in this codebase (gap 4's `resumable` flag is read-only metadata for a host's own
+ * later follow-up run, never consumed to actually spawn attempt #2 — see this function's own doc
+ * above) — so every real call to this function genuinely is evaluating the first and only attempt
+ * made so far. A future auto-retry loop would need to supply its own real count, not reuse this.
+ *
+ * `sideEffects` (2026-07-22, optional — `agent-executor.ts`'s three `wire*Lifecycle` drivers supply
+ * `userVisibleOutputSeen`/`toolCallSeen`, derived live from the translated agent-event stream each
+ * already processes; see `FailureClassificationContext`'s own doc for why those two specifically,
+ * and why `cancelRequested`/`artifactWriteSeen`/`liveArtifactSeen` aren't threaded through this
+ * call at all) makes two of `decideSafeRunRetry`'s four side-effect-suppression guards genuinely
+ * exercised. Omitting it (`undefined`) preserves this function's original no-observed-side-effects
+ * behavior for any other caller.
+ * @complexity O(1).
+ */
+export declare function resumableFromProcessExit(code: number | null, signal: string | null, 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;
+//# sourceMappingURL=retry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/run/core/retry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,uGAAuG;AAKvG,8GAA8G;AAC9G,eAAO,MAAM,mCAAmC,IAAI,CAAC;AACrD,8FAA8F;AAC9F,eAAO,MAAM,uBAAuB,EAAE,gBAAuC,CAAC;AAS9E,2JAA2J;AAC3J,eAAO,MAAM,8BAA8B,OAAQ,CAAC;AACpD,+EAA+E;AAC/E,eAAO,MAAM,6BAA6B,MAAM,CAAC;AACjD,wFAAwF;AACxF,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,mGAAmG;AACnG,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAYhD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,kBAAkB,GAAG,SAAS,EACxC,MAAM,GAAE,MAAM,MAAoB,GACjC,MAAM,CAQR;AAED,0FAA0F;AAC1F,MAAM,WAAW,qBAAqB;IACpC,gBAAgB,CAAC,EAAE,kBAAkB,CAAC;IACtC,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAClC,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,2GAA2G;AAC3G,MAAM,WAAW,uBAAuB;IACtC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,wHAAwH;AACxH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,uBAAuB,CAAC;IAEtC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAED,2GAA2G;AAC3G,MAAM,MAAM,sBAAsB,GAC9B;IACE,WAAW,EAAE,IAAI,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,gBAAgB,CAAC;IAChC,WAAW,EAAE,mBAAmB,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB,GACD;IACE,WAAW,EAAE,KAAK,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,gBAAgB,CAAC;IAChC,qBAAqB,EAAE,wBAAwB,CAAC;CACjD,CAAC;AAEN;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,qBAAqB,CAQ5G;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,WAAW,CAAC,EAAE,IAAI,CAAC,uBAAuB,EAAE,uBAAuB,GAAG,cAAc,CAAC,GACpF,OAAO,CAQT;AA2DD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,mBAAmB,GACzB,sBAAsB,CAiDxB"}

package/dist/run/core/retry.js

@@ -0,0 +1,210 @@
+/** @module run/core/retry — Retry backoff constants and policy decision logic for safe run retries. */
+// Counts automatic same-run retry attempts, not the initial run. The default
+// scopes automatic recovery to at most one same-run retry, so `attemptCount >=
+// 1` suppresses with `attempt_limit_reached`.
+/** Maximum number of automatic same-run retry attempts allowed per run (not counting the initial attempt). */
+export const DEFAULT_SAFE_RUN_RETRY_MAX_ATTEMPTS = 1;
+/** Retry strategy label emitted in analytics for all automatic same-run transient retries. */
+export const SAFE_RUN_RETRY_STRATEGY = 'same_run_transient';
+// Backoff before a same-run retry restart. An immediate retry of a transient
+// failure — especially a 429 — tends to re-hit the same limit, so the policy
+// waits before restarting. `rate_limit` gets a larger base than other
+// transient classes because the upstream is explicitly asking us to slow down.
+// The delay grows exponentially by attempt index and is capped, then equal
+// jitter (half fixed + half random) is applied to avoid synchronized retries
+// across concurrent runs.
+/** Base backoff delay in milliseconds for rate-limit retries; larger than the transient base because the upstream is explicitly asking us to slow down. */
+export const RATE_LIMIT_RETRY_BASE_DELAY_MS = 1_000;
+/** Base backoff delay in milliseconds for non-rate-limit transient retries. */
+export const TRANSIENT_RETRY_BASE_DELAY_MS = 500;
+/** Exponential multiplier applied per retry attempt index to grow the backoff delay. */
+export const RETRY_BACKOFF_MULTIPLIER = 2;
+/** Maximum backoff delay in milliseconds after exponential growth and before jitter is applied. */
+export const MAX_RETRY_BACKOFF_DELAY_MS = 8_000;
+function backoffBaseDelayMs(category) {
+    return category === 'rate_limit'
+        ? RATE_LIMIT_RETRY_BASE_DELAY_MS
+        : TRANSIENT_RETRY_BASE_DELAY_MS;
+}
+// Pure, deterministic when `random` is supplied. `attemptIndex` is 1-based (the
+// index of the attempt about to be scheduled), so the first retry uses the base
+// delay and each subsequent attempt doubles it up to the cap. Equal jitter
+// returns a value in [delay/2, delay].
+/**
+ * Computes an exponentially backed-off delay with equal jitter for a retry attempt.
+ * @param attemptIndex - 1-based index of the attempt about to be scheduled.
+ * @param category - Failure category used to select the base delay; rate-limit failures use a larger base.
+ * @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) {
+    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);
+    const half = capped / 2;
+    const sample = random();
+    const jitter = Number.isFinite(sample) ? Math.min(1, Math.max(0, sample)) : 0;
+    return Math.round(half + jitter * half);
+}
+/**
+ * Classifies a terminated child process's raw `code`/`signal` into the `process_exit` category
+ * this module's own policy understands — the only signal cheaply available to
+ * `@jini-ai/daemon`'s `ClassifyFailure` port (see `agent-executor.ts`'s `FailureClassificationContext`
+ * doc for why richer signal, like a detected 429 or protocol error, isn't available there without
+ * new stderr/stdout buffering machinery this pass deliberately does not add).
+ * @param code - The child process's exit code, or `null` if it was terminated by a signal.
+ * @param signal - The OS signal that terminated the child, or `null` if it exited normally.
+ * @returns A `RunRetryFailureSignal` suitable for {@link decideSafeRunRetry}.
+ * @complexity O(1).
+ */
+export function classifyProcessExitFailure(code, signal) {
+    if (signal !== null) {
+        return { failure_category: 'process_exit', failure_detail: 'signal_killed', retryable: true };
+    }
+    if (code !== null && code !== 0) {
+        return { failure_category: 'process_exit', failure_detail: 'exit_nonzero', retryable: false };
+    }
+    return { failure_category: 'process_exit', failure_detail: 'terminated_unknown', retryable: false };
+}
+/**
+ * `@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
+ * metadata a host reads for its own later follow-up run, see `RunEndPayload.sessionRef`'s own doc),
+ * it does not schedule an automatic in-process retry the way {@link decideSafeRunRetry}'s full
+ * `attemptCount`/`sideEffects` machinery is built for. This composes the two: classifies the raw
+ * exit info via {@link classifyProcessExitFailure}, then asks {@link decideSafeRunRetry} whether a
+ * *first* attempt (`attemptCount: 0`) would be safe to retry, and returns that verdict.
+ *
+ * `attemptCount: 0` is always correct here, not a stand-in: no automatic same-run retry *loop*
+ * exists anywhere in this codebase (gap 4's `resumable` flag is read-only metadata for a host's own
+ * later follow-up run, never consumed to actually spawn attempt #2 — see this function's own doc
+ * above) — so every real call to this function genuinely is evaluating the first and only attempt
+ * made so far. A future auto-retry loop would need to supply its own real count, not reuse this.
+ *
+ * `sideEffects` (2026-07-22, optional — `agent-executor.ts`'s three `wire*Lifecycle` drivers supply
+ * `userVisibleOutputSeen`/`toolCallSeen`, derived live from the translated agent-event stream each
+ * already processes; see `FailureClassificationContext`'s own doc for why those two specifically,
+ * and why `cancelRequested`/`artifactWriteSeen`/`liveArtifactSeen` aren't threaded through this
+ * call at all) makes two of `decideSafeRunRetry`'s four side-effect-suppression guards genuinely
+ * exercised. Omitting it (`undefined`) preserves this function's original no-observed-side-effects
+ * 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 } : {}),
+    });
+    return decision.shouldRetry;
+}
+function normalizeAttemptCount(attemptCount) {
+    if (!Number.isFinite(attemptCount) || attemptCount < 0)
+        return 0;
+    return Math.floor(attemptCount);
+}
+function normalizeMaxAttempts(maxAttempts) {
+    if (maxAttempts === undefined)
+        return DEFAULT_SAFE_RUN_RETRY_MAX_ATTEMPTS;
+    if (!Number.isFinite(maxAttempts) || maxAttempts < 0)
+        return 0;
+    return Math.floor(maxAttempts);
+}
+function transientSuppressedReason(category, detail, stage) {
+    if (category === undefined)
+        return 'missing_failure_signal';
+    if (category === 'rate_limit') {
+        return detail === 'rate_limit_429' ? null : 'non_retryable_category';
+    }
+    if (category === 'upstream_unavailable') {
+        return detail === 'stream_disconnected' ||
+            detail === 'upstream_5xx' ||
+            detail === 'provider_high_demand' ||
+            detail === 'provider_routing_error' ||
+            detail === 'network_error'
+            ? null
+            : 'non_retryable_category';
+    }
+    if (category === 'empty_output') {
+        return stage === undefined || stage === 'first_token_wait'
+            ? null
+            : 'unsafe_failure_stage';
+    }
+    if (category === 'timeout') {
+        return stage === 'first_token_wait'
+            ? null
+            : 'unsafe_failure_stage';
+    }
+    if (category === 'process_exit') {
+        // `signal_killed` added 2026-07-22 (gap 4's real default classifier — see `classifyProcessExitFailure`
+        // below): a process terminated by an OS signal (SIGKILL/SIGTERM/etc) was never the agent's own
+        // choice to fail — an OOM-kill or an infra-level eviction is the common real-world cause, and
+        // both are presumptively transient. A plain non-zero exit code, by contrast, is the agent's own
+        // process deciding to fail (a config problem, a deterministic bug) and is not retried here.
+        return detail === 'agent_protocol_error' ||
+            detail === 'qoder_stop_sequence' ||
+            detail === 'session_resume_expired' ||
+            detail === 'stream_error' ||
+            detail === 'fatal_rpc_error' ||
+            detail === 'signal_killed'
+            ? null
+            : 'non_retryable_category';
+    }
+    return 'non_retryable_category';
+}
+/**
+ * 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 function decideSafeRunRetry(input) {
+    const attemptCount = normalizeAttemptCount(input.attemptCount);
+    const retryMaxAttempts = normalizeMaxAttempts(input.maxAttempts);
+    const retryAttemptIndex = attemptCount + 1;
+    const base = {
+        retryAttemptIndex,
+        retryMaxAttempts,
+        retryStrategy: SAFE_RUN_RETRY_STRATEGY,
+    };
+    const suppress = (retrySuppressedReason) => ({
+        ...base,
+        shouldRetry: false,
+        retrySuppressedReason,
+    });
+    if (input.result !== 'failed')
+        return suppress('not_failed');
+    const sideEffects = input.sideEffects ?? {};
+    if (sideEffects.cancelRequested)
+        return suppress('cancel_requested');
+    const failure = input.failure;
+    if (!failure)
+        return suppress('missing_failure_signal');
+    if (failure.failure_detail === 'hard_quota')
+        return suppress('hard_quota');
+    const transientReason = transientSuppressedReason(failure.failure_category, failure.failure_detail, failure.failure_stage);
+    if (transientReason === 'non_retryable_category')
+        return suppress(transientReason);
+    if (!failure.retryable)
+        return suppress('not_retryable');
+    if (transientReason)
+        return suppress(transientReason);
+    if (attemptCount >= retryMaxAttempts)
+        return suppress('attempt_limit_reached');
+    if (sideEffects.userVisibleOutputSeen)
+        return suppress('user_visible_output_seen');
+    if (sideEffects.toolCallSeen)
+        return suppress('tool_call_seen');
+    if (sideEffects.artifactWriteSeen)
+        return suppress('artifact_write_seen');
+    if (sideEffects.liveArtifactSeen)
+        return suppress('live_artifact_seen');
+    return {
+        ...base,
+        shouldRetry: true,
+        retryReason: 'transient_failure',
+        retryDelayMs: computeRetryBackoffMs(retryAttemptIndex, failure.failure_category, input.random),
+    };
+}
+//# sourceMappingURL=retry.js.map