@oh-my-pi/pi-coding-agent 16.2.1 → 16.2.3

package/dist/types/session/messages.d.ts

@@ -12,6 +12,32 @@ import type { OutputMeta } from "../tools/output-meta";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 export declare const BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE = "background-tan-dispatch";
+/** Custom message type for hidden interrupted-thinking continuity context. */
+export declare const INTERRUPTED_THINKING_MESSAGE_TYPE = "interrupted-thinking";
+/** Metadata persisted with a hidden interrupted-thinking continuity message. */
+export interface InterruptedThinkingDetails {
+    interruptedAt: number;
+    provider: AssistantMessage["provider"];
+    model: string;
+    blockCount: number;
+}
+/** Pure helper result for persisting interrupted thinking outside the assistant turn. */
+export interface DemotedInterruptedThinking {
+    reasoning: string;
+    strippedContent: AssistantMessage["content"];
+    blockCount: number;
+}
+/**
+ * Demote a trailing run of *incomplete* interrupted-thinking from an assistant
+ * message — reasoning that was still streaming when the user aborted.
+ *
+ * A block joins the run only when it is a non-empty `thinking` block with no
+ * `thinkingSignature`. A signed/complete thinking block (Anthropic signature,
+ * OpenAI reasoning item id) is safely replayable, so it ends the run and stays
+ * in place — as do `redactedThinking` encrypted blobs, text, tool calls,
+ * empty-thinking blocks, and trailing empty text placeholders.
+ */
+export declare function demoteInterruptedThinking(message: Pick<AssistantMessage, "content">): DemotedInterruptedThinking | undefined;
 /** Details persisted on a `/tan` background-dispatch breadcrumb. */
 export interface BackgroundTanDispatchDetails {
     jobId: string;
@@ -43,18 +69,17 @@ export interface SkillPromptDetails {
  *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
  *  (fallback error emission) read it via `isSilentAbort`. */
 export declare const SILENT_ABORT_MARKER = "__omp.silent_abort__";
-/** Type-guard for `SILENT_ABORT_MARKER`. Renderers MUST branch on this rather
- *  than string-comparing inline so refactors to the marker constant (e.g.,
- *  namespacing changes) propagate through every consumer in lockstep. */
-export declare function isSilentAbort(errorMessage: string | undefined): boolean;
+/** Type-guard for silent aborts. Renderers MUST call this helper so structured
+ *  `errorId` and legacy persisted marker messages stay in lockstep. */
+export declare function isSilentAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean;
 /** Reason threaded through `AbortController.abort(reason)` when the user aborts
  *  the turn with Esc (see `AgentSession.abort`). The agent keeps it on the
  *  aborted assistant message's `errorMessage` so queued follow-ups/tool-result
  *  placeholders can distinguish a deliberate interrupt from a bare lifecycle
  *  abort, but interactive renderers suppress this redundant transcript line. */
 export declare const USER_INTERRUPT_LABEL = "Interrupted by user";
-export declare function isUserInterruptAbort(errorMessage: string | undefined): boolean;
-export declare function shouldRenderAbortReason(errorMessage: string | undefined): boolean;
+export declare function isUserInterruptAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean;
+export declare function shouldRenderAbortReason(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean;
 /** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
  *  reason (bare `abort()`). Renderers treat it as "no specific reason given". */
 export declare const GENERIC_ABORT_SENTINEL = "Request was aborted";
@@ -63,7 +88,7 @@ export declare const GENERIC_ABORT_SENTINEL = "Request was aborted";
  *  no threaded reason fall back to the retry-aware generic label. Call
  *  `shouldRenderAbortReason` before rendering when user interrupts should stay
  *  visually quiet. */
-export declare function resolveAbortLabel(errorMessage: string | undefined, retryAttempt?: number): string;
+export declare function resolveAbortLabel(message: Pick<AssistantMessage, "errorId" | "errorMessage">, retryAttempt?: number): string;
 /** Extract the optional `__queueChipText` field from a CustomMessage's
  *  `details` blob. Safe over `unknown`; returns undefined when the field is
  *  absent or non-string. */

package/dist/types/session/messages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/session/session-entries.d.ts

@@ -1,13 +1,26 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, MessageAttribution, ServiceTier, TextContent } from "@oh-my-pi/pi-ai";
 export declare const CURRENT_SESSION_VERSION = 3;
+export declare const SESSION_TITLE_SLOT_BYTES = 256;
+export declare const SESSION_TITLE_SLOT_ENTRY_TYPE = "title";
+export declare const TITLE_CHANGE_ENTRY_TYPE = "title_change";
+export type SessionTitleSource = "auto" | "user";
+/** Fixed-width first-line slot carrying the mutable current session title. */
+export interface SessionTitleSlotEntry {
+    type: typeof SESSION_TITLE_SLOT_ENTRY_TYPE;
+    v: 1;
+    title: string;
+    source?: SessionTitleSource;
+    updatedAt: string;
+    pad: string;
+}
 export declare const EPHEMERAL_MODEL_CHANGE_ROLE = "fallback";
 export interface SessionHeader {
     type: "session";
     version?: number;
     id: string;
     title?: string;
-    titleSource?: "auto" | "user";
+    titleSource?: SessionTitleSource;
     timestamp: string;
     cwd: string;
     parentSession?: string;
@@ -91,6 +104,19 @@ export interface LabelEntry extends SessionEntryBase {
     targetId: string;
     label: string | undefined;
 }
+/** Append-only audit entry recording a session title change. */
+export interface TitleChangeEntry extends SessionEntryBase {
+    type: typeof TITLE_CHANGE_ENTRY_TYPE;
+    title: string;
+    previousTitle?: string;
+    source: SessionTitleSource;
+    trigger?: string;
+}
+declare module "@oh-my-pi/pi-agent-core/compaction/entries" {
+    interface CustomCompactionSessionEntries {
+        titleChange: TitleChangeEntry;
+    }
+}
 /** TTSR injection entry - tracks which time-traveling rules have been injected this session. */
 export interface TtsrInjectionEntry extends SessionEntryBase {
     type: "ttsr_injection";
@@ -149,9 +175,11 @@ export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
     attribution?: MessageAttribution;
 }
 /** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
-export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry;
-/** Raw file entry (includes header) */
+export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | ModelChangeEntry | ServiceTierChangeEntry | CompactionEntry | BranchSummaryEntry | CustomEntry | CustomMessageEntry | LabelEntry | TitleChangeEntry | TtsrInjectionEntry | MCPToolSelectionEntry | SessionInitEntry | ModeChangeEntry;
+/** Raw logical file entry after loaders strip any fixed-width title slot. */
 export type FileEntry = SessionHeader | SessionEntry;
+/** Physical JSONL entry before slot-aware loaders fold the title slot. */
+export type RawFileEntry = SessionTitleSlotEntry | FileEntry;
 /** Tree node for getTree() - defensive copy of session structure */
 export interface SessionTreeNode {
     entry: SessionEntry;

package/dist/types/session/session-history-format.d.ts

@@ -18,6 +18,12 @@ export interface HistoryFormatOptions {
      * still collapse to a one-liner.
      */
     expandPrimaryContext?: boolean;
+    /**
+     * Append the full unified diff (from a tool result's `details.diff`) below
+     * edit/apply_patch tool lines, instead of just the path. The advisor sets
+     * this so it sees what changed without re-reading the file.
+     */
+    expandEditDiffs?: boolean;
 }
 /**
  * Hidden custom messages that inject the primary agent's operative *constraints*

package/dist/types/session/session-loader.d.ts

@@ -1,7 +1,15 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { BlobStore } from "./blob-store";
-import type { FileEntry } from "./session-entries";
+import { type FileEntry, type SessionTitleSlotEntry } from "./session-entries";
 import { type SessionStorage } from "./session-storage";
+import { type SessionTitleUpdate } from "./session-title-slot";
+/** Parse session JSONL while stripping and folding the optional fixed title slot. */
+export declare function parseSessionContent(content: string): {
+    entries: FileEntry[];
+    titleSlot: SessionTitleUpdate | undefined;
+};
+/** Read only the fixed-size head window to detect a physical title slot. */
+export declare function readTitleSlotFromFile(filePath: string, storage?: SessionStorage): Promise<SessionTitleSlotEntry | undefined>;
 /** Exported for compaction.test.ts */
 export declare function parseSessionEntries(content: string): FileEntry[];
 /** Exported for testing */

package/dist/types/session/session-manager.d.ts

@@ -3,7 +3,7 @@ import { ArtifactManager } from "./artifacts";
 import { type BlobPutOptions, type BlobPutResult } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
 import { type BuildSessionContextOptions, type SessionContext } from "./session-context";
-import { type NewSessionOptions, type SessionEntry, type SessionHeader, type SessionTreeNode, type UsageStatistics } from "./session-entries";
+import { type NewSessionOptions, type SessionEntry, type SessionHeader, type SessionTitleSource, type SessionTreeNode, type UsageStatistics } from "./session-entries";
 import { type SessionInfo } from "./session-listing";
 import { type SessionStorage } from "./session-storage";
 export type ReadonlySessionManager = Pick<SessionManager, "getCwd" | "getSessionDir" | "getSessionId" | "getSessionFile" | "getSessionName" | "getArtifactsDir" | "getArtifactManager" | "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "getLeafId" | "getLeafEntry" | "getEntry" | "getLabel" | "getBranch" | "getHeader" | "getEntries" | "getTree" | "getUsageStatistics" | "putBlob" | "putBlobSync">;
@@ -12,8 +12,10 @@ interface SessionManagerStateSnapshot {
     sessionDir: string;
     sessionId: string;
     sessionName: string | undefined;
-    titleSource: "auto" | "user" | undefined;
+    titleSource: SessionTitleSource | undefined;
     sessionFile: string | undefined;
+    titleUpdatedAt: string;
+    hasTitleSlot: boolean;
     onDisk: boolean;
     needsRewrite: boolean;
     header: SessionHeader;
@@ -109,7 +111,7 @@ export declare class SessionManager {
     saveDraft(text: string): Promise<void>;
     consumeDraft(): Promise<string | null>;
     /** The source that set the session name: "user" (manual/RPC) or "auto" (generated title). */
-    get titleSource(): "auto" | "user" | undefined;
+    get titleSource(): SessionTitleSource | undefined;
     getSessionName(): string | undefined;
     onSessionNameChanged(cb: () => void): () => void;
     /**
@@ -117,7 +119,7 @@ export declare class SessionManager {
      * @param source "user" for explicit renames; "auto" for generated titles.
      *   Auto titles are ignored once the user has set a name.
      */
-    setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
+    setSessionName(name: string, source?: SessionTitleSource, trigger?: string): Promise<boolean>;
     /**
      * Append a foreign (host-authored) entry verbatim, preserving its
      * `id`/`parentId`. Used by collab guests to mirror the host session.

package/dist/types/session/session-storage.d.ts

@@ -1,3 +1,4 @@
+import { type SessionTitleUpdate } from "./session-title-slot";
 export interface SessionStorageStat {
     size: number;
     mtimeMs: number;
@@ -22,6 +23,14 @@ export interface SessionStorage {
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
+    /**
+     * Update the current session title through the storage backend.
+     *
+     * File-like backends rewrite the fixed-width JSONL title slot; indexed
+     * backends can store the semantic title fields and synthesize the slot when
+     * reading.
+     */
+    updateSessionTitle(path: string, update: SessionTitleUpdate): Promise<void>;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
@@ -43,6 +52,7 @@ export declare class FileSessionStorage implements SessionStorage {
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(fpath: string, content: string): void;
+    updateSessionTitle(fpath: string, update: SessionTitleUpdate): Promise<void>;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
@@ -67,6 +77,7 @@ export declare class MemorySessionStorage implements SessionStorage {
     ensureDirSync(_dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
+    updateSessionTitle(path: string, update: SessionTitleUpdate): Promise<void>;
     /**
      * Internal O(1) append used by {@link MemorySessionStorageWriter}. Lazily
      * creates the entry. External callers should go through `openWriter()`

package/dist/types/session/session-title-slot.d.ts

@@ -0,0 +1,19 @@
+import { type SessionTitleSlotEntry, type SessionTitleSource } from "./session-entries";
+/** Semantic title update persisted by session storage backends. */
+export interface SessionTitleUpdate {
+    title?: string;
+    source?: SessionTitleSource;
+    updatedAt: string;
+}
+/** Parse a physical title slot JSONL line. Returns undefined for legacy headers. */
+export declare function parseTitleSlotLine(line: string): SessionTitleSlotEntry | undefined;
+/** Parse the fixed-width title slot from a physical session body. */
+export declare function parseTitleSlotFromContent(content: string): SessionTitleSlotEntry | undefined;
+/** Convert a parsed title slot to the semantic storage update shape. */
+export declare function titleUpdateFromSlot(slot: SessionTitleSlotEntry | undefined): SessionTitleUpdate | undefined;
+/** Serialize the fixed-width first-line title slot, exactly 256 UTF-8 bytes including newline. */
+export declare function serializeTitleSlot(options: SessionTitleUpdate): string;
+/** Replace the physical fixed-width title slot in a full session body. */
+export declare function overlayTitleSlotContent(content: string, update: SessionTitleUpdate): string;
+/** Replace the physical fixed-width title slot in a prefix byte window. */
+export declare function overlayTitleSlotPrefix(prefix: string, prefixBytes: number, update: SessionTitleUpdate): string;

package/dist/types/session/settings-stream-fn.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Settings-aware stream wrapper shared by the main agent (sdk.ts) and the
+ * advisor agent (AgentSession.#buildAdvisorRuntime).
+ *
+ * Reads OpenRouter / Antigravity routing variants, Responses-family text
+ * verbosity, per-provider in-flight caps, and the loop guard out of `Settings`
+ * per request, layering them onto whatever options the caller passed. Before
+ * this helper existed, advisor turns called bare `streamSimple` while the main
+ * turn went through an inline closure that read these settings — so an advisor on
+ * OpenRouter never saw `providers.openrouterVariant`, breaking sticky routing
+ * and OpenRouter response-cache hits across advisor calls.
+ */
+import type { StreamFn } from "@oh-my-pi/pi-agent-core";
+import { type Settings } from "../config/settings";
+/**
+ * Build a {@link StreamFn} that reads provider routing/guard settings from
+ * `settings` per call and forwards to `base` (defaults to `streamSimple`).
+ *
+ * Caller-supplied `streamOptions` always win — the helper only fills holes.
+ */
+export declare function createSettingsAwareStreamFn(settings: Settings, base?: StreamFn): StreamFn;

package/dist/types/session/turn-persistence.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Helpers that share one cheap, structural identity for messages — both during
+ * incremental persistence and for the mid-run-compaction ordering check.
+ *
+ * Previously `AgentSession` carried two near-duplicate routines
+ * (`#sessionMessagesReferToSameTurn` + `#messageValueSignature`) that
+ * reconstructed the branch path on every check (O(n²) `unshift`) and
+ * `JSON.stringify`-compared the full message content on every pairwise hit.
+ * Long-running sessions with many subagents fired this thousands of times per
+ * minute and froze the TUI loop (see issue #3629). The persistence key already
+ * encodes a stable logical identity — timestamp + role-specific discriminators
+ * — so the structural compare is now the rare collision tiebreaker (e.g. two
+ * provider responses at the same millisecond with `undefined` responseId),
+ * not the load-bearing check.
+ *
+ * The helpers here keep that identity in one place and expose the planner so
+ * the persistence-ordering logic is unit-testable without standing up an
+ * `AgentSession`.
+ */
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+/**
+ * Stable identity for messages that pass through {@link AgentSession}'s
+ * incremental persistence path.
+ *
+ * The discriminators chosen per role are precisely the fields that uniquely
+ * identify a single logical message instance:
+ *
+ * - `assistant` — timestamp + provider + model + responseId + stopReason
+ *   (responseId is the canonical provider-side id when available; the rest
+ *   disambiguate when it is not, e.g. local/dev models).
+ * - `toolResult` — timestamp + toolCallId + toolName (toolCallId is unique
+ *   per execution; toolName guards against synthetic reuse).
+ * - `user` / `developer` — timestamp + attribution (attribution distinguishes
+ *   user-typed vs hook-injected at the same wall-clock millisecond).
+ * - `fileMention` — timestamp.
+ *
+ * Returns `undefined` for message roles that are not persisted through this
+ * path (e.g. `hookMessage`, `custom`, `bashExecution`) — those follow other
+ * append paths in `SessionManager`.
+ */
+export declare function sessionMessagePersistenceKey(message: AgentMessage): string | undefined;
+/**
+ * Slow-path content equality check used when two messages collide on
+ * {@link sessionMessagePersistenceKey}. Only the role's content fields are
+ * compared (no timestamps, no metadata) because the key already pinned all of
+ * those down.
+ *
+ * Most calls into the persistence path never reach this — keys are unique
+ * enough in production that the snapshot lookup short-circuits at the key
+ * level. Restoring the structural compare here preserves the pre-#3629
+ * contract that two messages with the same metadata BUT different content are
+ * distinct (e.g. two assistant turns with `undefined` responseId emitted in
+ * the same wall-clock millisecond, which is exactly how the in-memory test
+ * harness crafts streamed responses).
+ */
+export declare function sameMessageContent(left: AgentMessage, right: AgentMessage): boolean;
+/**
+ * Outcome of {@link planTurnPersistence}.
+ *
+ * `ok` lists the turn-message indices that still need to be appended (in
+ * order). `out-of-order` reports the first message whose later sibling is
+ * already persisted — the caller bails so it does not silently splice a
+ * stale message between newer entries on the live branch.
+ */
+export type TurnPersistencePlan = {
+    kind: "ok";
+    toPersist: readonly number[];
+} | {
+    kind: "out-of-order";
+    messageIndex: number;
+};
+/**
+ * Decide what to do with a turn's messages relative to what's already on the
+ * branch, in a single pass over the pre-computed keys.
+ *
+ * @param turnKeys persistence keys for each turn message, in the order the
+ *   agent loop emitted them. `undefined` slots represent messages with no
+ *   persistence key (skipped silently).
+ * @param persistedKeys the snapshot of persistence keys currently on the
+ *   branch (built once per call from {@link sessionMessagePersistenceKey} for
+ *   each persisted message entry).
+ *
+ * The check is O(n²) over turn messages — but `n` here is the size of one
+ * turn (a handful of tool results), not the size of the branch. That's the
+ * point of this refactor: the expensive O(branch) work happens exactly once,
+ * inside the caller's snapshot loop, not per-comparison.
+ */
+export declare function planTurnPersistence(turnKeys: readonly (string | undefined)[], persistedKeys: ReadonlySet<string>): TurnPersistencePlan;

package/dist/types/ssh/connection-manager.d.ts

@@ -14,6 +14,15 @@ export interface SSHHostInfo {
     version: number;
     os: SSHHostOs;
     shell: SSHHostShell;
+    /**
+     * Shell name OMP verified can execute the POSIX transfer snippets
+     * (`head`/`cat`/`mv`/`test`/`ls`) `ssh://` uses. Probed by running
+     * `sh -lc` / `bash -lc` / `zsh -lc` against the remote and keeping the
+     * first one that round-trips a known marker. Independent of `shell`
+     * (the self-reported login shell), which may be noisy, exotic, or simply
+     * mis-classified — only `transferShell` gates ssh:// transfers.
+     */
+    transferShell?: "sh" | "bash" | "zsh";
     compatShell?: "bash" | "sh";
     compatEnabled: boolean;
 }
@@ -22,6 +31,44 @@ interface SSHArgsOptions {
     /** When true, omit `-n` so the remote command can read from our piped stdin. */
     allowStdin?: boolean;
 }
+/**
+ * Parse a raw cache-file value (or any unknown) into a normalized
+ * {@link SSHHostInfo}, dropping fields that don't pass the per-field guards.
+ * Exported so cache-layer round-tripping (incl. the new `transferShell`
+ * field, #3719) is testable without touching disk.
+ */
+export declare function parseHostInfo(value: unknown): SSHHostInfo | null;
+/**
+ * Frame marker emitted by the remote OS/shell probe. The probe wraps its
+ * payload in this prefix so the parser can ignore startup-file noise (banners,
+ * `motd`, login messages, `Last login: …`) instead of trusting only the first
+ * line of stdout. See #3719.
+ */
+export declare const HOST_PROBE_MARKER = "PI_HOST_PROBE=";
+/** Marker for the transfer-shell capability probe. */
+export declare const TRANSFER_PROBE_MARKER = "PI_TRANSFER_OK|";
+/**
+ * Find the first line of `stdout`/`stderr` that begins with `marker` and
+ * return everything after it. Used by the SSH host probe so noisy login
+ * dotfiles can't corrupt OS/shell classification by emitting text on the
+ * first line of `ssh` output.
+ *
+ * Returns `null` when no marker line is found in either stream.
+ */
+export declare function extractProbePayload(stdout: string, stderr: string, marker?: string): string | null;
+/**
+ * Find `marker` anywhere in `stdout` or `stderr` and return everything that
+ * follows it, scanning stdout first. Returns `null` when the marker is in
+ * neither stream.
+ *
+ * Used by the transfer-shell capability probe. Some remotes have broken
+ * login dotfiles that swap fd 1/2, so the marker can land on stderr even
+ * though the probe ran the printf successfully (matches the host-info
+ * probe's stderr fallback). See #3719.
+ */
+export declare function findProbeMarker(stdout: string, stderr: string, marker: string): string | null;
+/** Classify a POSIX-ish `uname -s` payload from the transfer-shell probe. */
+export declare function osFromUname(value: string): SSHHostOs | undefined;
 export declare function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined>;
 export declare function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined>;
 /**

package/dist/types/ssh/utils.d.ts

@@ -6,3 +6,19 @@ export declare function buildSshTarget(username: string | undefined, host: strin
  * `ssh://` file-transfer helpers.
  */
 export declare function quotePosixPath(value: string): string;
+/**
+ * Wrap a POSIX command in `<shell> -c '<command>'` so it runs under the
+ * named shell rather than whatever `$SHELL` happens to be on the remote.
+ *
+ * Used by the `ssh://` transfer helpers and the Windows compat dispatch:
+ * OpenSSH passes our snippets to `<login-shell> -c`, so a remote whose
+ * login shell is fish/csh/tcsh (or cmd/powershell on Windows compat)
+ * can't parse `if [ … ]; then …`. Wrapping forces parsing under the
+ * shell OMP actually verified can run the snippet.
+ *
+ * `-c` (not `-lc`): the transfer snippets only call absolute POSIX
+ * builtins (`head`/`cat`/`mv`/`test`/`ls`/`mkdir`/`rm`/`dirname`) and
+ * don't need login-profile setup. Capability *probing* still uses
+ * `-lc` to mirror the user's real environment.
+ */
+export declare function wrapInPosixShell(shell: "sh" | "bash" | "zsh", command: string): string;

package/dist/types/task/executor.d.ts

@@ -23,7 +23,8 @@ import type { AuthStorage } from "../session/auth-storage";
 import type { ContextFileEntry } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
-import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult, type YieldItem } from "./types";
+export type { YieldItem } from "./types";
 /**
  * Soft per-agent request budgets (assistant requests per run). When a subagent
  * crosses its budget it receives ONE steering notice asking it to wrap up; at
@@ -164,20 +165,6 @@ export interface ExecutorOptions {
      */
     keepAlive?: boolean;
 }
-export interface YieldItem {
-    data?: unknown;
-    status?: "success" | "aborted";
-    error?: string;
-    /**
-     * Set by the in-tool yield validator when it exhausted its retry budget
-     * (MAX_SCHEMA_RETRIES) and accepted a schema-invalid payload anyway.
-     * `finalizeSubprocessOutput` honors this by serializing the payload and
-     * surfacing a stderr warning, instead of re-emitting `schema_violation`
-     * — which would silently swap the subagent's "accepted" view for a
-     * different, opaque error blob in the parent's view of the result.
-     */
-    schemaOverridden?: boolean;
-}
 interface FinalizeSubprocessOutputArgs {
     rawOutput: string;
     exitCode: number;
@@ -187,6 +174,7 @@ interface FinalizeSubprocessOutputArgs {
     yieldItems?: YieldItem[];
     reportFindings?: ReviewFinding[];
     outputSchema: unknown;
+    lastAssistantText?: string;
 }
 interface FinalizeSubprocessOutputResult {
     rawOutput: string;
@@ -217,4 +205,3 @@ export declare function finalizeSubagentLifecycle(args: {
  * Run a single agent in-process.
  */
 export declare function runSubprocess(options: ExecutorOptions): Promise<SingleResult>;
-export {};

package/dist/types/task/render.d.ts

@@ -31,9 +31,4 @@ export declare function renderResult(result: {
     details?: TaskToolDetails;
     isError?: boolean;
 }, options: TaskRenderOptions, theme: Theme, args?: TaskParams): Component;
-export declare const taskToolRenderer: {
-    renderCall: typeof renderCall;
-    renderResult: typeof renderResult;
-    mergeCallAndResult: boolean;
-};
 export {};

package/dist/types/task/renderer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Task tool renderer export.
+ *
+ * Separated from render.ts to avoid circular dependency issues with
+ * tools/renderers.ts. This module has no side effects and can be safely
+ * imported without triggering the subprocessToolRegistry registration.
+ */
+import { renderCall, renderResult } from "./render";
+export declare const taskToolRenderer: {
+    readonly renderCall: typeof renderCall;
+    readonly renderResult: typeof renderResult;
+    readonly mergeCallAndResult: true;
+};

package/dist/types/task/types.d.ts

@@ -206,6 +206,22 @@ export interface AgentDefinition {
     source: AgentSource;
     filePath?: string;
 }
+/** Details extracted from a subagent `yield` tool call for final-result assembly and task rendering. */
+export interface YieldItem {
+    data?: unknown;
+    status?: "success" | "aborted";
+    error?: string;
+    /** A string label is terminal; a non-empty array of labels is incremental. */
+    type?: string | string[];
+    /** Resolve this yield's payload from the latest durable assistant text instead of `data`. */
+    useLastTurn?: boolean;
+    /**
+     * Set by the in-tool yield validator when it exhausted its retry budget and
+     * accepted schema-invalid data anyway. The executor preserves that override
+     * during post-mortem validation.
+     */
+    schemaOverridden?: boolean;
+}
 /** Progress tracking for a single agent */
 export interface AgentProgress {
     index: number;

package/dist/types/task/yield-assembly.d.ts

@@ -0,0 +1,28 @@
+import type { YieldItem } from "./types";
+/** Outcome of folding a run's yield calls into one payload, with provenance flags. */
+interface AssembledYieldResult {
+    data: unknown;
+    schemaOverridden: boolean;
+    rawText: boolean;
+    missingData: boolean;
+}
+/**
+ * Top-level output-schema property names declared as arrays (JTD `elements` →
+ * JSON `type: "array"`). An incremental yield section for such a label
+ * accumulates into a list even when the agent emits exactly one — otherwise a
+ * single `type: ["findings"]` yield would assemble as a bare object and fail
+ * array-typed schema validation.
+ */
+export declare function arrayValuedLabels(outputSchema: unknown): ReadonlySet<string>;
+/**
+ * Assemble typed yield calls into the final payload consumed by schema validation.
+ *
+ * A non-empty array `type` contributes an incremental section and never decides
+ * termination by itself. A string `type` with omitted `data` makes the last
+ * assistant turn the raw terminal result. Other string-typed yields contribute
+ * the terminal labelled section. Untyped terminal yields keep the historical
+ * "last yield wins" behavior unless no terminal yield exists, in which case
+ * accumulated typed sections finalize on idle.
+ */
+export declare function assembleYieldResult(yieldItems: YieldItem[], lastAssistantText?: string, arrayLabels?: ReadonlySet<string>): AssembledYieldResult | undefined;
+export {};

package/dist/types/tiny/text.d.ts

@@ -16,6 +16,14 @@ export declare function stripCodeBlocks(message: string): string;
 /** Prepare a raw user message for titling: drop code blocks, then bound length. */
 export declare function prepareTitleInput(message: string): string;
 export declare function formatTitleUserMessage(message: string): string;
+/** Single recent conversation turn supplied to title refresh after replanning. */
+export interface TitleConversationTurn {
+    role: "user" | "assistant";
+    text?: string;
+    thinking?: string;
+}
+/** Format recent user/assistant context for title generation after a todo replan. */
+export declare function formatTitleConversationContext(turns: readonly TitleConversationTurn[]): string;
 /**
  * True when a first user message is too low-signal to title (greeting, ack,
  * bare number, or empty once code/punctuation/emoji are stripped).

package/dist/types/tools/render-utils.d.ts

@@ -45,6 +45,8 @@ export declare const TRUNCATE_LENGTHS: {
     readonly LINE: 110;
     /** Very short (task previews, badges) */
     readonly SHORT: 40;
+    /** Idle recap status line (~40-word LLM reply) */
+    readonly RECAP: 280;
 };
 /** Human-readable key currently bound to tool-output expansion, e.g. `Ctrl+O`. */
 export declare function expandKeyHint(): string;

package/dist/types/tools/review.d.ts

@@ -1,9 +1,10 @@
 /**
- * Review tools - report_finding for structured code review.
+ * Legacy hidden review-finding tool for agents that have not migrated to
+ * incremental `yield` sections.
  *
- * Used by the reviewer agent to report findings in a structured way.
- * Hidden by default - only enabled when explicitly listed in agent's tools.
- * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
+ * Hidden by default - only enabled when explicitly listed in an agent's tools.
+ * Reviewers now finish via incremental `yield`; this tool remains for
+ * compatibility with older or custom review agents.
  */
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
@@ -15,6 +16,7 @@ export interface FindingPriorityInfo {
     color: ThemeColor;
 }
 export declare const PRIORITY_LABELS: FindingPriority[];
+export declare function isFindingPriority(value: unknown): value is FindingPriority;
 export declare function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo;
 declare const ReportFindingParams: import("arktype/internal/variants/object.ts").ObjectType<{
     title: string;

package/dist/types/tools/ssh.d.ts

@@ -67,7 +67,7 @@ export declare const sshToolRenderer: {
         renderContext?: SshRenderContext;
     }, uiTheme: Theme, args?: SshRenderArgs): Component;
     mergeCallAndResult: boolean;
-    provisionalPendingPreview: string;
+    provisionalPendingPreview: boolean;
     provisionalPartialResult: boolean;
 };
 export {};