agent-afk 5.296.4 → 5.296.6

package/dist/agent/dag.d.ts

@@ -23,6 +23,10 @@ export interface DAGRunResult {
         error: Error;
     }>;
     skipped: string[];
+    partial: Array<{
+        id: string;
+        stopReason: string;
+    }>;
 }
 export declare function validateDAG(graph: DAGGraph): void;
 export declare function runDAG(graph: DAGGraph, signal: AbortSignal, options?: DAGRunOptions): Promise<DAGRunResult>;

package/dist/agent/facets/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const FACET_VERSION = 7;
+export declare const FACET_VERSION = 8;
 export declare const ToolEventInputSchema: z.ZodObject<{
     toolName: z.ZodString;
     toolUseId: z.ZodOptional<z.ZodString>;
@@ -7,6 +7,7 @@ export declare const ToolEventInputSchema: z.ZodObject<{
     inputRaw: z.ZodOptional<z.ZodString>;
     result: z.ZodOptional<z.ZodString>;
     isError: z.ZodOptional<z.ZodBoolean>;
+    incomplete: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export declare const TurnInputSchema: z.ZodObject<{
     user: z.ZodDefault<z.ZodString>;
@@ -19,6 +20,7 @@ export declare const TurnInputSchema: z.ZodObject<{
         inputRaw: z.ZodOptional<z.ZodString>;
         result: z.ZodOptional<z.ZodString>;
         isError: z.ZodOptional<z.ZodBoolean>;
+        incomplete: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
 export declare const StoredSessionInputSchema: z.ZodObject<{
@@ -57,6 +59,7 @@ export declare const StoredSessionInputSchema: z.ZodObject<{
             inputRaw: z.ZodOptional<z.ZodString>;
             result: z.ZodOptional<z.ZodString>;
             isError: z.ZodOptional<z.ZodBoolean>;
+            incomplete: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$loose>>>;
     }, z.core.$loose>>>;
     forkedFrom: z.ZodOptional<z.ZodString>;
@@ -168,6 +171,7 @@ export declare const SessionFacetSchema: z.ZodObject<{
     tool_error_categories: z.ZodRecord<z.ZodString, z.ZodNumber>;
     friction_counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
     friction_detail: z.ZodString;
+    compose_partial_nodes: z.ZodOptional<z.ZodNumber>;
     outcome: z.ZodEnum<{
         unknown: "unknown";
         aborted: "aborted";

package/dist/agent/journal/types.d.ts

@@ -56,6 +56,7 @@ export type JournalBlock = {
     type: 'tool_result';
     toolUseId: string;
     isError?: boolean;
+    incomplete?: boolean;
     content: JournalResultPart[];
 } | {
     type: 'image';

package/dist/agent/tools/compose-executor.partial.d.ts

@@ -0,0 +1,5 @@
+import type { DAGRunResult } from '../dag.js';
+export declare function partialNodeFlag(partial: DAGRunResult['partial'] | undefined): {
+    incomplete: true;
+    incompleteReason: string;
+} | Record<string, never>;

package/dist/agent/tools/detach-registry.d.ts

@@ -6,6 +6,8 @@ export interface DetachedToolResult {
     readonly output: string;
     readonly exitCode?: number;
     readonly durationMs: number;
+    readonly incomplete?: boolean;
+    readonly incompleteReason?: string;
 }
 export interface DetachToken {
     readonly toolUseId: string;

package/dist/agent/tools/hooks/path-approval-hook.d.ts

@@ -1,9 +1,21 @@
-import type { HookHandler } from '../../hooks.js';
+import type { GrantManager } from '../grant-manager.js';
+import type { HookDecision, HookHandler } from '../../hooks.js';
+export { extractCandidatePath, extractAllPaths } from './path-approval-hook.prompt.js';
 export type PathApprovalSurface = 'repl' | 'telegram' | 'web' | 'unknown';
 export interface PathApprovalHookOptions {
     getCwd: () => string | undefined;
     surface: PathApprovalSurface;
 }
+export interface PathApprovalState {
+    sessionApproved: Set<string>;
+    onceApproved: Map<string, {
+        resolvedPath: string;
+        mode: 'read' | 'write';
+        capturedCwd: string | undefined;
+    }>;
+    inFlight: Map<string, Promise<HookDecision>>;
+    lastSeenGrantManager: GrantManager | undefined;
+}
 export interface PathApprovalHookHandlers {
     preToolUse: HookHandler;
     postToolUse: HookHandler;

package/dist/agent/tools/hooks/path-approval-hook.prompt.d.ts

@@ -0,0 +1,18 @@
+import type { GrantManager } from '../grant-manager.js';
+import type { HookDecision } from '../../hooks.js';
+import type { PathApprovalState, PathApprovalSurface } from './path-approval-hook.js';
+export declare function extractCandidatePath(toolName: string, input: Record<string, unknown>): string | undefined;
+export declare function extractAllPaths(toolName: string, input: Record<string, unknown>): string[];
+export declare function pathApprovalKey(mode: 'read' | 'write', resolvedPath: string): string;
+export declare function promptForApproval(args: {
+    toolName: string;
+    resolvedPath: string;
+    allPaths?: string[];
+    capturedCwd: string | undefined;
+    mode: 'read' | 'write';
+    grantManager: GrantManager;
+    state: PathApprovalState;
+    surface: PathApprovalSurface;
+    signal?: AbortSignal;
+    sessionId?: string;
+}): Promise<HookDecision>;

package/dist/agent/tools/readonly-bash.d.ts

@@ -1,3 +1,4 @@
+export { tokenizedSegmentReason } from './readonly-bash.tokenizer.js';
 export declare function classifyBashCommand(command: string): {
     mutating: boolean;
     reason?: string;

package/dist/agent/tools/readonly-bash.tokenizer.d.ts

@@ -0,0 +1,10 @@
+export interface CmdSegment {
+    readonly command: string;
+    readonly argv: readonly string[];
+}
+export declare function baseName(cmd: string): string;
+export declare function tokenizeSegments(command: string): string[][];
+export declare function resolveSegment(rawTokens: readonly string[], vars: Map<string, string>): CmdSegment | null;
+export declare function gitSegmentReason(argv: readonly string[]): string | null;
+export declare function curlSegmentMutating(seg: CmdSegment): boolean;
+export declare function tokenizedSegmentReason(command: string): string | null;

package/dist/agent/trace/receipt.d.ts

@@ -1,3 +1,4 @@
+export { renderReceiptMarkdown } from './receipt.render.js';
 import type { HookHandler } from '../hooks.js';
 import { type ClosureReason, type ToolFailureClass, type TraceEvent, type TraceEventKind } from './types.js';
 export declare const RECEIPT_SCHEMA_VERSION: 1;
@@ -78,7 +79,6 @@ export declare function receiptPathsFor(tracePath: string): {
     mdPath: string;
 };
 export declare function generateReceipt(events: TraceEvent[], meta: ReceiptMeta): RunReceipt;
-export declare function renderReceiptMarkdown(r: RunReceipt): string;
 export interface WriteRunReceiptOptions {
     tracePath: string;
     sessionId?: string;

package/dist/agent/trace/receipt.render.d.ts

@@ -0,0 +1,2 @@
+import type { RunReceipt } from './receipt.js';
+export declare function renderReceiptMarkdown(r: RunReceipt): string;

package/dist/agent/types/message-types.d.ts

@@ -51,6 +51,8 @@ export interface ToolResultChunk {
     toolUseId: string;
     content: string;
     isError?: boolean;
+    incomplete?: boolean;
+    incompleteReason?: string;
     truncated?: boolean;
     persistedPath?: string;
     capturePath?: string;

package/dist/agent/worktree/worktree-sweep.classify.d.ts

@@ -0,0 +1,43 @@
+export declare const MIN_EMPTY_AGE_MS = 3600000;
+export type DirtyReason = 'clean' | 'uncommitted changes' | 'git status failed' | `non-rebuildable ignored files: ${string}` | 'ignored-file probe failed';
+export interface WorktreeMeta {
+    owner: 'interactive' | 'diagnose' | string;
+    pid?: number;
+    createdAt: string;
+    baseSha?: string;
+    baseBranch?: string;
+    preservedReason?: 'dirty' | 'commits-ahead' | 'ignored-local-state';
+    preservedAt?: string;
+    commitsAheadAtPreserve?: number;
+}
+export interface WorktreeCandidate {
+    path: string;
+    head?: string;
+    branch?: string;
+    locked: boolean;
+    prunable: boolean;
+    meta?: WorktreeMeta;
+    ageMs: number;
+    isDirty: boolean;
+    dirtyReason: DirtyReason;
+    commitsAhead: number;
+    commitsUnpushed: number;
+    ownerLiveness: 'alive' | 'dead' | 'unknown';
+}
+export type WorktreeVerdict = 'empty' | 'stale-clean' | 'stale-dirty' | 'locked' | 'active' | 'orphaned-dir' | 'orphaned-dir-preserved' | 'orphaned-registration' | 'dead-owner';
+export declare const MAX_TRUSTED_PID_AGE_MS: number;
+export { isProcessAlive } from '../process-liveness.js';
+export declare function realpathSafe(p: string): string;
+export declare function isPathWithin(child: string, parent: string): boolean;
+export declare function shortBranchName(branch: string): string;
+export interface ParsedWorktree {
+    path: string;
+    head: string;
+    branch: string;
+    locked: boolean;
+    lockReason?: string;
+    prunable: boolean;
+    isBare: boolean;
+}
+export declare function parseWorktreeList(stdout: string): ParsedWorktree[];
+export declare function classifyCandidate(candidate: WorktreeCandidate, maxAgeDaysClean: number, maxAgeDaysDirty: number): WorktreeVerdict;

package/dist/agent/worktree/worktree-sweep.d.ts

@@ -1,4 +1,6 @@
 import { type PresenceRecord } from '../awareness/presence.js';
+import { type WorktreeVerdict } from './worktree-sweep.classify.js';
+export { MIN_EMPTY_AGE_MS } from './worktree-sweep.classify.js';
 export type ExecFileFn = (file: string, args: string[], opts?: {
     cwd?: string;
     maxBuffer?: number;
@@ -7,7 +9,6 @@ export type ExecFileFn = (file: string, args: string[], opts?: {
     stdout: string;
     stderr: string;
 }>;
-type WorktreeVerdict = 'empty' | 'stale-clean' | 'stale-dirty' | 'locked' | 'active' | 'orphaned-dir' | 'orphaned-dir-preserved' | 'orphaned-registration' | 'dead-owner';
 export interface SweepOptions {
     execFile: ExecFileFn;
     repoRoot: string;
@@ -33,6 +34,4 @@ export interface SweepResult {
     candidates: SweepCandidateSummary[];
     contested?: boolean;
 }
-export declare const MIN_EMPTY_AGE_MS = 3600000;
 export declare function runSweep(options: SweepOptions): Promise<SweepResult>;
-export {};

package/dist/agent/worktree/worktree-sweep.lock.d.ts

@@ -0,0 +1,5 @@
+export declare function countPriorSuccessfulRuns(telemetryPath: string): Promise<number>;
+export declare class LockContestedError extends Error {
+    constructor(lockPath: string);
+}
+export declare function acquireLock(lockPath: string): Promise<() => Promise<void>>;

package/dist/cli/_lib/testing/virtual-screen.csi.d.ts

@@ -0,0 +1,25 @@
+export interface CsiHost {
+    readonly cols: number;
+    readonly rows: number;
+    readonly grid: string[][];
+    cursorRow: number;
+    cursorCol: number;
+    pendingWrap: boolean;
+    scrollTop: number;
+    scrollBottom: number;
+    cursorHidden: boolean;
+    readonly oscSequences: string[];
+    scrollback: string[];
+    clampRow(r: number): number;
+    clampCol(c: number): number;
+    lineAt(row: number): string;
+    scrollRegionUp(): void;
+}
+export declare function normalizeCsiParams(raw: number[]): number[];
+export declare function eraseCursorToEndOfLine(host: CsiHost): void;
+export declare function eraseStartOfLineToCursor(host: CsiHost): void;
+export declare function eraseEntireLine(host: CsiHost): void;
+export declare function eraseCursorToEndOfScreen(host: CsiHost): void;
+export declare function eraseStartOfScreenToCursor(host: CsiHost): void;
+export declare function eraseEntireScreen(host: CsiHost): void;
+export declare function dispatchCsi(host: CsiHost, final: number, rawParams: number[], privatePrefix: boolean): void;

package/dist/cli/_lib/testing/virtual-screen.d.ts

@@ -26,18 +26,11 @@ export declare class VirtualScreen {
     private processEscByte;
     private processCsiByte;
     private dispatchCsi;
-    private normalizeCsiParams;
     private processOscByte;
     private processUtf8Byte;
     private putChar;
     private lineFeed;
     private scrollRegionUp;
-    private eraseCursorToEndOfLine;
-    private eraseStartOfLineToCursor;
-    private eraseEntireLine;
-    private eraseCursorToEndOfScreen;
-    private eraseStartOfScreenToCursor;
-    private eraseEntireScreen;
     visibleLines(): string[];
     lineAt(row: number): string;
     scrollbackLines(): string[];

package/dist/cli/commands/interactive/tool-lane.d.ts

@@ -39,7 +39,6 @@ export declare class ToolLane {
     findLastSkillEntryId(): string | undefined;
     peekTrailingCompletedRootToolName(): string | undefined;
     getOverlay(): string;
-    private ancestorDepthOf;
     flushSource(parentId: string, homeDir?: string): string[];
     flushCompletedRoots(homeDir?: string): string[];
     flush(homeDir?: string): string[];

package/dist/cli/commands/interactive/tool-lane.flush.d.ts

@@ -0,0 +1,8 @@
+import { type Entry } from './tool-lane-render.js';
+export interface ToolLaneFlushHost {
+    readonly entries: Map<string, Entry>;
+    order: string[];
+    readonly compactScrollback: boolean;
+}
+export declare function flushSource(host: ToolLaneFlushHost, parentId: string, homeDir?: string): string[];
+export declare function flushCompletedRoots(host: ToolLaneFlushHost, homeDir?: string): string[];

package/dist/cli/elicitation/agent-question.d.ts

@@ -1,4 +1,5 @@
 import type { ElicitationRequest, ElicitationResult } from '../../agent/types/sdk-types.js';
 import type { ReplElicitationDeps } from './repl-shared.js';
-export declare const SKIP: ElicitationResult;
+import { SKIP } from './agent-question.fallback.js';
+export { SKIP };
 export declare function renderAgentQuestion(request: ElicitationRequest, deps: ReplElicitationDeps, signal: AbortSignal): Promise<ElicitationResult>;

package/dist/cli/elicitation/agent-question.fallback.d.ts

@@ -0,0 +1,11 @@
+import type { ElicitationRequest, ElicitationResult } from '../../agent/types/sdk-types.js';
+import type { ReplElicitationDeps } from './repl-shared.js';
+export declare const SKIP: ElicitationResult;
+type Writer = ReplElicitationDeps['writer'];
+type ReadLine = ReplElicitationDeps['readLine'];
+export declare function renderConfirmFallback(request: ElicitationRequest, readLine: ReadLine, writer: Writer, signal: AbortSignal): Promise<ElicitationResult>;
+export declare function renderChoiceFallback(request: ElicitationRequest, readLine: ReadLine, writer: Writer, signal: AbortSignal): Promise<ElicitationResult>;
+export declare function renderMultiChoiceFallback(request: ElicitationRequest, readLine: ReadLine, writer: Writer, signal: AbortSignal): Promise<ElicitationResult>;
+export declare function renderNumberFallback(request: ElicitationRequest, readLine: ReadLine, writer: Writer, signal: AbortSignal): Promise<ElicitationResult>;
+export declare function renderTextFallback(request: ElicitationRequest, readLine: ReadLine, writer: Writer, signal: AbortSignal): Promise<ElicitationResult>;
+export {};

package/dist/cli/slash/types.d.ts

@@ -22,6 +22,7 @@ export interface ToolEvent {
     inputRaw?: string;
     result?: string;
     isError?: boolean;
+    incomplete?: boolean;
     resultTail?: string;
 }
 export interface TurnRecord {

package/dist/cli/terminal-compositor.input-dispatch.cursor.d.ts

@@ -0,0 +1,3 @@
+import type { KeyInfo } from './terminal-compositor.types.js';
+import type { KeyDispatchHost } from './terminal-compositor.input-dispatch.js';
+export declare function handleCursorAndEdit(self: KeyDispatchHost, key: KeyInfo): boolean;

package/dist/cli/terminal-compositor.input-dispatch.enter.d.ts

@@ -0,0 +1,8 @@
+import { InputCore } from './input-core.js';
+import type { KeyInfo, SubmissionPayload } from './terminal-compositor.types.js';
+import type { KeyDispatchHost } from './terminal-compositor.input-dispatch.js';
+export declare function mergeSubmissionPayloads(payloads: readonly SubmissionPayload[]): SubmissionPayload;
+export declare function commitIfChanged(self: KeyDispatchHost, next: ReturnType<typeof InputCore.seed>): true;
+export declare function applyAtomicPlaceholderDelete(self: KeyDispatchHost, direction: 'backward' | 'forward'): boolean;
+export declare function handleBackspace(self: KeyDispatchHost, key: KeyInfo): boolean;
+export declare function handleEnter(self: KeyDispatchHost, key: KeyInfo, sequence: string): boolean;