@skrr-ai/cli 0.1.119 → 0.1.120

package/dist/commands/tasks/start-receipt.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+/** Read-only recovery for one caller-owned task-start request. */
+export default class TasksStartReceipt extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/start-receipt.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const task_resolver_1 = require("../../lib/task-resolver");
+/** Read-only recovery for one caller-owned task-start request. */
+class TasksStartReceipt extends base_command_1.BaseCommand {
+    static description = 'Read the durable receipt for one task-start request without starting another run.';
+    static examples = [
+        '<%= config.bin %> tasks start-receipt <task-id> --request-id task-start:deploy-42',
+        '<%= config.bin %> tasks start-receipt <task-id> --request-id task-start:deploy-42 --json',
+    ];
+    static args = {
+        id: core_1.Args.string({
+            description: 'Task ID; defaults to OVERSKY_SESSION_TASK_ID in task runtimes',
+            required: false,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        task: core_1.Flags.string({ description: 'Task ID; overrides daemon runtime context' }),
+        'request-id': core_1.Flags.string({
+            description: 'The request id printed by tasks start',
+            required: true,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksStartReceipt);
+        let taskIdentity;
+        try {
+            taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        }
+        catch (err) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(err);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+                details: { suggestion: failure.suggestion, context: failure.details },
+            });
+        }
+        // `resolveTaskIdentity` decides which INPUT wins; it does no lookup. This
+        // turns whatever it picked into something the API can resolve — a UUID and
+        // an OSK-2423 ref pass through untouched, a title is searched.
+        const taskId = await this.resolveTaskReference(taskIdentity.id);
+        // The CLI may compile against a published data-provider declaration that
+        // predates this additive reader; use the runtime surface just as `start`
+        // does for its newer options.
+        const getTaskStartReceipt = data_provider_1.dataService
+            .getTaskStartReceipt;
+        let receipt;
+        try {
+            receipt = await getTaskStartReceipt(taskId, flags['request-id']);
+        }
+        catch (err) {
+            this.handleApiError(err, { subject: `Task ${taskId} start receipt` });
+        }
+        if (flags.json) {
+            this.printJsonResult(receipt);
+            return;
+        }
+        if (receipt.state === 'accepted') {
+            this.log(`Start request ${receipt.requestId} has an accepted server response.`);
+            if (receipt.responseStatus !== undefined)
+                this.log(`Response status: ${receipt.responseStatus}`);
+            if (receipt.run?.runId)
+                this.log(`Run: ${receipt.run.runId}`);
+            if (receipt.run?.autonomousRunId)
+                this.log(`Autonomous Run: ${receipt.run.autonomousRunId}`);
+            if (receipt.run?.conversationId)
+                this.log(`Conversation: ${receipt.run.conversationId}`);
+            if (receipt.run?.sessionId)
+                this.log(`Session: ${receipt.run.sessionId}`);
+            if (receipt.run?.responseMessageId) {
+                this.log(`Response message: ${receipt.run.responseMessageId}`);
+            }
+            if (receipt.code)
+                this.log(`Response code: ${receipt.code}`);
+            this.log('This receipt does not prove target acquisition, harness activity, or a terminal Task outcome.');
+            return;
+        }
+        if (receipt.state === 'pending') {
+            this.log(`Start request ${receipt.requestId} is pending; its outcome is not recorded yet.`);
+            this.log('Do not issue a fresh start. Wait for the original request or retry this exact request id.');
+            return;
+        }
+        this.log(`No task-scoped receipt exists for start request ${receipt.requestId}.`);
+        this.log(`That is not proof the start did not happen. Inspect: ${this.config.bin} tasks execution-state ${taskId}`);
+    }
+}
+exports.default = TasksStartReceipt;

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

@@ -11,7 +11,9 @@ export default class TasksStart extends BaseCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         skill: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        capability: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         branch: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'request-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }
@@ -25,6 +27,8 @@ export declare function waitingForMachine(err: unknown): {
     reason?: string;
     retryable?: boolean;
 } | null;
