@skrr-ai/cli 0.1.118 → 0.1.120

package/dist/commands/tasks/runs.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatRunExecutor = formatRunExecutor;
+exports.formatRunAttempt = formatRunAttempt;
+exports.formatRunAttemptState = formatRunAttemptState;
+exports.formatRunSettlement = formatRunSettlement;
+exports.formatRunCleanup = formatRunCleanup;
 exports.runNeedsFailureReason = runNeedsFailureReason;
 exports.runHandoverMarker = runHandoverMarker;
 exports.failureFromRun = failureFromRun;
@@ -33,6 +37,83 @@ function formatRunExecutor(run) {
     }
     return '-';
 }
+/**
+ * The executor attempt is the recovery fence, not a coordinator or terminal
+ * identity.  Keep it in the Task run listing because it lets a person tell a
+ * current retry from an old report without requiring them to discover an
+ * executor-specific UI.
+ */
+function formatRunAttempt(ref) {
+    if (!ref || typeof ref !== 'object' || Array.isArray(ref))
+        return null;
+    const attempt = ref;
+    const kind = typeof attempt.kind === 'string' && attempt.kind.trim() ? attempt.kind : null;
+    const runId = typeof attempt.runId === 'string' && attempt.runId.trim() ? attempt.runId : null;
+    const number = typeof attempt.attempt === 'number' &&
+        Number.isSafeInteger(attempt.attempt) &&
+        attempt.attempt >= 0
+        ? String(attempt.attempt)
+        : null;
+    const generation = typeof attempt.generation === 'number' &&
+        Number.isSafeInteger(attempt.generation) &&
+        attempt.generation >= 0
+        ? String(attempt.generation)
+        : null;
+    const identity = [kind, runId].filter(Boolean).join(':');
+    const counters = [number ? `attempt ${number}` : null, generation ? `generation ${generation}` : null]
+        .filter(Boolean)
+        .join(', ');
+    return [identity || null, counters || null].filter(Boolean).join(' · ') || null;
+}
+/** The latest exact attempt is enough for a compact historical row. */
+function formatRunAttemptState(run) {
+    const terminal = formatRunAttempt(run.terminalExecutorAttemptRef);
+    const active = formatRunAttempt(run.activeExecutorAttemptRef);
+    if (terminal && active && terminal !== active)
+        return `active ${active} → terminal ${terminal}`;
+    if (terminal)
+        return `terminal ${terminal}`;
+    if (active)
+        return `active ${active}`;
+    return null;
+}
+/**
+ * A terminal report, Task finalization and resource cleanup are deliberately
+ * separate receipts. This compact text preserves that order instead of calling
+ * any one of them "done" for the whole Task.
+ */
+function formatRunSettlement(run) {
+    const terminal = run.terminalReport;
+    const finalization = run.finalization;
+    const facts = [];
+    if (terminal?.state === 'accepted') {
+        facts.push(`terminal accepted${typeof terminal.outcome === 'string' ? ` (${terminal.outcome})` : ''}`);
+    }
+    if (finalization?.pending === true || finalization?.projected === false) {
+        facts.push('finalization pending');
+    }
+    else if (finalization?.projected === true) {
+        facts.push('finalized');
+    }
+    return facts.length ? facts.join(' · ') : null;
+}
+/**
+ * The public cleanup projection intentionally excludes reservation/fence
+ * coordinates. It is diagnostic evidence only; it never grants a CLI caller a
+ * release operation.
+ */
+function formatRunCleanup(run) {
+    const cleanup = run.cleanup;
+    const lease = cleanup?.capacityReservation;
+    if (!lease || typeof lease.state !== 'string' || !lease.state)
+        return null;
+    const reason = typeof lease.unknownReason === 'string' && lease.unknownReason
+        ? lease.unknownReason
+        : typeof lease.reason === 'string' && lease.reason
+            ? lease.reason
+            : null;
+    return `capacity ${lease.state}${reason ? ` (${reason})` : ''}`;
+}
 /**
  * Whether this run row is one whose reason the caller cannot see. (S3 dogfood finding)
  *
@@ -193,6 +274,12 @@ class TasksRuns extends base_command_1.BaseCommand {
         // The column exists only when a run carries a handover field — an older
         // deployment sends neither, and an always-on column of '-' is noise.
         const showHandover = markers.some(Boolean);
+        const attempts = items.map(formatRunAttemptState);
+        const settlements = items.map(formatRunSettlement);
+        const cleanups = items.map(formatRunCleanup);
+        const showAttempt = attempts.some(Boolean);
+        const showSettlement = settlements.some(Boolean);
+        const showCleanup = cleanups.some(Boolean);
         const rows = items.map((run, i) => ({
             runId: String(run.runId ?? run.id ?? run._id ?? '-'),
             status: String(run.status ?? '-'),
@@ -203,6 +290,9 @@ class TasksRuns extends base_command_1.BaseCommand {
             // Always present on the row so the record type stays uniform; the COLUMN
             // is what is conditional.
             handover: markers[i] ?? '-',
+            attempt: attempts[i] ?? '-',
+            settlement: settlements[i] ?? '-',
+            cleanup: cleanups[i] ?? '-',
         }));
         (0, format_1.renderTable)(rows, [
             { key: 'runId', header: 'RUN ID' },
@@ -211,6 +301,11 @@ class TasksRuns extends base_command_1.BaseCommand {
             { key: 'started', header: 'STARTED' },
             { key: 'duration', header: 'DURATION' },
             { key: 'tokens', header: 'TOKENS' },
+            ...(showAttempt ? [{ key: 'attempt', header: 'ATTEMPT', maxWidth: 48 }] : []),
+            ...(showSettlement
+                ? [{ key: 'settlement', header: 'SETTLEMENT', maxWidth: 42 }]
+                : []),
+            ...(showCleanup ? [{ key: 'cleanup', header: 'CLEANUP', maxWidth: 42 }] : []),
             ...(showHandover ? [{ key: 'handover', header: 'HANDOVER' }] : []),
         ], (line) => this.log(line));
         // Only once something failed: a healthy list pays nothing for this.

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

@@ -117,6 +117,8 @@ export default class TasksShow extends BaseCommand {
         id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        fields: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        compact: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         task: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'no-enrich': import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/tasks/show.js

@@ -23,6 +23,7 @@ const principal_display_1 = require("../../lib/principal-display");
 const task_economics_line_1 = require("../../lib/task-economics-line");
 const format_1 = require("../../lib/format");
 const task_recurrence_outcome_1 = require("../../lib/task-recurrence-outcome");
+const record_output_1 = require("../../lib/record-output");
 /**
  * Where to look next — as COMMANDS, not as facts about the task.
  *
@@ -282,6 +283,8 @@ class TasksShow extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks show',
         '<%= config.bin %> tasks show --task <task-id> --json',
         '<%= config.bin %> tasks show <task-id> --json',
+        '<%= config.bin %> tasks show <task-id> --compact --json',
+        '<%= config.bin %> tasks show <task-id> --fields id,ref,title,status --json',
         '<%= config.bin %> tasks show <task-id> --no-enrich',
     ];
     static args = {
@@ -303,6 +306,7 @@ class TasksShow extends base_command_1.BaseCommand {
             description: 'How to read the description. html (default) is what is stored; markdown returns it as it was written.',
             options: ['html', 'markdown'],
         }),
+        ...record_output_1.recordOutputFlags,
     };
     async run() {
         this.requireAuth();
@@ -393,9 +397,19 @@ class TasksShow extends base_command_1.BaseCommand {
             completionRead = false;
         }
         if (flags.json) {
-            this.printJsonResult({ ...t, url, completion });
+            // `ref` is the stable copy/paste alias list output already exposes. A
+            // detail record normalizes it before any projection so callers may use
+            // `--fields ref` consistently across `tasks list` and `tasks show`.
+            const ref = (typeof t.ref === 'string' && t.ref) ||
+                (typeof t.identifier === 'string' && t.identifier) ||
+                (typeof t.taskNumber === 'number' || typeof t.taskNumber === 'string'
+                    ? `#${t.taskNumber}`
+                    : undefined);
+            this.printJsonResult((0, record_output_1.shapeRecordResponse)({ ...t, ...(ref ? { ref } : {}), ...(url ? { url } : {}), completion }, { resource: 'task', fields: flags.fields, compact: flags.compact }));
             return;
         }
+        for (const line of (0, record_output_1.textModeRecordProjectionNotes)(flags))
+            this.log(line);
         for (const line of completionLines(completion, { read: completionRead }))
             this.log(line);
         const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds : [];

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;
 }