hankweave 0.7.2 → 0.7.4

package/dist/claude-agent-sdk-manager.d.ts

@@ -9,6 +9,16 @@ import type { Logger } from "./utils.js";
 export declare class ClaudeExecutableNotFoundError extends Error {
     constructor(message: string);
 }
+/**
+ * Default stream-inactivity timeout for SDK sessions, in seconds.
+ *
+ * Unlike the shim binaries (which apply their own internal 120s default), the
+ * SDK path historically had NO inactivity bound when shimIdleTimeout was
+ * unset — a hung streaming connection would sit silent until the OS killed
+ * the socket. SDK messages arrive at message granularity (not per token), so 180s of total silence
+ * reliably indicates a dead stream rather than a slow turn.
+ */
+export declare const DEFAULT_SDK_IDLE_TIMEOUT_SECONDS = 180;
 /**
  * Whether lenient ("legacy") Claude auth is enabled via HW_INTERNAL_CLAUDE_LEGACY_AUTH.
  *
@@ -107,6 +117,14 @@ export declare class ClaudeAgentSDKManager extends BaseProcessManager {
      * Write a message to the log file.
      */
     private writeToLog;
+    /**
+     * Write a synthetic error result message to the log and wait for the write
+     * to flush. Used when the session dies without the SDK emitting a result
+     * (e.g. idle timeout): the log parser picks it up so the runtime gets a
+     * classifiable failure reason. The flush matters — emitExit() synchronously
+     * re-parses the log file, so a buffered write would be invisible to it.
+     */
+    private writeSyntheticErrorResult;
     /**
      * Kill the Claude Agent SDK session gracefully.
      * Aborts the query (which triggers SIGTERM on the child via the SDK's abort handler),
@@ -136,6 +154,15 @@ export declare class ClaudeAgentSDKManager extends BaseProcessManager {
      * Get session ID.
      */
     getSessionId(): string | undefined;
+    /**
+     * Whether the SDK delivered at least one message (the session id is captured
+     * from the first message). This is a synchronous, race-free establishment
+     * signal: it is set inside the message loop and survives `cleanup()`, so it is
+     * still readable on the error path after a query-promise rejection — unlike the
+     * log-parser-fed flag in CodonRunner, which may not have parsed the init line
+     * yet when the SDK emits "error".
+     */
+    getSessionEstablished(): boolean;
     /**
      * Get synthetic PID (for compatibility with ClaudeProcessManager API).
      * Note: This is not a real process ID since SDK runs in-process.

package/dist/codon-runner.d.ts

@@ -123,21 +123,10 @@ export type CodonRunnerConfig = CodonRunnerConfigWithoutExtension | CodonRunnerC
  * ensuring they are created together, used together, and cleaned up together.
  */
 /**
- * Failure reasons that prevent extension
+ * Failure reasons that prevent extension.
+ * Shared with the runtime's failure-policy machinery (see event-schemas.ts).
  */
-type FailureReason = {
-    type: "timeout";
-    retriable: boolean;
-} | {
-    type: "rate-limit";
-    retriable: boolean;
-} | {
-    type: "api-error";
-    retriable: boolean;
-} | {
-    type: "unknown";
-    retriable: boolean;
-};
+type FailureReason = import("./types/types.js").FailureReason;
 /**
  * Determines whether a codon should extend based on exit conditions.
  * Pure function for unit testing.
@@ -160,6 +149,7 @@ export declare function shouldExtendCodon(params: {
     isInterrupted: boolean;
     failureReason: FailureReason | undefined;
     isBudgetExceeded?: boolean;
+    errorResultReceived?: boolean;
 }): boolean;
 export declare class CodonRunner extends TypedEventEmitter<CodonRunnerEvents> {
     private readonly config;
@@ -172,8 +162,10 @@ export declare class CodonRunner extends TypedEventEmitter<CodonRunnerEvents> {
     private successResultReceived;
     private extensionCount;
     private resultMessageReceived;
+    private errorResultReceived;
     private failureReason;
     private currentSessionId;
+    private systemMessageReceived;
     constructor(config: CodonRunnerConfig);
     /**
      * Check if a model can be run by CodonRunner.
@@ -182,6 +174,7 @@ export declare class CodonRunner extends TypedEventEmitter<CodonRunnerEvents> {
      * - Anthropic models via ClaudeAgentSDKManager
      * - Google models via ShimProcessManager (gemini shim)
      * - OpenAI models via ShimProcessManager (codex shim)
+     * - DeepSeek, Pi, and OpenCode models via ShimProcessManager
      *
      * @param model - The ModelInfo to check
      * @returns true if the model can be executed, false otherwise
@@ -263,6 +256,27 @@ export declare class CodonRunner extends TypedEventEmitter<CodonRunnerEvents> {
      * Get the process ID (if running)
      */
     getPid(): number | undefined;