+/** The next safe action when admission is retained but its machine is waking. */
+export declare function waitingForMachineFollowUpLine(bin: string, taskRef: string): string;
 /**
  * What to run next, printed after a start (OSK-12128). A start used to print
  * two ids and stop, and the way to watch it was found by accident. Every

package/dist/commands/tasks/start.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitingForMachine = waitingForMachine;
+exports.waitingForMachineFollowUpLine = waitingForMachineFollowUpLine;
 exports.startFollowUpLines = startFollowUpLines;
 const core_1 = require("@oclif/core");
+const node_crypto_1 = require("node:crypto");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const task_resolver_1 = require("../../lib/task-resolver");
 const git_task_1 = require("../../lib/git-task");
 const task_admission_1 = require("../../lib/task-admission");
+const TASK_START_REQUEST_ID_PATTERN = /^[A-Za-z0-9._:/-]{1,200}$/;
 class TasksStart extends base_command_1.BaseCommand {
     static description = 'Start execution of a task: its assignee agent runs it in a new conversation + session. ' +
         'Alias: tasks execute';
@@ -19,9 +22,11 @@ class TasksStart extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks start',
         '<%= config.bin %> tasks start --task <task-id> --json',
         '<%= config.bin %> tasks start <task-id> --skill <skill-id>',
+        '<%= config.bin %> tasks start <task-id> --capability shell --capability codex_session',
         '<%= config.bin %> tasks start OSK-123 --branch',
         '<%= config.bin %> tasks start <task-id> --json',
         '<%= config.bin %> tasks start <task-id> --dry-run --json',
+        '<%= config.bin %> tasks start <task-id> --request-id task-start:deploy-42',
     ];
     static args = {
         id: core_1.Args.string({
@@ -39,9 +44,16 @@ class TasksStart extends base_command_1.BaseCommand {
         skill: core_1.Flags.string({
             description: "Skill ID to inject into the run. Must be pinned to the task's space (server rejects unknown skills with 4xx).",
         }),
+        capability: core_1.Flags.string({
+            multiple: true,
+            description: 'Capability required of the selected execution target. Repeat for every required capability.',
+        }),
         branch: core_1.Flags.boolean({
             description: 'Create or check out the local oversky/task/<ref> branch before starting the task.',
         }),
+        'request-id': core_1.Flags.string({
+            description: 'Stable idempotency key for this logical start. Reuse it after a lost response; inspect it with tasks start-receipt.',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -60,6 +72,10 @@ class TasksStart extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        if (flags['request-id'] !== undefined &&
+            !TASK_START_REQUEST_ID_PATTERN.test(flags['request-id'])) {
+            this.error('--request-id must be 1-200 characters of letters, digits and . _ : / - (it is sent as an idempotency key).', { exit: 2 });
+        }
         if (flags['dry-run']) {
             if (flags.branch)
                 this.error('--dry-run cannot check out a branch; omit --branch.', { exit: 2 });
@@ -67,7 +83,11 @@ class TasksStart extends base_command_1.BaseCommand {
             try {
                 // A separate route is intentional: an older /start silently ignores
                 // unknown request fields. A dryRun flag there could start real work.
-                preview = await data_provider_1.dataService.previewTaskStart(taskIdentity.id, flags.skill ? { skillId: flags.skill } : undefined);
+                const previewOptions = {
+                    ...(flags.skill ? { skillId: flags.skill } : {}),
+                    ...(flags.capability?.length ? { requestedCapabilities: flags.capability } : {}),
+                };
+                preview = await data_provider_1.dataService.previewTaskStart(taskIdentity.id, Object.keys(previewOptions).length ? previewOptions : undefined);
             }
             catch (err) {
                 this.handleApiError(err, { subject: `Task ${taskIdentity.id} execution preview` });
@@ -96,6 +116,10 @@ class TasksStart extends base_command_1.BaseCommand {
         const taskId = flags.branch
             ? await this.resolveTaskReference(taskIdentity.id)
             : taskIdentity.id;
+        // Task starts can allocate a Run. The CLI owns one request id per invocation
+        // and prints it, so a caller who loses the response can inspect or replay
+        // this exact request instead of guessing whether another start is safe.
+        const requestId = flags['request-id'] || `task-start:${(0, node_crypto_1.randomUUID)()}`;
         let branch;
         if (flags.branch) {
             try {
@@ -125,7 +149,11 @@ class TasksStart extends base_command_1.BaseCommand {
         }
         let result;
         try {
-            result = await data_provider_1.dataService.startTask(taskId, flags.skill ? { skillId: flags.skill } : undefined);
+            result = await data_provider_1.dataService.startTask(taskId, {
+                ...(flags.skill ? { skillId: flags.skill } : {}),
+                ...(flags.capability?.length ? { requestedCapabilities: flags.capability } : {}),
+                requestId,
+            });
         }
         catch (err) {
             // A stopped Dedicated machine is being started for this work. That is the
@@ -139,6 +167,7 @@ class TasksStart extends base_command_1.BaseCommand {
                         code: 'TASK_WAITING_FOR_MACHINE',
                         taskId,
                         task: { ...taskIdentity, id: taskId },
+                        requestId,
                         ...(branch ? { branch } : {}),
                         ...waiting,
                     }, null, 2));
@@ -148,8 +177,11 @@ class TasksStart extends base_command_1.BaseCommand {
                     this.log(`${branch.created ? 'Created' : 'Checked out'} branch: ${branch.branch}`);
                 }
                 this.log(`Task ${taskIdentity.id} is waiting for the machine to start; the task will run by itself once it is ready.`);
+                this.log(`Start request: ${requestId}`);
+                this.log(`Inspect request receipt: ${this.config.bin} tasks start-receipt ${taskIdentity.id} --request-id ${requestId}`);
                 if (waiting.message)
                     this.log(waiting.message);
+                this.log(waitingForMachineFollowUpLine(this.config.bin, taskIdentity.id));
                 return;
             }
             // Name the task in the failure. `skrr tasks start` is the command people
@@ -159,21 +191,30 @@ class TasksStart extends base_command_1.BaseCommand {
             this.handleApiError(err, { subject: `Task ${taskIdentity.id}` });
         }
         if (flags.json) {
+            const receipt = result.receipt || { requestId, state: 'accepted' };
             this.log(JSON.stringify({
                 ...result,
+                receipt,
                 taskId,
                 task: { ...taskIdentity, id: taskId },
                 ...(branch ? { branch } : {}),
             }, null, 2));
             return;
         }
-        this.log(`Started task ${taskId}${flags.skill ? ` with skill ${flags.skill}` : ''}`);
+        this.log(`Accepted start request for task ${taskId}${flags.skill ? ` with skill ${flags.skill}` : ''}`);
+        this.log(`Start receipt: ${result.receipt?.requestId || requestId}`);
         if (branch)
             this.log(`${branch.created ? 'Created' : 'Checked out'} branch: ${branch.branch}`);
         for (const line of (0, task_admission_1.admissionLines)(result.executionAdmission))
             this.log(line);
+        if (result.runId)
+            this.log(`Run:          ${result.runId}`);
+        if (result.autonomousRunId)
+            this.log(`Autonomous Run: ${result.autonomousRunId}`);
         this.log(`Conversation: ${result.conversationId}`);
         this.log(`Session:      ${result.sessionId}`);
+        if (result.responseMessageId)
+            this.log(`Response message: ${result.responseMessageId}`);
         for (const line of startFollowUpLines(this.config.bin, taskIdentity.id))
             this.log(line);
     }
@@ -213,6 +254,10 @@ function waitingForMachine(err) {
         ...(typeof body.retryable === 'boolean' ? { retryable: body.retryable } : {}),
     };
 }
+/** The next safe action when admission is retained but its machine is waking. */
+function waitingForMachineFollowUpLine(bin, taskRef) {
+    return `Inspect recovery: ${bin} tasks execution-state ${taskRef}`;
+}
 /**
  * What to run next, printed after a start (OSK-12128). A start used to print
  * two ids and stop, and the way to watch it was found by accident. Every
@@ -230,6 +275,7 @@ function startFollowUpLines(bin, taskRef) {
         '',
         'Follow it:',
         `  ${bin} tasks watch ${taskRef}            status until it finishes or fails`,
+        `  ${bin} tasks execution-state ${taskRef}  exact run, current attempt, wait and recovery state`,
         `  ${bin} tasks transcript ${taskRef}       what the agent has said so far`,
         `  ${bin} tasks approvals list ${taskRef}   approvals waiting on you, or why a run is blocked on one`,
         'On a local machine, the run may add its instruction file (AGENTS.md / CLAUDE.md) to the',

package/dist/commands/tasks/update.js

@@ -543,6 +543,9 @@ class TasksUpdate extends base_command_1.BaseCommand {
             }
             this.handleApiError(err);
         }
+        // Held for approval by the Space write policy: nothing was changed.
+        if (this.reportHeldSpaceWrite(updated, { json: flags.json }))
+            return;
         // Postcondition, not a prediction — see `droppedEstimateWarning`. On stderr
         // so `--json` stdout stays a parseable task row.
         const estimateWarning = (0, create_1.droppedEstimateWarning)(flags.estimate, updated, updated?.spaceId);

package/dist/commands/tasks/upsert.js

@@ -25,7 +25,10 @@ class TasksUpsert extends base_command_1.BaseCommand {
         'default-agent': core_1.Flags.string({
             description: 'Override the automatic assignee for creates, or fill an unassigned existing match. Use "auto" to inherit the space lead agent.',
         }),
-        unassigned: core_1.Flags.boolean({ description: 'Explicitly clear both assignee kinds, suppressing automatic defaults while retaining executor intent.', exclusive: ['default-agent', 'assignee-agent', 'assignee-user'] }),
+        unassigned: core_1.Flags.boolean({
+            description: 'Explicitly clear both assignee kinds, suppressing automatic defaults while retaining executor intent.',
+            exclusive: ['default-agent', 'assignee-agent', 'assignee-user'],
+        }),
         title: core_1.Flags.string({ description: 'Task title (required when creating)' }),
         description: core_1.Flags.string({ description: 'Task description' }),
         'description-format': core_1.Flags.string({
@@ -70,7 +73,12 @@ class TasksUpsert extends base_command_1.BaseCommand {
         this.setJsonOperation({ command: 'tasks:upsert', mode: 'execute' });
         const unassignmentError = (0, tasks_1.taskUnassignmentFlagError)(flags);
         if (unassignmentError)
-            this.failWithCliError({ message: unassignmentError, code: 'TASK_UNASSIGNED_CONFLICT', exit: 2, retryable: false });
+            this.failWithCliError({
+                message: unassignmentError,
+                code: 'TASK_UNASSIGNED_CONFLICT',
+                exit: 2,
+                retryable: false,
+            });
         let body = {};
         try {
             body = await (0, prompt_1.readJsonBody)(flags['from-json']);
@@ -219,6 +227,9 @@ class TasksUpsert extends base_command_1.BaseCommand {
                 this.handleApiError(err);
             }
         }
+        // Held for approval by the Space write policy: nothing was written.
+        if (this.reportHeldSpaceWrite(task, { json: flags.json }))
+            return;
         const result = {
             object: 'task_upsert',
             action,
@@ -229,7 +240,10 @@ class TasksUpsert extends base_command_1.BaseCommand {
             url: (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, task),
         };
         if (flags.json) {
-            this.printJsonOperation(result, { resource: { kind: 'task', id: task?.id }, task: { id: task?.id } });
+            this.printJsonOperation(result, {
+                resource: { kind: 'task', id: task?.id },
+                task: { id: task?.id },
+            });
             return;
         }
         this.log(`${capitalize(action)} task ${(0, tasks_1.formatTaskLabel)(task)}`);

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

@@ -13,7 +13,10 @@ export default class TasksWatch extends BaseCommand {
         interval: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         timeout: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        operation: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private watchOperation;
+    private printOperationCheckpoint;
     private printSnapshot;
 }

package/dist/commands/tasks/watch.js

@@ -4,12 +4,15 @@ const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
 const task_execution_1 = require("../../lib/task-execution");
+const task_operation_watch_1 = require("../../lib/task-operation-watch");
+const data_provider_1 = require("@skrr-ai/data-provider");
 class TasksWatch extends base_command_1.BaseCommand {
-    static description = 'Watch task execution status until completion or failure';
+    static description = 'Watch task execution status, or one immutable Task Operation, without dispatching work';
     static examples = [
         '<%= config.bin %> tasks watch <task-id>',
         '<%= config.bin %> tasks watch <root-task-id> --descendants',
         '<%= config.bin %> tasks watch <root-task-id> --descendants --json',
+        '<%= config.bin %> tasks watch <task-id> --operation <operation-id> --timeout 10m',
     ];
     static args = {
         id: core_1.Args.string({ description: 'Task or root task ID', required: true, ignoreStdin: true }),
@@ -27,14 +30,27 @@ class TasksWatch extends base_command_1.BaseCommand {
         interval: core_1.Flags.integer({ description: 'Polling interval in seconds', default: 5 }),
         timeout: core_1.Flags.string({ description: 'Timeout such as 30s, 10m, 2h' }),
         limit: core_1.Flags.integer({ description: 'Max descendants to inspect', default: 500 }),
+        operation: core_1.Flags.string({
+            description: 'Watch this immutable Task Operation rather than inferring completion from Task workflow status',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksWatch);
+        if (flags.operation) {
+            if (flags.descendants ||
+                flags['children-only'] ||
+                (flags['fail-on'] !== undefined && flags['fail-on'] !== task_execution_1.DEFAULT_FAIL_STATUSES_FLAG) ||
+                (flags.limit !== undefined && flags.limit !== 500)) {
+                this.error('--operation cannot be combined with --descendants, --children-only, --fail-on, or --limit. It watches one immutable operation, not a Task tree.', { exit: 2 });
+            }
+            await this.watchOperation(args.id, flags.operation, flags);
+            return;
+        }
         const failOn = (0, task_execution_1.parseStatusSet)(flags['fail-on'], task_execution_1.DEFAULT_FAIL_STATUSES);
         let timeoutMs = null;
         try {
-            timeoutMs = parseDurationMs(flags.timeout);
+            timeoutMs = (0, task_operation_watch_1.parseTaskOperationWatchDuration)(flags.timeout);
         }
         catch (err) {
             this.error(err.message, { exit: 1 });
@@ -76,6 +92,73 @@ class TasksWatch extends base_command_1.BaseCommand {
             await (0, task_execution_1.sleep)(intervalMs);
         }
     }
+    async watchOperation(taskRef, operationId, flags) {
+        const taskId = await this.resolveTaskReference(taskRef);
+        const canonicalOperationId = operationId.trim();
+        if (!canonicalOperationId || canonicalOperationId.length > 200) {
+            this.error('--operation must be a non-empty operation ID of at most 200 characters.', { exit: 2 });
+            return;
+        }
+        let timeoutMs;
+        try {
+            timeoutMs = (0, task_operation_watch_1.parseTaskOperationWatchDuration)(flags.timeout);
+        }
+        catch (error) {
+            this.error(error.message, { exit: 2 });
+            return;
+        }
+        const intervalMs = Math.max(1, flags.interval) * 1000;
+        const getTaskOperation = data_provider_1.dataService.getTaskOperation;
+        if (!getTaskOperation) {
+            this.failWithCliError({
+                code: 'TASK_OPERATION_READER_UNAVAILABLE',
+                message: 'This CLI build cannot read Task Operations. Update skrr before waiting on this operation.',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        try {
+            const result = await (0, task_operation_watch_1.watchTaskOperation)({
+                taskId,
+                operationId: canonicalOperationId,
+                intervalMs,
+                timeoutMs,
+                read: getTaskOperation,
+                onCheckpoint: (checkpoint) => this.printOperationCheckpoint(checkpoint, Boolean(flags.json)),
+            });
+            if (result.result === 'failed')
+                this.exit(1);
+        }
+        catch (error) {
+            const candidate = error;
+            if (candidate?.code === 'TASK_OPERATION_WAIT_TIMEOUT') {
+                this.exit(124);
+                return;
+            }
+            if (candidate?.code === 'TASK_OPERATION_TERMINAL_UNKNOWN') {
+                this.failWithCliError({
+                    code: 'TASK_OPERATION_TERMINAL_UNKNOWN',
+                    message: 'The Task Operation is terminal but does not report a recognized outcome. Inspect it; do not issue a fresh operation by guesswork.',
+                    exit: 2,
+                    retryable: false,
+                    details: { operationId: canonicalOperationId, taskId },
+                });
+                return;
+            }
+            this.handleApiError(error, { subject: `Task operation ${canonicalOperationId}` });
+        }
+    }
+    printOperationCheckpoint(checkpoint, json) {
+        if (json) {
+            this.log(JSON.stringify(checkpoint));
+            return;
+        }
+        // A text stream stays calm between changes; JSON preserves every polling
+        // checkpoint so automation can distinguish a live wait from silence.
+        if (checkpoint.changed || checkpoint.terminal || checkpoint.observation === 'timeout') {
+            this.log((0, task_operation_watch_1.taskOperationCheckpointLine)(checkpoint));
+        }
+    }
     printSnapshot(snapshot) {
         this.log('');
         this.log(`[${snapshot.generatedAt}] tasks=${snapshot.taskCount} active=${snapshot.activeCount} recovered=${snapshot.recoveredCount} terminal=${snapshot.terminalCount} pending=${snapshot.pendingCount}`);
@@ -101,21 +184,3 @@ class TasksWatch extends base_command_1.BaseCommand {
     }
 }
 exports.default = TasksWatch;
-function parseDurationMs(value) {
-    if (!value)
-        return null;
-    const match = value.trim().match(/^(\d+)(ms|s|m|h)?$/i);
-    if (!match)
-        throw new Error(`Invalid --timeout value: ${value}`);
-    const amount = Number(match[1]);
-    const unit = (match[2] || 's').toLowerCase();
-    if (unit === 'ms')
-        return amount;
-    if (unit === 's')
-        return amount * 1000;
-    if (unit === 'm')
-        return amount * 60 * 1000;
-    if (unit === 'h')
-        return amount * 60 * 60 * 1000;
-    return amount * 1000;
-}

package/dist/commands/wiki/history.d.ts

@@ -0,0 +1,33 @@
+import type { WikiPageAuthor, WikiPageRevision } from '@skrr-ai/data-provider';
+import { BaseCommand } from '../../base-command';
+/**
+ * `agent <id>` for a write a verified Run proved; otherwise the person whose
+ * credential wrote it, with the channel it came through — so an agent working
+ * through a delegated CLI credential without Run proof reads as
+ * "person <id> (via delegated agent CLI credential)", never as a bare person.
+ */
+export declare function formatAuthor(author: WikiPageAuthor | undefined): string;
+export declare function buildHistoryRows(revisions: WikiPageRevision[]): {
+    rev: string;
+    when: string;
+    author: string;
+    also: string;
+    source: string;
+    chars: string;
+}[];
+export default class WikiHistory extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        space: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'page-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        cursor: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        revision: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}