@gajae-code/coding-agent 0.16.3 → 0.16.6

package/dist/types/extensibility/runtime-skill-discovery.d.ts

@@ -1,5 +1,5 @@
 import type { SkillsSettings } from "../config/settings-schema";
-import type { Skill } from "./skills";
+import { type Skill } from "./skills";
 export type RuntimeSkillDiscoverySource = "project" | "user";
 export interface RuntimeSkillDiscoveryCandidate {
     name: string;
@@ -24,6 +24,9 @@ export interface RuntimeSkillDiscoveryResult {
 export interface DiscoverRuntimeSkillsOptions {
     cwd: string;
     home?: string;
+    agentDir?: string;
+    /** Resolver-owned profile classification; unlike path comparison, this survives HOME refreshes. */
+    profileAuthority?: "default" | "custom";
     query?: string;
     limit?: number;
     source?: RuntimeSkillDiscoverySource | "all";
@@ -38,4 +41,4 @@ export interface DiscoverRuntimeSkillsOptions {
  */
 export declare function describeDisabledSkillScopes(source: RuntimeSkillDiscoverySource | "all", policy: SkillsSettings | undefined): string | undefined;
 export declare function discoverRuntimeSkills(options: DiscoverRuntimeSkillsOptions): Promise<RuntimeSkillDiscoveryResult>;
-export declare function findRuntimeSkillByName(cwd: string, name: string, policy?: SkillsSettings, home?: string): Promise<Skill | undefined>;
+export declare function findRuntimeSkillByName(cwd: string, name: string, policy?: SkillsSettings, home?: string, agentDir?: string, profileAuthority?: "default" | "custom"): Promise<Skill | undefined>;

package/dist/types/extensibility/shared-events.d.ts

@@ -152,7 +152,7 @@ export interface AgentEndEvent {
     sdkRunToken?: string;
     /** Indicates whether the loop ended normally, suspended, cancelled, or entered maintenance. */
     stopReason?: "completed" | "paused" | "cancelled" | "maintenance";
-    /** Present for maintenance checkpoints; non-aborted checkpoints are not terminal. */
+    /** Present for maintenance checkpoints; only committed maintenance outcomes are non-terminal. */
     maintenanceOutcome?: MidRunMaintenanceOutcome;
 }
 /** Fired at the start of each turn */

package/dist/types/extensibility/skill-management.d.ts

@@ -32,6 +32,7 @@ export interface ConventionSkillImportSource {
 export interface WriteNativeSkillInput {
     cwd: string;
     home?: string;
+    agentDir?: string;
     scope: SkillScope;
     name: string;
     content: string;
@@ -61,13 +62,14 @@ export declare function getProjectSkillDirs(cwd: string, home: string): Promise<
     repoRoot: string | null;
 }>;
 /** Canonical user skill directories in precedence order (same resolution as runtime discovery). */
-export declare function getUserSkillDirs(home: string): string[];
+export declare function getUserSkillDirs(home: string, agentDir?: string, profileAuthority?: "default" | "custom"): string[];
 /**
  * The canonical directory a write targets for a scope: the repo root (or `cwd`)
- * `.gjc/skills` for project scope, the canonical `<config>/agent/skills` user
- * root for user scope (honoring `GJC_CONFIG_DIR` / `PI_CONFIG_DIR`).
+ * `.gjc/skills` for project scope, the agent directory's `skills` root for user
+ * scope — the same directory every reader scans first (`gjc config path` prints
+ * it; `--agent-dir` / `GJC_CODING_AGENT_DIR` / `setAgentDir()` move it).
  */
-export declare function resolveNativeSkillScopeDir(cwd: string, scope: SkillScope, home?: string): Promise<string>;
+export declare function resolveNativeSkillScopeDir(cwd: string, scope: SkillScope, _home?: string, agentDir?: string): Promise<string>;
 /**
  * Authoritative discovery of native skills with provenance and enablement
  * state. Unlike runtime session discovery, this lists every scanned skill —
@@ -77,6 +79,9 @@ export declare function resolveNativeSkillScopeDir(cwd: string, scope: SkillScop
 export declare function listNativeSkillsForManagement(options: {
     cwd: string;
     home?: string;
+    agentDir?: string;
+    /** Resolver-owned profile classification; unlike path comparison, this survives HOME refreshes. */
+    profileAuthority?: "default" | "custom";
     policy?: SkillManagementPolicy;
 }): Promise<ManagedSkillRecord[]>;
 /**

package/dist/types/extensibility/skills.d.ts

@@ -57,6 +57,8 @@ export interface LoadSkillsOptions extends SkillsSettings {
     home?: string;
     /** Explicit user agent directory for native user-scope skill discovery. */
     agentDir?: string;
+    /** Resolver-owned classification for the selected agent directory. */
+    profileAuthority?: "default" | "custom";
 }
 /**
  * Load skills from all configured locations.

package/dist/types/gjc-runtime/empty-delete-gc.d.ts

@@ -13,7 +13,7 @@ export interface EmptyDeleteIdentity {
     mtimeNs: bigint;
     parentDev: bigint;
     parentIno: bigint;
-    sha256: string;
+    sha256?: string;
 }
 export interface EmptyDeleteGcRecord {
     root: string;
@@ -44,11 +44,14 @@ export interface EmptyDeleteGcReport {
 export interface EmptyDeleteGcOptions {
     roots: string[];
     prune: boolean;
+    /** Disk artifact GC must not remove unrelated file receipts. */
+    artifactRootsOnly?: boolean;
 }
 export interface EmptyDeleteGcDependencies {
     /** Internal seam for deterministic collect-to-prune race tests. */
     collect?: (root: string) => Promise<EmptyDeleteGcRecord[]>;
     exactUnlinkDirect?: typeof exactUnlinkDirect;
+    rmdir?: (directory: string) => Promise<void>;
 }
 export declare function collectEmptyDeleteReceipts(root: string, deps?: {
     lstat?: (file: string, options: {

package/dist/types/gjc-runtime/linux-proc.d.ts

@@ -26,6 +26,8 @@ export declare function parseLinuxProcStartTime(stat: string | null | undefined)
 export declare function parseLinuxProcTtyDevice(stat: string | null | undefined): string | null;
 /** Parse field 3 (single-letter process state) from a `/proc/<pid>/stat` record. */
 export declare function parseLinuxProcState(stat: string | null | undefined): string | null;
+/** Parse field 4 (`ppid`) from a `/proc/<pid>/stat` record. */
+export declare function parseLinuxProcParentPid(stat: string | null | undefined): number | null;
 export declare function probeLinuxProcPidSync(pid: number): LinuxProcPidProbeResult;
 export declare function probeLinuxProcPid(pid: number): Promise<LinuxProcPidProbeResult>;
 /**

package/dist/types/gjc-runtime/session-state-lock.d.ts

@@ -83,6 +83,8 @@ export declare const SessionStateLockTestHooks: {
     forcedQuarantineName?: string;
     /** @internal Observes bounded acquisition retries without changing their timing. */
     afterAcquireContention?: (lockFile: string, attempt: number, elapsedMs: number) => void;
+    /** @internal Observes process-local admission without altering on-disk ownership. */
+    afterLocalTransitionQueued?: (transitionDir: string) => void;
     /** @internal Runs after transition mkdir contention and before stale-claim inspection. */
     afterTransitionClaimContention?: (transitionDir: string) => void | Promise<void>;
 };
@@ -168,4 +170,16 @@ export declare function reclaimStaleSessionStateLock(lockFile: string, quarantin
  * lock file itself and may run for as long as it needs.
  */
 export declare function withSessionStateFileLock<T>(stateFile: string, operation: () => Promise<T>): Promise<T>;
+/**
+ * Try one admission without joining a live owner's queue or backing off on contention.
+ * A stale reclaim may return `acquired: false` after making the next attempt possible.
+ * Once admitted, the operation and identity-safe release use the normal lock protocol;
+ * their failures propagate rather than being reported as contention.
+ */
+export declare function tryWithSessionStateFileLock<T>(stateFile: string, operation: () => Promise<T>): Promise<{
+    acquired: true;
+    value: T;
+} | {
+    acquired: false;
+}>;
 export {};

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -208,7 +208,36 @@ export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
     reason: string;
     currentGoalObjective?: string;
 }): Promise<UltragoalNudgeOutcome>;
-export declare function writePlan(cwd: string, plan: UltragoalPlan, sessionId?: string | null): Promise<void>;
+export declare function writePlan(cwd: string, plan: UltragoalPlan, sessionId?: string | null, 
+/** Set by callers already inside {@link withUltragoalPlanOwnership} for this plan. */
+options?: {
+    lockHeld?: boolean;
+}): Promise<void>;
+/**
+ * The single exclusion that decides who owns an Ultragoal run (#5353).
+ *
+ * Establishing ownership is a read-decide-write sequence, not a write: a start
+ * reads the plan, checks the outgoing succession fence, then commits `active`.
+ * Checking quiescence at a point in time and writing afterwards is not enough —
+ * an offer can observe `pending` in the window between an in-flight start's
+ * check and its commit, and both runs then believe they own the goal.
+ *
+ * Every caller that decides ownership — source admission (`start`/`checkpoint`),
+ * succession offer/fence issuance, and successor publication — runs its whole
+ * decision inside this lock, keyed on the plan it is deciding about, and
+ * re-reads the plan under it. Writers inside pass `lockHeld` because
+ * `withFileLock` intentionally serializes same-process callers as well.
+ *
+ * Lock ordering: this lock is always taken BEFORE any ledger lock. The existing
+ * ledger-scoped critical sections (nudge budget, critic verdict, critic gate
+ * override) never write the plan, so no cycle exists.
+ */
+export declare function withUltragoalPlanOwnership<T>(cwd: string, sessionId: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Resolve the session whose plan ownership is being decided, without changing
+ * the resolution behaviour callers already depend on.
+ */
+export declare function resolveUltragoalOwnershipSession(cwd: string, sessionId?: string | null): Promise<string>;
 export declare function nonEmptyString(value: unknown): string | null;
 export declare function stringArray(value: unknown): string[] | null;
 export declare function readUltragoalPlan(cwd: string, sessionId?: string | null): Promise<UltragoalPlan | null>;
@@ -324,13 +353,22 @@ export declare function validateUltragoalQualityGateReadOnly(input: {
     valid: boolean;
     errors: readonly UltragoalQualityGateDiagnostic[];
 }>;
-export declare function checkpointUltragoalGoal(input: {
+export interface UltragoalCheckpointInput {
     cwd: string;
     goalId: string;
     status: UltragoalGoalStatus;
     evidence: string;
     qualityGateJson?: string;
-}): Promise<UltragoalPlan>;
+}
+/**
+ * Checkpointing shares its plan with a succession offer, but only its *commit*
+ * is fenced against one (#5353). Completion validation must observe the same
+ * repository basis `quality-gate source-hash` did, and the ownership lock's own
+ * on-disk artifact lives under `.gjc/` — a path repositories are not required to
+ * ignore — so capturing the basis while holding it would make the runtime digest
+ * disagree with the gate the caller was told to produce.
+ */
+export declare function checkpointUltragoalGoal(input: UltragoalCheckpointInput): Promise<UltragoalPlan>;
 export interface UltragoalCheckpointContinuation {
     plan: UltragoalPlan;
     checkpointedGoal: UltragoalGoal;

package/dist/types/gjc-runtime/ultragoal-succession.d.ts

@@ -0,0 +1,251 @@
+import { type RepositoryBinding } from "./repository-binding";
+import { type UltragoalCommandResult, type UltragoalGjcGoalMode, type UltragoalGoalStatus, type UltragoalPlan } from "./ultragoal-runtime";
+export declare const ULTRAGOAL_SUCCESSION_OPERATION_SCHEMA: "gjc.ultragoal_succession_operation.v1";
+export declare const ULTRAGOAL_SUCCESSION_OFFER_SCHEMA: "gjc.ultragoal_succession_offer.v1";
+export declare const ULTRAGOAL_SUCCESSION_FENCE_SCHEMA: "gjc.ultragoal_succession_fence.v1";
+export declare const ULTRAGOAL_SUCCESSION_ADOPTION_SCHEMA: "gjc.ultragoal_succession_adoption.v1";
+export declare const ULTRAGOAL_SUCCESSION_CLAIM_SCHEMA: "gjc.ultragoal_succession_claim.v1";
+export declare const SUCCESSION_ADOPTED_EVENT: "succession_adopted";
+export type UltragoalSuccessionErrorCode = "source_plan_missing" | "source_not_quiescent" | "invalid_selection" | "unsafe_target" | "authorization_required" | "divergent_operation" | "goal_handed_off" | "adoption_unpublished" | "publication_conflict" | "published_plan_missing" | "fence_missing" | "fence_mismatch" | "source_changed" | "offer_untrusted" | "offer_path_escape" | "target_mismatch" | "target_occupied" | "duplicate_adoption";
+export declare class UltragoalSuccessionError extends Error {
+    readonly code: UltragoalSuccessionErrorCode;
+    constructor(code: UltragoalSuccessionErrorCode, message: string);
+}
+export interface UltragoalSuccessionArtifactDigests {
+    briefSha256: string;
+    goalsSha256: string;
+    ledgerSha256: string;
+}
+export interface UltragoalSuccessionCarriedGoal {
+    sourceGoalId: string;
+    title: string;
+    /** The source objective, verbatim. Never a summary. */
+    objective: string;
+    /** Historical provenance only; never a receipt. */
+    sourceStatusAtOffer: UltragoalGoalStatus;
+    unresolvedObligations: string[];
+    /**
+     * Source dependency groups this goal belonged to, carried as an obligation
+     * with explicit id mapping. The group's *metadata* (batch hashes, receipts)
+     * is deliberately not carried — that would be inherited validation authority.
+     * What is carried is the requirement that these goals be validated together.
+     */
+    dependencyGroups: UltragoalSuccessionDependencyGroup[];
+}
+export type UltragoalSuccessionDependencyGroupKind = "validation-batch" | "review-blocker";
+export interface UltragoalSuccessionDependencyGroup {
+    kind: UltragoalSuccessionDependencyGroupKind;
+    groupId: string;
+    memberSourceGoalIds: string[];
+    /** For validation batches: the source goal that closed the batch. */
+    finalSourceGoalId?: string;
+}
+/**
+ * Per-selected-goal snapshot of exactly what was offered.
+ *
+ * Admission compares *this*, not whole-file equality. The fence deliberately
+ * leaves unselected goals schedulable, so ordinary source progress moves
+ * `goals.json`/`ledger.jsonl` bytes; requiring whole-file equality would
+ * permanently strand the selected work through drift that never touched it
+ * (issue #5353 review item 3). Whole-file digests remain recorded as provenance
+ * and any observed drift is written into the adoption record.
+ */
+export interface UltragoalSuccessionSelectionSnapshot {
+    /** The brief carries global constraints, so it must not change. */
+    briefSha256: string;
+    goals: Array<{
+        sourceGoalId: string;
+        recordSha256: string;
+        obligationsSha256: string;
+    }>;
+    snapshotSha256: string;
+}
+export interface UltragoalSuccessionOffer {
+    schema: typeof ULTRAGOAL_SUCCESSION_OFFER_SCHEMA;
+    operationId: string;
+    createdAt: string;
+    source: {
+        sessionId: string;
+        repository: RepositoryBinding;
+        /** Whole-file digests at offer time. Provenance; not the admission test. */
+        artifacts: UltragoalSuccessionArtifactDigests;
+        /** The authoritative admission test for "did the offered work change". */
+        selectionSnapshot: UltragoalSuccessionSelectionSnapshot;
+        gjcGoalMode: UltragoalGjcGoalMode;
+    };
+    target: {
+        repository: RepositoryBinding;
+    };
+    selection: {
+        goalIds: string[];
+    };
+    carryover: {
+        /** The source brief, verbatim. */
+        brief: string;
+        goals: UltragoalSuccessionCarriedGoal[];
+    };
+    authorization: {
+        statement: string;
+        authorizedBy: string;
+    };
+    provenanceNotice: string;
+}
+export interface UltragoalSuccessionFence {
+    schema: typeof ULTRAGOAL_SUCCESSION_FENCE_SCHEMA;
+    operationId: string;
+    createdAt: string;
+    sourceSessionId: string;
+    sourceRepository: RepositoryBinding;
+    targetRepository: RepositoryBinding;
+    selectedGoalIds: string[];
+    sourceArtifacts: UltragoalSuccessionArtifactDigests;
+    offerPath: string;
+    offerSha256: string;
+}
+export interface UltragoalSuccessionGoalMapping {
+    sourceGoalId: string;
+    targetGoalId: string;
+}
+export interface UltragoalSuccessionAdoption {
+    schema: typeof ULTRAGOAL_SUCCESSION_ADOPTION_SCHEMA;
+    operationId: string;
+    status: "pending" | "published";
+    claimedAt: string;
+    publishedAt?: string;
+    targetSessionId: string;
+    targetRepository: RepositoryBinding;
+    source: {
+        sessionId: string;
+        repository: RepositoryBinding;
+        artifacts: UltragoalSuccessionArtifactDigests;
+        /** Whole-file digests observed at adoption; may differ from the offer. */
+        artifactsAtAdoption: UltragoalSuccessionArtifactDigests;
+        /** Whole-file drift on goals the offer did not select, recorded honestly. */
+        unselectedDrift: string[];
+        verifiedAt: string;
+    };
+    goalMap: UltragoalSuccessionGoalMapping[];
+    /**
+     * Content digest of the plan this operation is entitled to publish, recorded
+     * before publication. A pending replay may only proceed when the target plan
+     * is absent or matches this exactly; anything else is someone else's work.
+     */
+    expectedPlanDigest: string;
+    /** Pinned so the published plan is a deterministic function of the claim. */
+    plannedAt: string;
+    offerPath: string;
+    offerSha256: string;
+    fencePath: string;
+    claimPath: string;
+    authorization: {
+        statement: string;
+        authorizedBy: string;
+    };
+    provenanceNotice: string;
+}
+/**
+ * Repository-wide adoption claim.
+ *
+ * The session-scoped adoption record cannot be the exclusion primitive: two
+ * simultaneous sessions in one repository each create their own file and both
+ * win. This claim is a single O_EXCL file per operation for the whole
+ * repository, so exclusion is atomic rather than scan-then-write.
+ */
+export interface UltragoalSuccessionRepositoryClaim {
+    schema: typeof ULTRAGOAL_SUCCESSION_CLAIM_SCHEMA;
+    operationId: string;
+    targetSessionId: string;
+    targetWorktreeRoot: string;
+    targetCommonDir: string | null;
+    claimedAt: string;
+}
+export declare function ultragoalSuccessionDir(cwd: string, sessionId: string): string;
+export declare function ultragoalSuccessionFencePath(cwd: string, sessionId: string): string;
+export declare function ultragoalSuccessionAdoptionPath(cwd: string, sessionId: string): string;
+export declare function ultragoalSuccessionOfferPath(cwd: string, sessionId: string, operationId: string): string;
+/**
+ * Repository-wide (deliberately NOT session-scoped) adoption claim.
+ *
+ * Session directories cannot express "this repository has already adopted this
+ * operation", so the exclusion primitive lives beside them under the shared
+ * ultragoal root that `getUltragoalPaths` already uses for session-less state.
+ */
+export declare function ultragoalSuccessionClaimPath(cwd: string, operationId: string): string;
+/** Read the durable outgoing ownership fence for a source session, if any. */
+export declare function readUltragoalSuccessionFence(cwd: string, sessionId: string): Promise<UltragoalSuccessionFence | null>;
+/** Read the durable adoption claim for a target session, if any. */
+export declare function readUltragoalSuccessionAdoption(cwd: string, sessionId: string): Promise<UltragoalSuccessionAdoption | null>;
+/**
+ * Source admission guard: a goal that has been handed off to a successor run is
+ * no longer this run's to schedule or checkpoint.
+ *
+ * Goals outside the fenced selection stay fully schedulable — the fence defines
+ * one owner per goal, not a freeze of the whole source run.
+ */
+export declare function assertUltragoalGoalNotFenced(cwd: string, sessionId: string | null | undefined, goalId: string): Promise<void>;
+/**
+ * Target admission guard: an adoption that has not finished publishing does not
+ * yet own anything.
+ *
+ * Publication writes `goals.json` before it marks the claim published, so a
+ * crash leaves a *visible plan with an unpublished claim*. A visible plan is not
+ * admission evidence — the claim is. Without this, the target executes goals
+ * whose adoption was never completed, and the run's own completion receipts
+ * would rest on a transaction that never committed.
+ *
+ * Callers must invoke this before any mutation so a refusal leaves `goals.json`
+ * and `ledger.jsonl` untouched.
+ */
+export declare function assertUltragoalAdoptionPublished(cwd: string, sessionId: string | null | undefined): Promise<void>;
+export interface UltragoalSuccessionOfferInput {
+    cwd: string;
+    sessionId?: string | null;
+    targetRepositoryPath: string;
+    goalIds: readonly string[];
+    authorization: string;
+    authorizedBy: string;
+}
+export interface UltragoalSuccessionOfferResult {
+    operationId: string;
+    offerPath: string;
+    fencePath: string;
+    offer: UltragoalSuccessionOffer;
+    /** True when an identical prior operation was reconciled instead of re-recorded. */
+    reconciled: boolean;
+}
+/**
+ * Record an explicit successor offer and fence the selected goals off from the
+ * source run. Writes nothing to the source brief, goals or ledger.
+ */
+export declare function offerUltragoalSuccession(input: UltragoalSuccessionOfferInput): Promise<UltragoalSuccessionOfferResult>;
+export interface UltragoalSuccessionAdoptInput {
+    cwd: string;
+    sessionId?: string | null;
+    offerPath: string;
+    gjcGoalMode?: UltragoalGjcGoalMode;
+}
+export interface UltragoalSuccessionAdoptResult {
+    operationId: string;
+    adoptionPath: string;
+    plan: UltragoalPlan;
+    goalMap: UltragoalSuccessionGoalMapping[];
+    reconciled: boolean;
+}
+/**
+ * Adopt an explicit successor offer into this repository/session.
+ *
+ * Fails closed on a forged or stale offer, a changed source, a missing source
+ * fence, an unnamed target, an occupied target, and any duplicate or divergent
+ * adoption anywhere in this repository. A retry reconciles the exact recorded
+ * operation or fails closed; it never resumes a different one.
+ */
+export declare function adoptUltragoalSuccession(input: UltragoalSuccessionAdoptInput): Promise<UltragoalSuccessionAdoptResult>;
+/**
+ * `gjc ultragoal succession <offer|adopt|status>`.
+ *
+ * Kept out of `RECONCILE_COMMANDS` on purpose: the reconcile pass appends a
+ * `reconcile_failed` ledger row on failure, which would move the very source
+ * digests this feature records. The target's workflow state and HUD reconcile on
+ * the next ordinary `gjc ultragoal status`.
+ */
+export declare function runUltragoalSuccessionCommand(args: readonly string[], cwd: string): Promise<UltragoalCommandResult>;

package/dist/types/modes/components/assistant-message.d.ts

@@ -10,10 +10,9 @@ interface AssistantMessageUpdateOptions {
 export declare class AssistantMessageComponent extends Container {
     #private;
     private hideThinkingBlock;
-    private readonly onImageUpdate?;
     private readonly onVisibleMutation?;
     private readonly hintSession?;
-    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, viewportAnchorId?: string, onVisibleMutation?: (() => void) | undefined, hintSession?: ProviderSafetyStopHintSession | undefined);
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: () => void, viewportAnchorId?: string, onVisibleMutation?: (() => void) | undefined, hintSession?: ProviderSafetyStopHintSession | undefined);
     invalidate(): void;
     setHideThinkingBlock(hide: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;

package/dist/types/modes/components/bash-execution.d.ts

@@ -15,6 +15,7 @@ export declare class BashExecutionComponent extends Container {
     appendOutput(chunk: string): void;
     setComplete(exitCode: number | undefined, cancelled: boolean, options?: {
         output?: string;
+        signal?: string;
         truncation?: TruncationMeta;
     }): void;
     render(width: number): string[];

package/dist/types/modes/components/execution-shared.d.ts

@@ -34,6 +34,7 @@ export declare function createCollapsedPreview(previewText: string, previewLines
 export declare function buildStatusFooter(opts: {
     status: ExecutionStatus;
     exitCode: number | undefined;
+    signal?: string;
     truncation: TruncationMeta | undefined;
     hiddenLineCount: number;
     /** Suppress the "… N more lines" hint (used when sixel passthrough renders the full output). */

package/dist/types/modes/components/settings-selector.d.ts

@@ -5,7 +5,7 @@ import { type SettingPath } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import type { GjcRuntimeSnapshotProvider } from "../../extensibility/gjc-plugins/runtime-quarantine";
 import { type NotificationsEditorOperations } from "./notifications-settings-editor";
-import type { StatusLineSegmentOptions } from "./tool-status-header";
+import type { StatusLinePreviewParts, StatusLineSegmentOptions } from "./tool-status-header";
 /**
  * Dynamic context for settings that need runtime data.
  * Some settings (like thinking level) are managed by the session, not Settings.
@@ -42,6 +42,7 @@ export interface StatusLinePreviewSettings {
     separator?: StatusLineSeparatorStyle;
     segmentOptions?: StatusLineSegmentOptions;
     previewHighlightSegment?: StatusLineSegmentId;
+    previewHighlightStyle?: "focus" | "selected";
     sessionAccent?: boolean;
     maxRows?: number;
 }
@@ -70,6 +71,10 @@ export interface SettingsCallbacks {
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
     /** Get current rendered status line for inline preview */
     getStatusLinePreview?: (width?: number) => string;
+    /** Render a status-line preview for supplied draft settings without mutating the live status line. */
+    getStatusLinePreviewForSettings?: (settings: StatusLinePreviewSettings, width?: number) => string;
+    /** Render status-line segment groups for supplied draft settings without mutating the live status line. */
+    getStatusLinePreviewPartsForSettings?: (settings: StatusLinePreviewSettings, width?: number) => StatusLinePreviewParts;
     /** Called when plugins change */
     onPluginsChanged?: () => void;
     /** Called when asynchronously rebuilt settings content needs a repaint. */

package/dist/types/modes/components/status-line/command.d.ts

@@ -0,0 +1,35 @@
+export declare const STATUS_LINE_COMMAND_DEFAULT_MAX_LENGTH = 80;
+export declare const STATUS_LINE_COMMAND_MAX_LENGTH = 256;
+export interface StatusLineCommandOptions {
+    command?: string;
+    timeoutMs?: number;
+    refreshMs?: number;
+    maxLength?: number;
+}
+export interface ResolvedStatusLineCommandOptions {
+    command: string;
+    timeoutMs: number;
+    refreshMs: number;
+    maxLength: number;
+}
+export interface StatusLineCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut: boolean;
+    outputTruncated: boolean;
+}
+export declare function normalizeStatusLineCommandOptions(value: unknown): ResolvedStatusLineCommandOptions;
+/**
+ * Run a configured status-line command without making the synchronous render
+ * path wait on it. The streams are drained with a hard byte cap and the whole
+ * process group is killed when the timeout expires.
+ */
+export declare function runStatusLineCommand(command: string, options: {
+    cwd: string;
+    shell: string;
+    shellArgs: readonly string[];
+    env: Record<string, string>;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<StatusLineCommandResult>;

package/dist/types/modes/components/status-line/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./command";
 export * from "./presets";
 export * from "./segments";
 export * from "./separators";

package/dist/types/modes/components/status-line/types.d.ts

@@ -57,6 +57,11 @@ export interface SegmentContext {
             resetUnit?: "m" | "h";
         }>;
     } | null;
+    command?: {
+        output: string | null;
+        failed: boolean;
+        pending: boolean;
+    };
 }
 export interface RenderedSegment {
     content: string;

package/dist/types/modes/components/tool-status-header.d.ts

@@ -5,6 +5,8 @@ import type { AgentSession } from "../../session/agent-session";
 import { type SkillActiveEntry } from "../../skill-state/active-state";
 import type { ActionRegistry, FocusDomain } from "../action-registry";
 import { type JobsSnapshot } from "../jobs-observer";
+import { type StatusLineCommandOptions } from "./status-line/command";
+import type { SeparatorDef } from "./status-line/types";
 export interface StatusLineSegmentOptions {
     model?: {
         showThinkingLevel?: boolean;
@@ -28,6 +30,7 @@ export interface StatusLineSegmentOptions {
     usage?: {
         mode?: "used" | "remaining";
     };
+    command?: StatusLineCommandOptions;
 }
 export interface StatusLineSettings {
     preset?: StatusLinePreset;
@@ -36,6 +39,7 @@ export interface StatusLineSettings {
     separator?: StatusLineSeparatorStyle;
     segmentOptions?: StatusLineSegmentOptions;
     previewHighlightSegment?: StatusLineSegmentId;
+    previewHighlightStyle?: "focus" | "selected";
     showHookStatus?: boolean;
     showSkillHud?: boolean;
     showActionHints?: boolean;
@@ -48,11 +52,19 @@ export interface StatusLineComponentOptions {
     getKeybindings?: () => KeybindingsManager;
     focusDomain?: FocusDomain;
     keyDisplayContext?: KeyDisplayContext;
+    onUpdate?: () => void;
 }
 export interface StatusLineActionHint {
     id: AppKeybinding;
     content: string;
 }
+export interface StatusLinePreviewParts {
+    left: string[];
+    leftIds: StatusLineSegmentId[];
+    right: string[];
+    rightIds: (StatusLineSegmentId | null)[];
+    separator: SeparatorDef;
+}
 /**
  * Produces whole, bound action hints for the current focus domain. The registry
  * remains the authority for availability; KEYBINDINGS remains the authority for
@@ -100,6 +112,8 @@ export declare class StatusLineComponent implements Component {
      * everything fits on one row.
      */
     getPreviewContent(width: number): string;
+    getPreviewContentForSettings(width: number, previewSettings: StatusLineSettings): string;
+    getPreviewPartsForSettings(width: number, previewSettings: StatusLineSettings): StatusLinePreviewParts;
     getCacheStatsForTest(): {
         rowHits: number;
         rowMisses: number;

package/dist/types/modes/controllers/event-controller.d.ts

@@ -14,6 +14,12 @@ export declare class EventController {
     private ctx;
     constructor(ctx: InteractiveModeContext);
     dispose(): void;
+    /** Temporary TUI stop discards scheduling, not historical assistant callback lifetimes. */
+    suspendAssistantTextPresentation(): void;
+    /** Rearm before the first restarted frame, even without a new provider event. */
+    resumeAssistantTextPresentation(): void;
+    /** Session/transcript replacement invalidates callbacks before removing old children. */
+    resetAssistantTextPresentation(): void;
     subscribeToAgent(): void;
     handleEvent(event: AgentSessionEvent): Promise<void>;
     clearIrcExpiryTimers(): void;

package/dist/types/modes/interactive-mode.d.ts

@@ -198,6 +198,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     beginOAuthUrlForCopy(url: string): () => void;
     hasOAuthUrlForCopy(): boolean;
     copyOAuthUrl(): Promise<void>;
+    /** Clear the status display without settling the foreground run during maintenance/retry. */
+    clearLoadingAnimation(): void;
     syncActivityIndicator(): void;
     ensureLoadingAnimation(): void;
     stopLoadingAnimation(options?: ActivityIndicatorStopOptions): void;
@@ -213,6 +215,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): Promise<void>;
     flushPendingBashComponents(): void;
     isKnownSlashCommand(text: string): boolean;
+    resetAssistantTextPresentation(): void;
     /** Advances the sticky-viewport source only for semantic transcript output. */
     recordVisibleTranscriptMutation(): void;
     addMessageToChat(message: AgentMessage, options?: {