+    /**
+     * The classified failure reason for the current attempt, if one was derived
+     * from an error result message or a transient mid-stream crash. The runtime
+     * adopts this on the exit path when it has no result-message-derived reason of
+     * its own, so `onFailure: retry` can act on SDK crashes that never produced a
+     * terminal result.
+     */
+    getFailureReason(): FailureReason | undefined;
+    /**
+     * Whether the agent session was established (first system/init message
+     * observed) before any failure. Used to gate the retriability of unrecognized
+     * crashes: a process that dies before establishing a session, with text we
+     * don't recognize as a transient API error, is a local setup failure, not a
+     * transient one.
+     *
+     * ORs the log-parser-fed flag with the SDK manager's synchronous signal: the
+     * SDK emits "error" after cleanup() without force-parsing the log, so the
+     * parser-fed flag can lag a genuine establishment — `getSessionEstablished()`
+     * (derived from the session id captured in the message loop) closes that race.
+     */
+    getSystemMessageReceived(): boolean;
     /**
      * Get the prompt frontmatter (if any was parsed from the prompt file)
      */

package/dist/config.d.ts

@@ -10,6 +10,7 @@ export declare const TIMEOUTS: {
     readonly LOG_PARSER_DELAY_MS: 100;
     readonly CODON_CLEANUP_DELAY_MS: 100;
     readonly SELF_TEST_TIMEOUT_MS: 30000 | 60000;
+    readonly SHUTDOWN_WATCHDOG_MS: 30000;
 };
 /** Maximum allowed shimIdleTimeout in seconds */
 export declare const SHIM_IDLE_TIMEOUT_MAX_SECONDS = 1800;
@@ -40633,6 +40634,13 @@ export interface HankweaveConfig extends Omit<Required<RuntimeConfig>, "model" |
     isResuming: boolean;
     /** How data is linked (symlink or copy) */
     linkType: "symlink" | "copy";
+    /**
+     * True when launched with --headless: no interactive TUI/client is driving
+     * the run. Used to decide that a retriable failure under onFailure:"abort"
+     * must fail-and-shutdown rather than park in "stay-active" (which would hang
+     * forever waiting for a client that will never connect).
+     */
+    headless?: boolean;
     /** Array of codon configurations to execute */
     codons: CodonConfig[];
     /** Path to a replay source directory (for replaying execution from JSONL logs without real LLM calls) */

package/dist/cost-tracker.d.ts

@@ -1,4 +1,5 @@
 import type { LlmProviderRegistry } from "./llm/llm-provider-registry.js";
+import type { ModelInfo } from "./llm/models-dev-schema.js";
 import { TypedEventEmitter } from "./typed-event-emitter.js";
 import type { TokenUsage } from "./types/types.js";
 import type { Logger } from "./utils.js";
