@skrr-ai/cli 0.1.50 → 0.1.51

package/dist/commands/outbox/list.js

@@ -1,11 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.queuedBecause = queuedBecause;
 exports.outboxListSnapshot = outboxListSnapshot;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const keychain_1 = require("../../lib/keychain");
 const format_1 = require("../../lib/format");
 const outbox_1 = require("../../lib/outbox");
+/**
+ * Why one entry was queued, in words (OSK-12121). The queue holds more than
+ * outage casualties — a 401 is queued too, so authored content survives a lapsed
+ * sign-in — and a list that described every entry as "the API was unavailable"
+ * sent a signed-out reader to wait for an outage that was not happening.
+ */
+function queuedBecause(entry) {
+    const status = entry.reason?.status;
+    if (status === 401)
+        return { label: 'sign-in refused (401)', kind: 'auth' };
+    if (status === 429)
+        return { label: 'throttled (429)', kind: 'throttled' };
+    if ((typeof status === 'number' && status >= 500) || (0, outbox_1.isOutageFailure)(entry.reason)) {
+        return { label: status ? `unavailable (${status})` : 'unreachable', kind: 'unavailable' };
+    }
+    return { label: status ? `HTTP ${status}` : 'unknown', kind: 'other' };
+}
 function outboxListSnapshot(profile) {
     const queued = (0, outbox_1.listWrites)(profile);
     const incident = (0, outbox_1.readIncident)(profile);
@@ -24,7 +42,7 @@ function outboxListSnapshot(profile) {
  * where they find out.
  */
 class OutboxList extends base_command_1.BaseCommand {
-    static description = 'Show writes queued locally because the API was unavailable';
+    static description = 'Show writes queued locally because the server could not take them: an outage, throttling, or a lapsed sign-in';
     static examples = [
         '<%= config.bin %> outbox list',
         '<%= config.bin %> outbox list --json',
@@ -46,7 +64,9 @@ class OutboxList extends base_command_1.BaseCommand {
                 `${incident.consecutive} consecutive failure(s).`);
             this.log('');
         }
-        else if (incident) {
+        else if (incident && entries.some((e) => queuedBecause(e).kind === 'unavailable')) {
+            // A past incident is context only for entries an outage put here. Beside
+            // a queue of sign-in refusals it reads as the explanation, and is not.
             this.log(`Last service incident: ${incident.baseURL} failed at ${incident.lastOutageAt}` +
                 `${incident.status ? ` (HTTP ${incident.status})` : ''}. ` +
                 'No current outage is confirmed.');
@@ -61,6 +81,7 @@ class OutboxList extends base_command_1.BaseCommand {
             queued: e.queuedAt,
             command: e.command,
             summary: e.summary,
+            why: queuedBecause(e).label,
             // Surface the attempt count only once it matters; a column of "0"s is
             // noise, but an entry nearing the cap needs a human.
             attempts: e.attempts > 0 ? `${e.attempts}/${outbox_1.MAX_REPLAY_ATTEMPTS}` : '-',
@@ -69,6 +90,7 @@ class OutboxList extends base_command_1.BaseCommand {
             { key: 'queued', header: 'QUEUED', maxWidth: 24 },
             { key: 'command', header: 'COMMAND', maxWidth: 24 },
             { key: 'summary', header: 'SUMMARY', maxWidth: 40 },
+            { key: 'why', header: 'WHY', maxWidth: 24 },
             { key: 'attempts', header: 'TRIES' },
         ], (line) => this.log(line));
         const exhausted = entries.filter((e) => e.attempts >= outbox_1.MAX_REPLAY_ATTEMPTS);
@@ -77,6 +99,13 @@ class OutboxList extends base_command_1.BaseCommand {
             this.log(`${exhausted.length} entry(ies) hit the ${outbox_1.MAX_REPLAY_ATTEMPTS}-attempt cap and will not be ` +
                 'retried automatically. Inspect the failure, then retry or drop them explicitly.');
         }
+        const authQueued = entries.filter((e) => queuedBecause(e).kind === 'auth').length;
+        if (authQueued > 0) {
+            this.log('');
+            this.log(`${authQueued} entry(ies) were queued because the server refused this sign-in, not because ` +
+                `it was down. Sign in with \`${this.config.bin} login\` first; a replay before that is ` +
+                'refused the same way.');
+        }
         this.log('');
         this.log(`Replay:  ${this.config.bin} outbox retry`);
         this.log(`Discard: ${this.config.bin} outbox drop <id>`);

package/dist/commands/revoke-daemon.js

@@ -67,6 +67,8 @@ class RevokeDaemon extends base_command_1.BaseCommand {
             const host = resolvedDaemon?.machineUuid
                 ? resolvedDaemon.machineUuid.slice(0, 12)
                 : (resolvedDaemon?.os ?? 'unknown host');
+            this.log('Revoking a daemon also revokes every CLI sign-in it brokered — on its machine, ' +
+                `\`${this.config.bin} login\` without a browser signs in through the daemon.`);
             const confirmed = await this.confirm(`Revoke daemon "${name}" on ${host}? [y/N] `);
             if (!confirmed) {
                 this.log('Aborted.');
@@ -99,6 +101,13 @@ class RevokeDaemon extends base_command_1.BaseCommand {
         const daemonId = (res.daemon?.id ?? resolvedId).slice(0, 12);
         if (res.revoked) {
             this.log(`Revoked daemon ${daemonName} (${daemonId}).`);
+            if (res.callerSessionRevoked === true) {
+                // Said now, not discovered later as a refresh failure: the sign-in this
+                // command used was brokered by that daemon and died with it.
+                this.warn(`This also signed out ${this.config.bin} on this machine: its sign-in was brokered ` +
+                    `by that daemon and was revoked with it. Run \`${this.config.bin} daemon login\` to ` +
+                    `re-enroll the daemon, then \`${this.config.bin} login\` to sign the CLI in again.`);
+            }
             // exit 0 (default)
         }
         else if (res.alreadyRevoked) {

package/dist/commands/spaces/create.d.ts

@@ -19,6 +19,7 @@ export default class SpacesCreate extends BaseCommand {
         'group-chat': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         parent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'inherit-access': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'working-directory': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/spaces/create.js

@@ -9,6 +9,7 @@ const label_ref_1 = require("../../lib/label-ref");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
 const created_line_1 = require("../../lib/created-line");
+const tasks_1 = require("../../lib/tasks");
 class SpacesCreate extends base_command_1.BaseCommand {
     static description = 'Create a new space';
     static examples = [
@@ -51,6 +52,11 @@ class SpacesCreate extends base_command_1.BaseCommand {
             allowNo: true,
             description: 'Inherit members/permissions from the parent chain (default). Use --no-inherit-access to make a private subspace.',
         }),
+        'working-directory': core_1.Flags.string({
+            description: "Space-level working directory for this space's local Harness runs — an absolute " +
+                "path on the executing daemon's filesystem. The middle layer of task → space → " +
+                'agent: a per-task override wins, the agent default applies when neither is set.',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -95,7 +101,18 @@ class SpacesCreate extends base_command_1.BaseCommand {
             groupChatId: flags['group-chat'],
             parentSpaceId: flags.parent,
             inheritAccess: flags['inherit-access'],
+            workingDirectory: (0, tasks_1.workingDirectoryFromFlag)(flags['working-directory']),
         });
+        // Post-merge, so --working-directory and --from-json are checked
+        // identically: a relative path is refused here rather than stored and
+        // silently fallen back from at run time on the daemon.
+        const workingDirectoryError = (0, tasks_1.workingDirectoryValidationError)(payload.workingDirectory);
+        if (workingDirectoryError) {
+            this.error(workingDirectoryError, { exit: 2 });
+        }
+        // 'none' on create means "no space default" — the field is absent anyway.
+        if (payload.workingDirectory === null)
+            delete payload.workingDirectory;
         if (!payload.title || typeof payload.title !== 'string') {
             this.error('A title is required. Pass --title "..." or include it in --from-json.', {
                 exit: 1,

package/dist/commands/spaces/show.js

@@ -57,6 +57,11 @@ class SpacesShow extends base_command_1.BaseCommand {
         this.log(`Leader:      ${s.leadAgentId ?? '-'}`);
         this.log(`Target Date: ${s.targetDate ?? '-'}`);
         this.log(`Goals:       ${Array.isArray(s.goalIds) ? s.goalIds.length : 0}`);
+        // Only when set — the space default is the middle layer of the
+        // task → space → agent cascade, and most spaces leave it unset.
+        if (typeof s.workingDirectory === 'string' && s.workingDirectory) {
+            this.log(`Directory:   ${s.workingDirectory}`);
+        }
         this.log(`Archived:    ${s.archivedAt ? 'yes' : 'no'}`);
         this.log(`Parent:      ${s.parentSpaceId ?? '(root)'}`);
         this.log(`Depth:       ${s.depth ?? 0}`);

package/dist/commands/spaces/update.d.ts

@@ -30,6 +30,7 @@ export default class SpacesUpdate extends BaseCommand {
         'auto-start-on-backlog-exit': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'triage-external-intake': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'default-task-template': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'working-directory': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/spaces/update.js

@@ -135,6 +135,12 @@ class SpacesUpdate extends base_command_1.BaseCommand {
             description: 'Default task template for new tasks in this space — a template id, reference, or ' +
                 'exact title (the server resolves it to the template). Pass "none" to clear.',
         }),
+        'working-directory': core_1.Flags.string({
+            description: "Space-level working directory for this space's local Harness runs — an absolute " +
+                "path on the executing daemon's filesystem. The middle layer of task → space → " +
+                'agent: a per-task override wins, the agent default applies when neither is set. ' +
+                'Pass "none" to clear.',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -159,11 +165,21 @@ class SpacesUpdate extends base_command_1.BaseCommand {
             autoStartOnBacklogExit: flags['auto-start-on-backlog-exit'],
             triageExternalIntake: flags['triage-external-intake'],
             defaultTaskTemplateId: clearable(flags['default-task-template']),
+            // Per-space working-directory default. 'none'/'clear'/'null' ⇒ null
+            // ($unset → resolution falls through to the agent default).
+            workingDirectory: (0, tasks_1.workingDirectoryFromFlag)(flags['working-directory']),
             estimateScale: flags['estimate-scale'],
             estimateScaleMigration: flags['estimate-migration'],
             defaultEstimate: flags['default-estimate'],
             useDefaultEstimateForUnestimated: flags['use-default-estimate'],
         });
+        // Post-merge, so --working-directory and --from-json are checked
+        // identically. A relative path stores fine and then silently falls back on
+        // the daemon at run time — refuse it here, where the mistake can be named.
+        const workingDirectoryError = (0, tasks_1.workingDirectoryValidationError)(payload.workingDirectory);
+        if (workingDirectoryError) {
+            this.error(workingDirectoryError, { exit: 2 });
+        }
         // Worktree-isolation default lives on the space's deliveryPolicy subdoc,
         // which the API replaces wholesale on update. Merge into the policy the user
         // supplied via --from-json, else the space's current policy, so setting just

package/dist/commands/tasks/create.d.ts

@@ -65,6 +65,7 @@ export default class TasksCreate extends BaseCommand {
         estimate: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         tag: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'label-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'working-directory': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         worktree: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'lifecycle-definition': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'lifecycle-version': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/create.js

@@ -226,6 +226,11 @@ class TasksCreate extends base_command_1.BaseCommand {
                 'An unknown name is refused, never created. Manage labels with `skrr labels`.',
             multiple: true,
         }),
+        'working-directory': core_1.Flags.string({
+            description: "Working directory for this task's local Harness runs — an absolute path on " +
+                "the daemon's filesystem. Overrides the agent's default; omit to inherit the " +
+                'agent default, then the daemon session default.',
+        }),
         worktree: core_1.Flags.boolean({
             allowNo: true,
             description: "Isolate this task's autonomous runs in a one-shot git worktree (--worktree), " +

package/dist/commands/tasks/show.js

@@ -402,6 +402,51 @@ class TasksShow extends base_command_1.BaseCommand {
             this.log(`Result:      ${priorLine}`);
         }
         this.log(`Executor:    ${taskExecutorLabel(t, this.config.bin)}`);
+        // Effective run directory, resolved the same way the server resolves it —
+        // most specific scope wins: task → space → agent. The daemon layers below
+        // (session.defaultCwd → --cwd) are the daemon's own and cannot be read
+        // here, so when no owned layer wins the row is omitted rather than
+        // labelled "inherited". Two extra reads, paid only when the row can say
+        // something (a detail view).
+        if (typeof t.workingDirectory === 'string' && t.workingDirectory) {
+            this.log(`Directory:   ${t.workingDirectory} (task)`);
+        }
+        else {
+            let spaceDir = null;
+            let agentDir = null;
+            if (typeof t.spaceId === 'string' && t.spaceId) {
+                try {
+                    const space = (await data_provider_1.dataService.getSpace(t.spaceId));
+                    if (typeof space?.workingDirectory === 'string' && space.workingDirectory) {
+                        spaceDir = space.workingDirectory;
+                    }
+                }
+                catch {
+                    // Unreadable space → no claim, not a wrong one.
+                }
+            }
+            if (!spaceDir) {
+                const agentRef = (typeof t.driAgentId === 'string' && t.driAgentId) ||
+                    (Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds[0] : null);
+                if (agentRef) {
+                    try {
+                        const agentRow = (await data_provider_1.dataService.getAgentById({
+                            agent_id: agentRef,
+                        }));
+                        if (typeof agentRow?.workingDirectory === 'string' && agentRow.workingDirectory) {
+                            agentDir = agentRow.workingDirectory;
+                        }
+                    }
+                    catch {
+                        // Same rule: unreadable → silence.
+                    }
+                }
+            }
+            const inheritedDir = spaceDir ?? agentDir;
+            if (inheritedDir) {
+                this.log(`Directory:   ${inheritedDir} (${spaceDir ? 'space' : 'agent'} default)`);
+            }
+        }
         this.log(`Priority:    ${t.priority ?? '-'}`);
         this.log(`Parent:      ${t.parentId ?? '-'}`);
         this.log(`Space:       ${t.spaceId ?? '-'}`);

package/dist/commands/tasks/update.d.ts

@@ -58,6 +58,7 @@ export default class TasksUpdate extends BaseCommand {
         tag: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'label-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'repair-release-pins': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'working-directory': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         worktree: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/tasks/update.js

@@ -168,6 +168,11 @@ class TasksUpdate extends base_command_1.BaseCommand {
                 'rejected with AGENT_RELEASE_PIN_STATE_INVALID: pins that govern no current ' +
                 'assignee are dropped and broken ones are re-resolved (recorded in the activity log).',
         }),
+        'working-directory': core_1.Flags.string({
+            description: "Working directory for this task's local Harness runs — an absolute path on " +
+                'the daemon\'s filesystem. Overrides the agent\'s default. Pass "none" to ' +
+                'clear back to inheriting the agent default.',
+        }),
         worktree: core_1.Flags.boolean({
             allowNo: true,
             description: "Isolate this task's autonomous runs in a git worktree (--worktree) or force " +
@@ -348,6 +353,10 @@ class TasksUpdate extends base_command_1.BaseCommand {
             // Worktree isolation override. --worktree ⇒ 'ephemeral', --no-worktree ⇒
             // 'shared', omitted ⇒ unchanged. (Clear-to-inherit via --from-json.)
             executionIsolation: (0, tasks_2.executionIsolationFromWorktreeFlag)(flags.worktree),
+            // Per-task working-directory override. --working-directory <abs path> ⇒
+            // set; "none"/"clear"/"null" ⇒ null (clears → inherit the agent
+            // default); omitted ⇒ unchanged.
+            workingDirectory: (0, tasks_2.workingDirectoryFromFlag)(flags['working-directory']),
             // A mutation option, not a field — `undefined` unless explicitly asked
             // for, so it never counts toward the "nothing to update" check below.
             repairReleasePins: flags['repair-release-pins'] ? true : undefined,
@@ -361,6 +370,18 @@ class TasksUpdate extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        // Post-merge, so flag and --from-json inputs are checked identically. A
+        // relative path stores fine and then silently falls back at run time —
+        // refuse it here, where the mistake can still be named.
+        const workingDirectoryError = (0, tasks_2.workingDirectoryValidationError)(payload.workingDirectory);
+        if (workingDirectoryError) {
+            this.failWithCliError({
+                message: workingDirectoryError,
+                code: 'INVALID_TASK_WORKING_DIRECTORY',
+                exit: 2,
+                retryable: false,
+            });
+        }
         if (payloadKeys.length === 0) {
             this.failWithCliError({
                 message: 'Nothing to update. Pass at least one flag (e.g. --title) or --from-json.',

package/dist/commands/tasks/upsert.d.ts

@@ -20,6 +20,7 @@ export default class TasksUpsert extends BaseCommand {
         'assignee-user': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'execution-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'due-date': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'working-directory': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         tag: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/tasks/upsert.js

@@ -57,6 +57,10 @@ class TasksUpsert extends base_command_1.BaseCommand {
             options: ['agent', 'human'],
         }),
         'due-date': core_1.Flags.string({ description: 'Due date (ISO string)' }),
+        'working-directory': core_1.Flags.string({
+            description: "Working directory for this task's local Harness runs — an absolute path on " +
+                'the daemon\'s filesystem. Pass "none" to clear an existing override.',
+        }),
         tag: core_1.Flags.string({ description: 'Replace/create tag (repeatable)', multiple: true }),
     };
     async run() {
@@ -75,6 +79,18 @@ class TasksUpsert extends base_command_1.BaseCommand {
             });
         }
         const payload = (0, tasks_1.buildTaskCreatePayload)(body, flags);
+        // Checked here, not inside validateTaskCreatePayload's create-leg call —
+        // an upsert that resolves to UPDATE never reaches that validator, and a
+        // relative path would silently no-op at run time on the daemon.
+        const workingDirectoryError = (0, tasks_1.workingDirectoryValidationError)(payload.workingDirectory);
+        if (workingDirectoryError) {
+            this.failWithCliError({
+                message: workingDirectoryError,
+                code: 'INVALID_TASK_WORKING_DIRECTORY',
+                exit: 2,
+                retryable: false,
+            });
+        }
         let scope;
         try {
             scope = await (0, tasks_1.resolveTaskCreateScope)(payload);

package/dist/lib/agentic-stream.d.ts

@@ -94,6 +94,20 @@ export type AgenticStreamOptions = {
     /** How long to keep trying to attach before reporting a detach. Default 30s. */
     attachTimeoutMs?: number;
 };
+/**
+ * What a permission request would DO, in one line a person can judge.
+ *
+ * The prompt used to be `Allow tool <name>?` and nothing else, so a shell
+ * approval read "Allow tool unknown? [y/N]" and a person approved a command
+ * they never saw (OSK-12119). The command, or else the path, or else the
+ * arguments, is the part that decides the answer.
+ *
+ * The text is chosen by the agent and printed to a terminal, so control
+ * characters are escaped: an embedded carriage return or escape sequence could
+ * otherwise redraw the line and show the person a different command than the
+ * one they are approving.
+ */
+export declare function describePermissionTarget(toolInput: unknown): string | null;
 /**
  * Small Node-side adapter for the existing Agentic Socket.IO contract.
  * It deliberately normalizes only lifecycle/text/tool events; the server's
@@ -159,6 +173,25 @@ export type ProjectedToolEvent = {
  * of the run. The pairing is unambiguous within a turn.
  */
 export declare function projectDaemonToolEvents(envelopes: unknown[], namesByCall: Map<string, string>): ProjectedToolEvent[];
+/**
+ * WHO or WHAT decided a permission request, as a reader needs it (OSK-12113).
+ *
+ * `by` names the surface or fallback that resolved the ask and is a closed wire
+ * enum; `basis` beside it says what decided. The distinction is the finding: an
+ * edit acceptEdits applied on its own was recorded `by: "cli"`, which read as
+ * the CLI user having approved something nobody was asked about.
+ */
+export declare function describePermissionDecider(ev: {
+    by?: unknown;
+    basis?: unknown;
+    mode?: unknown;
+    surface?: unknown;
+}): string;
+/**
+ * Daemon `permission-resolved` envelopes as `permission.resolved` events, named
+ * by the tool their `permission-ask` announced and carrying who decided.
+ */
+export declare function projectPermissionResolutions(envelopes: unknown[], toolsByRequest: Map<string, string>): AgenticStreamEvent[];
 /**
  * The part of a cumulative snapshot that has not been shown yet.
  *
@@ -262,8 +295,32 @@ export type SeqGap = {
     from: number;
     to: number;
 };
+/**
+ * `service` envelopes that carry a `notice` — words for the person, not
+ * diagnostics — projected as `session.notice` events. Today the only notice is
+ * `harness-session-reset`: the local harness could not resume its previous
+ * session and began a new one, so its local working context is gone.
+ */
+export declare function projectSessionNotices(envelopes: unknown[]): AgenticStreamEvent[];
 export declare function detectSeqGap(highestApplied: number, incoming: number): SeqGap | null;
-export declare function seqGapNotice(gap: SeqGap): string;
+/**
+ * The notice a reader sees when chunks went missing.
+ *
+ * It names `run.result` only when this client will actually fill `run.result`
+ * from the persisted message (`recordBackfill`). The sentence used to promise
+ * it unconditionally, while `run.result.text` was folded from the envelopes
+ * that DID arrive — so the one run told to trust `run.result` was the run whose
+ * `run.result.text` was empty, with the answer only in the record (OSK-12132).
+ */
+export declare function seqGapNotice(gap: SeqGap, options?: {
+    recordBackfill?: boolean;
+}): string;
+/**
+ * The permission mode a `run.started` reports, and where it came from
+ * (OSK-12089). `null` when the event carries no mode report at all — a cloud
+ * turn from an older server, say — so nothing is claimed.
+ */
+export declare function describeRunPermission(event: AgenticStreamEvent): string | null;
 export declare class AgenticStreamClient {
     private readonly options;
     private socket;
@@ -291,6 +348,8 @@ export declare class AgenticStreamClient {
     private readonly seenLifecycle;
     /** `call` → tool name, so a daemon `tool-call-end` can be named (OSK-7730). */
     private readonly toolNamesByCall;
+    /** `permission-ask` requestId → tool name, to name its resolution (OSK-12113). */
+    private readonly toolNamesByPermission;
     /** Text already written to the terminal, for suffix-only rendering. */
     private renderedText;
     private idleTimer;
@@ -372,6 +431,14 @@ export declare class AgenticStreamClient {
     private emitToolEvent;
     private emit;
     private finish;
+    /**
+     * The answer as the durable record holds it, for a run whose stream had a
+     * hole. Bounded: the record is written before the terminal event is sent, so
+     * it is normally there at once, and a record that stays silent must not hold
+     * the run open — the reader then gets what the stream delivered.
+     */
+    private readRecordedText;
+    private settle;
     /**
      * OSK-2944 — a transient connect failure must not end an ACCEPTED run.
      *