@kynver-app/runtime 0.1.119 → 0.1.122

package/dist/chat/anthropic-credentials.d.ts

@@ -6,4 +6,6 @@ export type LocalAnthropicCredentials = {
     token: string;
 };
 export declare function parseClaudeCredentials(raw: string, now?: number): string | null;
-export declare function resolveLocalAnthropicCredentials(env?: Record<string, string | undefined>): LocalAnthropicCredentials | null;
+export declare function resolveLocalAnthropicCredentials(env?: Record<string, string | undefined>, opts?: {
+    oauthOptIn?: boolean;
+}): LocalAnthropicCredentials | null;

package/dist/chat/chat-claim-loop.d.ts

@@ -5,9 +5,11 @@ export interface ChatBridgeTarget {
     apiKey: string;
     boxId: string;
     model: string;
+    /** Claude Code OAuth opt-in (config `chatUseClaudeOauth` or env). */
+    useClaudeOauth: boolean;
 }
 /** Resolve the chat-bridge target; null when the feature is off/unconfigured. */
-export declare function resolveChatBridgeTarget(env?: Record<string, string | undefined>): ChatBridgeTarget | null;
+export declare function resolveChatBridgeTarget(env?: Record<string, string | undefined>): Promise<ChatBridgeTarget | null>;
 interface ClaimedTurn {
     turnId: string;
     agentOsId: string;

package/dist/cleanup-duplicate-worktrees.d.ts

@@ -1,7 +1,8 @@
 import type { CleanupCandidate } from "./cleanup-types.js";
 import type { ScanHarnessOptions } from "./cleanup-scan.js";
 /**
- * Secondary git worktrees under the harness layout that are clean but not indexed
- * (aborted duplicate attempts). Uses `git worktree remove` during execute.
+ * Secondary git worktrees under the harness layout that are not indexed
+ * (aborted duplicate attempts). Salvage guards (orphan safety) run at evaluation
+ * time — do not run per-worktree `git status` during the scan pass.
  */
 export declare function scanDuplicateWorktreeCandidates(opts: ScanHarnessOptions): CleanupCandidate[];

package/dist/cleanup-git-probe.d.ts

@@ -0,0 +1,5 @@
+import type { GitCaptureResult } from "./git.js";
+/** Bounded git work during broad cleanup scans — hung repos must not stall the sweep. */
+export declare const CLEANUP_GIT_PROBE_TIMEOUT_MS = 5000;
+export declare function cleanupGitCapture(cwd: string, args: string[]): GitCaptureResult;
+export declare function gitStatusShortForCleanup(worktreePath: string): string[] | null;

package/dist/cleanup-guards.d.ts

@@ -20,6 +20,10 @@ export interface WorktreeGuardInput {
     orphanSafety?: CleanupSkipReason | null;
     worktreeRemovalGuard?: WorktreeRemovalGuardHook;
     liveness?: CleanupRunLivenessContext;
+    now?: number;
+    harnessRoot?: string;
+    /** When true (execute mode), persist salvage evidence before allowing removal. */
+    writeSalvageEvidence?: boolean;
 }
 export type WorktreeGuardSkip = CleanupSkipReason | {
     reason: CleanupSkipReason;

package/dist/cleanup-retention-config.d.ts

@@ -3,6 +3,8 @@ import { type HarnessCleanupOptions } from "./cleanup-types.js";
 export interface ResolvedHarnessRetention {
     execute: boolean;
     finalizeStaleRuns: boolean;
+    /** When false, skip node_modules/.next/build-cache scans (worktree-only operator sweeps). */
+    scanDependencyCaches: boolean;
     nodeModulesAgeMs: number;
     worktreesAgeMs: number;
     terminalWorktreesAgeMs: number;

package/dist/cleanup-run-liveness.d.ts

@@ -7,11 +7,8 @@ export interface CleanupRunLivenessContext {
     gitStatusCache: CleanupGitStatusCache;
     gitRevCache: CleanupGitRevCache;
 }
-/**
- * True when the worker process is still live. Broad cleanup scans use worker.json
- * terminal hints before falling back to full `computeWorkerStatus` (expensive).
- */
-export declare function isWorkerProcessLive(indexed: IndexedWorktree): boolean;
+/** True when the worker process or heartbeat still shows live harness activity. */
+export declare function isWorkerProcessLive(indexed: IndexedWorktree, now?: number): boolean;
 /**
  * Run record still marked active but every worker is finished — safe to treat as
  * terminal for GC after `finalizeStaleRuns()` (or when deriveTerminalRunStatus is set).
@@ -21,4 +18,4 @@ export declare function isRunStaleActive(indexed: IndexedWorktree, ctx?: Cleanup
  * Whether the harness run still has unfinished work that should block whole-worktree removal.
  * Does not block per-worker `node_modules` when only this worker is finished.
  */
-export declare function runBlocksWorktreeRemoval(indexed: IndexedWorktree, ctx?: CleanupRunLivenessContext): boolean;
+export declare function runBlocksWorktreeRemoval(indexed: IndexedWorktree, ctx?: CleanupRunLivenessContext, now?: number): boolean;

package/dist/cleanup-salvage-evidence.d.ts

@@ -0,0 +1,33 @@
+import type { CleanupSkipReason } from "./cleanup-types.js";
+import type { IndexedWorktree } from "./cleanup-worktree-index.js";
+import type { RawHarnessWorkerStatus } from "./status.js";
+export interface WorktreeSalvageEvidenceRecord {
+    capturedAt: string;
+    skipReason: CleanupSkipReason;
+    runId: string;
+    workerName: string;
+    worktreePath: string;
+    taskId?: string;
+    agentOsId?: string;
+    branch?: string;
+    completionBlocker?: string;
+    finalResult?: unknown;
+    changedFiles: string[];
+    gitAncestry: RawHarnessWorkerStatus["gitAncestry"];
+    prUrl?: string | null;
+    patchPath?: string | null;
+}
+export declare function salvageEvidenceDir(harnessRoot: string, runId: string, workerName: string): string;
+export declare function hasSalvageEvidence(input: {
+    harnessRoot: string;
+    runId: string;
+    workerName: string;
+}): boolean;
+/** Persist worktree/git evidence before whole-worktree removal for operator salvage review. */
+export declare function writeWorktreeSalvageEvidence(input: {
+    harnessRoot: string;
+    indexed: IndexedWorktree;
+    skipReason: CleanupSkipReason;
+    status: RawHarnessWorkerStatus;
+    now?: number;
+}): WorktreeSalvageEvidenceRecord;

package/dist/cleanup-types.d.ts

@@ -106,6 +106,8 @@ export interface HarnessCleanupOptions {
     storagePerRunEntryCap?: number | null;
     /** Per-candidate filesystem walk cap when `du` is unavailable. */
     byteAccountingEntryCap?: number;
+    /** When false, skip node_modules/.next/build-cache scans (worktree-only operator sweeps). */
+    scanDependencyCaches?: boolean;
     /** Minimum age before removing generated `node_modules` (default 6h). */
     nodeModulesAgeMs?: number;
     /** When 0 or unset, worktree removal is disabled. */

package/dist/cleanup-worker-harness-live.d.ts

@@ -0,0 +1,9 @@
+import type { HarnessWorkerRecord } from "./status.js";
+/** True when parsed heartbeat JSON has a recent `ts` (not file mtime alone). */
+export declare function heartbeatContentIsFresh(worker: HarnessWorkerRecord, now?: number, windowMs?: number): boolean;
+/**
+ * Whether a harness worker still has live execution signals: OS process and/or
+ * fresh heartbeat content. Ignores stale `worker.json` status and file mtimes
+ * that daemons or scanners may touch without a running worker.
+ */
+export declare function isHarnessWorkerHarnessLive(worker: HarnessWorkerRecord, now?: number, windowMs?: number): boolean;

package/dist/cleanup-worktree-index.d.ts

@@ -11,6 +11,8 @@ export interface IndexedWorktree {
     status?: RawHarnessWorkerStatus;
 }
 export declare function buildWorktreeIndex(): Map<string, IndexedWorktree>;
+/** Scope a merged multi-root index to one harness tree (avoids triple-scanning every worker). */
+export declare function filterWorktreeIndexForRoot(index: Map<string, IndexedWorktree>, harnessRoot: string): Map<string, IndexedWorktree>;
 export declare function buildWorktreeIndexAt(harnessRoot: string): Map<string, IndexedWorktree>;
 /** Load worker when index miss but path is known from disk layout. */
 export declare function loadIndexedWorker(runId: string, workerName: string): HarnessWorkerRecord | null;