@@ -48,12 +49,14 @@ export interface CostTrackerEvents extends Record<string, unknown[]> {
  * Owned by CodonRunner. The runtime subscribes to its events.
  */
 export declare class CostTracker extends TypedEventEmitter<CostTrackerEvents> {
-    private readonly modelId;
     private readonly llmRegistry;
     private readonly logger;
     private runningCost;
     private runningTokens;
-    constructor(modelId: string | undefined, llmRegistry: LlmProviderRegistry, logger: Logger);
+    private readonly executableModelId;
+    private readonly pricingModelId;
+    constructor(model: ModelInfo | undefined, llmRegistry: LlmProviderRegistry, logger: Logger);
+    private static getPricingModelId;
     /**
      * Process usage from an assistant message. Calculates incremental cost,
      * accumulates running totals, and emits costIncremented.

package/dist/error-classification.d.ts

@@ -0,0 +1,78 @@
+import type { FailureReason } from "./types/types.js";
+/**
+ * Pure decision core of the runtime's failure policy
+ * (HankweaveRuntime.resolveFailurePolicy delegates here; extracted for unit
+ * testing, mirroring shouldExtendCodon in codon-runner.ts).
+ *
+ * - abort: retriable errors leave the server active for manual retry,
+ *   permanent ones shut the run down.
+ * - retry: retriable errors retry until maxAttempts is exhausted; permanent
+ *   errors shut down immediately.
+ * - ignore: always continue to the next codon.
+ */
+export declare function resolveFailureAction(params: {
+    onFailure: "abort" | "retry" | "ignore";
+    retriable: boolean;
+    attempts: number;
+    maxAttempts: number;
+}): "shutdown" | "stay-active" | "retry" | "continue";
+/**
+ * Classify API error text into a FailureReason with a retriability verdict.
+ *
+ * This is the single source of truth for deciding whether an API-level error
+ * is transient (worth retrying under onFailure: "retry") or permanent.
+ * Both the runtime's result-message handling and CodonRunner's extension
+ * logic must use this — divergent heuristics in those two places previously
+ * caused transient socket drops to abort runs that were configured to retry
+ *
+ * Classification policy:
+ * - Billing/credit/quota and auth errors are permanent: retrying burns
+ *   attempts on a hopeless request.
+ * - Invalid-request (400) errors are permanent: the same request will fail
+ *   the same way.
+ * - Transport faults (socket closed/reset, connection errors), timeouts,
+ *   rate limits, and server-side errors (5xx, overloaded) are transient.
+ * - Unrecognized error text defaults to RETRIABLE: retries are bounded by
+ *   retryConfig.maxAttempts, so a wrong "retriable" costs one extra attempt,
+ *   while a wrong "non-retriable" kills the whole run. This default is gated on
+ *   `opts.sessionEstablished`: when the caller knows no session was ever
+ *   established (the process failed before its first message), unrecognized text
+ *   is a local setup failure and is classified NON-retriable instead. The known
+ *   transient/permanent patterns above are unaffected by the gate.
+ */
+export declare function classifyApiErrorText(text: string, opts?: {
+    sessionEstablished?: boolean;
+}): FailureReason;
+/**
+ * Synthesize a failure reason for a codon that ended in a FAILED state without
+ * any classified reason of its own (no error result message, no transient-crash
+ * classification from the runner).
+ *
+ * This is the single convergence point for every process manager when a process
+ * exits without reporting a usable outcome:
+ *  - An early/pre-init shim exit on an API error returns a non-zero code with no
+ *    result message (gemini shim.ts:593 `!systemEmitted`; pi index.ts:452;
+ *    opencode shim.ts:462/486 and binary/arg-resolution failures).
+ *  - The Claude Agent SDK or any child process can crash without a terminal
+ *    result.
+ *
+ * Retriability is gated on session establishment (`sessionEstablished`):
+ *  - established then exited with no result → plausibly transient, RETRIABLE
+ *    (bounded by retryConfig.maxAttempts), mirroring classifyApiErrorText's
+ *    policy for unrecognized errors.
+ *  - never established (the process exited before its first message) → a local
+ *    setup/binary/resume-resolution failure that retrying cannot fix →
+ *    NON-retriable. Defaults to true so callers that don't supply the signal
+ *    keep the original retriable behavior.
+ *
+ * Returns undefined (no synthesis — preserve the existing non-retriable default)
+ * when the failure is intentional or owned by another mechanism:
+ *  - force-stop: the user asked to stop; retrying would fight that intent.
+ *  - context-exceeded: the loop/termination logic owns this outcome, not retry.
+ */
+export declare function synthesizeMissingFailureReason(params: {
+    isForceStopping: boolean;
+    isContextExceeded: boolean;
+    exitCode: number;
+    sessionEstablished?: boolean;
+}): FailureReason | undefined;