@skrr-ai/cli 0.1.110 → 0.1.111

package/dist/commands/tasks/list.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.agentSessionOpenDefault = agentSessionOpenDefault;
 exports.emptyTasksMessage = emptyTasksMessage;
+exports.externalKeyPrefixWarnings = externalKeyPrefixWarnings;
 exports.nextActionText = nextActionText;
 exports.nextColumnWidth = nextColumnWidth;
 exports.taskRef = taskRef;
+exports.taskExecution = taskExecution;
+exports.taskPageSummary = taskPageSummary;
+exports.taskExecutionText = taskExecutionText;
 exports.buildListParams = buildListParams;
 exports.statusFilterWarnings = statusFilterWarnings;
 const core_1 = require("@oclif/core");
@@ -151,6 +155,19 @@ function emptyTasksMessage(flags, bin = 'skrr') {
     }
     return lines.join('\n');
 }
+/** An empty filtered page is evidence about this query, not an empty Space. */
+function externalKeyPrefixWarnings(flags, rowCount) {
+    const prefix = flags['external-key-prefix'];
+    if (typeof prefix !== 'string' || rowCount !== 0)
+        return [];
+    return [
+        {
+            code: 'EXTERNAL_KEY_PREFIX_MATCHED_NOTHING',
+            value: { prefix, space: flags.space ?? null },
+            hint: `No tasks matched --external-key-prefix ${JSON.stringify(prefix)}${flags.space ? ` in space ${String(flags.space)}` : ''}. Check the prefix or run the same command without --external-key-prefix.`,
+        },
+    ];
+}
 /**
  * `--status` is repeatable, so the flag value is a list; callers that predate
  * that and tests that pass a bare string both normalize through here.
@@ -217,6 +234,56 @@ function nextColumnWidth(rows) {
 function taskRef(t) {
     return String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-'));
 }
+/** Evidence about managed execution only; unmanaged work is outside this projection. */
+function taskExecution(t) {
+    const actionability = t.actionability;
+    if (actionability?.state === 'terminal')
+        return { state: 'terminal' };
+    if (actionability?.execution)
+        return { ...actionability.execution };
+    // Older servers cannot distinguish an active Run from a retained checkout. Do not infer
+    // liveness from their `running` actionability, assigned agents, or workflow status.
+    if (!actionability || actionability.state === 'running')
+        return { state: 'unknown' };
+    return { state: 'not_observed' };
+}
+function taskPageSummary(items, hasMore) {
+    const countBy = (values) => values.reduce((out, value) => {
+        out[value] = (out[value] ?? 0) + 1;
+        return out;
+    }, {});
+    const assignment = (t) => {
+        if ((Array.isArray(t.assigneeAgentIds) && t.assigneeAgentIds.length > 0) ||
+            (Array.isArray(t.assigneeUserIds) && t.assigneeUserIds.length > 0))
+            return 'assigned';
+        return Array.isArray(t.assigneeAgentIds) && Array.isArray(t.assigneeUserIds)
+            ? 'unassigned' : 'unknown';
+    };
+    return {
+        scope: 'fetched_page',
+        taskCount: items.length,
+        has_more: hasMore,
+        workflow: countBy(items.map((t) => String(t.statusType ?? 'unknown'))),
+        assignment: {
+            assigned: items.filter((t) => assignment(t) === 'assigned').length,
+            unassigned: items.filter((t) => assignment(t) === 'unassigned').length,
+            unknown: items.filter((t) => assignment(t) === 'unknown').length,
+        },
+        readiness: countBy(items.map((t) => String(t.actionability?.reasonCode ?? 'unknown'))),
+        execution: countBy(items.map((t) => String(taskExecution(t).state))),
+        measurement: 'Managed execution evidence at read time; unmanaged work is not measured.',
+    };
+}
+function taskExecutionText(t) {
+    const execution = taskExecution(t);
+    switch (execution.state) {
+        case 'run_active': return `Run ${String(execution.runStatus ?? 'active')}${execution.agentId ? ` (${String(execution.agentId)})` : ''}`;
+        case 'checkout_held': return 'Checkout held; Run unverified';
+        case 'terminal': return 'Terminal';
+        case 'not_observed': return 'No active Run observed';
+        default: return 'Unknown';
+    }
+}
 /**
  * The task-list request bag is shared with import/export so every CLI list
  * surface serializes the same server-side filters. Keep user-id resolution in
@@ -501,10 +568,13 @@ class TasksList extends base_command_1.BaseCommand {
         view: core_1.Flags.string({
             description: 'Only tasks a saved Task View selects (task_view_…; see `views list`). Combines with other filters',
         }),
-        limit: core_1.Flags.integer({ description: 'Max results', default: 50 }),
+        limit: core_1.Flags.integer({
+            description: 'Results per page (default 50). Follow next_cursor with --cursor for remaining pages.',
+            default: 50,
+        }),
         cursor: core_1.Flags.string({ description: 'Pagination cursor from a previous page' }),
         all: core_1.Flags.boolean({
-            description: 'Include closed tasks even inside an agent session (where --json defaults to open work and reports filter_applied)',
+            description: 'Include closed tasks inside an agent session. This changes status filtering only; it does not fetch all pages. Use --cursor to continue.',
         }),
         ...list_output_1.listOutputFlags,
         strict: core_1.Flags.boolean({
@@ -595,9 +665,11 @@ class TasksList extends base_command_1.BaseCommand {
             };
         }
         const list = response;
+        const rowCount = Array.isArray(list?.data) ? list.data.length : 0;
+        const prefixWarnings = calendarRange ? [] : externalKeyPrefixWarnings(flags, rowCount);
         const statusWarnings = calendarRange
             ? []
-            : statusFilterWarnings(flags, Array.isArray(list?.data) ? list.data.length : 0);
+            : [...statusFilterWarnings(flags, rowCount), ...prefixWarnings];
         if (flags.strict && statusWarnings.some((w) => w.code === 'STATUS_NOT_BUILTIN')) {
             const bad = statusWarnings.find((w) => w.code === 'STATUS_NOT_BUILTIN');
             this.failWithCliError({
@@ -618,10 +690,12 @@ class TasksList extends base_command_1.BaseCommand {
             const enriched = list && Array.isArray(list.data)
                 ? {
                     ...list,
+                    ...(!calendarRange ? { summary: taskPageSummary(list.data, Boolean(list.has_more ?? list.next_cursor)) } : {}),
                     data: list.data.map((t) => ({
                         ...t,
                         ref: taskRef(t),
                         nextAction: nextActionText(t),
+                        ...(!calendarRange ? { execution: taskExecution(t) } : {}),
                     })),
                 }
                 : response;
@@ -635,7 +709,19 @@ class TasksList extends base_command_1.BaseCommand {
                     compact: flags.compact,
                     requestedLimit: flags.limit,
                     warnings: statusWarnings,
-                    ...(filterApplied ? { filterApplied } : {}),
+                    ...(filterApplied || flags['external-key-prefix']
+                        ? {
+                            filterApplied: {
+                                ...filterApplied,
+                                ...(flags['external-key-prefix']
+                                    ? {
+                                        externalKeyPrefix: flags['external-key-prefix'],
+                                        spaceId: flags.space ?? null,
+                                    }
+                                    : {}),
+                            },
+                        }
+                        : {}),
                 });
             this.printList(out, Boolean(flags.ndjson));
             return;
@@ -668,6 +754,8 @@ class TasksList extends base_command_1.BaseCommand {
         const items = r?.data ?? [];
         if (items.length === 0) {
             this.log(emptyTasksMessage(flags, this.config.bin));
+            for (const line of (0, list_output_1.warningLines)(prefixWarnings))
+                this.log(line);
             return;
         }
         const rows = items.map((t) => {
@@ -688,6 +776,7 @@ class TasksList extends base_command_1.BaseCommand {
                 priority: String(t.priority ?? '-'),
                 estimate: t.estimate === null || t.estimate === undefined ? '-' : String(t.estimate),
                 assignees,
+                execution: taskExecutionText(t),
                 next: nextActionText(t),
                 match: String(t._matchField ?? '-'),
                 savings: economics?.savings
@@ -719,6 +808,7 @@ class TasksList extends base_command_1.BaseCommand {
                 : []),
             { key: 'estimate', header: 'ESTIMATE' },
             { key: 'assignees', header: 'ASSIGNEES' },
+            { key: 'execution', header: 'EXECUTION', maxWidth: 58 },
             // Bounded: the reason is a sentence, and an unbounded column wraps the
             // table into unreadability on a narrow terminal.
             { key: 'next', header: 'NEXT', maxWidth: nextColumnWidth(rows) },
@@ -727,6 +817,9 @@ class TasksList extends base_command_1.BaseCommand {
             ...(flags.q ? [{ key: 'match', header: 'MATCH' }] : []),
             { key: 'id', header: 'ID' },
         ], (line) => this.log(line));
+        const summary = taskPageSummary(items, Boolean(r?.has_more ?? r?.next_cursor));
+        this.log(`\nFetched page: ${items.length} tasks; ${summary.assignment.unassigned} unassigned; ${summary.execution.run_active ?? 0} active managed Runs; ${summary.execution.checkout_held ?? 0} retained checkouts; ${summary.execution.unknown ?? 0} execution unknown. ${summary.has_more ? 'More pages available.' : 'Last page.'}`);
+        this.log(summary.measurement);
         if (flags.rank)
             this.log('\nRanked only within this fetched page; estimates are claims, not measured savings.\n' +
                 'SCORE = annualized USD savings / max(effort hours, 0.5) x risk factor (low 1, medium 0.6, high 0.25); ' +

package/dist/commands/tasks/move.js

@@ -63,6 +63,7 @@ class TasksMove extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksMove);
+        this.setJsonOperation({ command: 'tasks:move', mode: 'execute' });
         let taskIdentity;
         try {
             taskIdentity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
@@ -78,7 +79,7 @@ class TasksMove extends base_command_1.BaseCommand {
             });
         }
         const taskRef = await this.resolveEntityRef('task', taskIdentity.id);
-        const projectId = (0, projects_1.resolveTaskProjectFlag)(flags.project);
+        let projectId = (0, projects_1.resolveTaskProjectFlag)(flags.project);
         if (projectId !== undefined) {
             try {
                 (0, unsupported_managed_task_write_1.refuseUnsupportedManagedTaskWrite)('Project changes', 'mcp__tasks__task_update');
@@ -96,6 +97,11 @@ class TasksMove extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        if (typeof projectId === 'string') {
+            const placement = { projectId };
+            await this.resolveTaskResourceReferences(placement, { taskId: taskRef });
+            projectId = placement.projectId;
+        }
         // Whether a target is blocked is a Space-specific TYPE decision. The
         // server validates and applies these optional hold details after resolving
         // the state; a client must not guess from a display name.
@@ -148,7 +154,9 @@ class TasksMove extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
-            this.log(JSON.stringify((0, web_url_1.withTaskUrl)(this.cliConfig.baseURL, updated), null, 2));
+            this.printJsonOperation((0, web_url_1.withTaskUrl)(this.cliConfig.baseURL, updated), {
+                resource: { kind: 'task', id: updated?.id }, task: { id: updated?.id },
+            });
             return;
         }
         const t = (updated ?? {});

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base-command';
+export default class TasksPreflight extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        skill: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/tasks/preflight.js

@@ -0,0 +1,77 @@
+"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");
+const task_preflight_1 = require("../../lib/task-preflight");
+class TasksPreflight extends base_command_1.BaseCommand {
+    static description = 'Inspect workflow blockers and execution prerequisites without starting work or probing a machine';
+    static args = {
+        id: core_1.Args.string({ description: 'Task ID/ref; defaults to the current Task runtime', ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output native observations, uncertainty, and CLI verification metadata as JSON' }),
+        task: core_1.Flags.string({ description: 'Task ID/ref; overrides current Task runtime context' }),
+        skill: core_1.Flags.string({ description: 'Skill ID for the existing server execution preview' }),
+    };
+    static examples = [
+        '<%= config.bin %> tasks preflight OSK-123',
+        '<%= config.bin %> tasks preflight --json',
+    ];
+    async run() {
+        this.setJsonOperation({ command: 'tasks:preflight', mode: 'verify', writeState: 'not_attempted' });
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksPreflight);
+        let identity;
+        try {
+            identity = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        }
+        catch (error) {
+            const failure = (0, task_resolver_1.taskResolutionFailure)(error);
+            this.failWithCliError({ message: failure.message, code: failure.code, exit: 2, retryable: false,
+                details: { suggestion: failure.suggestion } });
+        }
+        let taskId = await this.resolveTaskReference(identity.id);
+        // Native endpoints accept identifiers, so BaseCommand intentionally keeps
+        // OSK-123 unchanged. Correlating two diagnostic records needs the returned
+        // canonical identity; UUID/title-resolved callers keep their request count.
+        if (/^[A-Z]+-\d+$/i.test(taskId)) {
+            let task;
+            try {
+                task = await data_provider_1.dataService.getTask(taskId, { enrich: false });
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (typeof task?.id !== 'string' || !/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i.test(task.id) ||
+                (task.identifier !== undefined && (typeof task.identifier !== 'string' || task.identifier.toUpperCase() !== taskId.toUpperCase()))) {
+                this.failWithCliError({
+                    code: 'TASK_PREFLIGHT_IDENTITY_UNCONFIRMED',
+                    message: 'The server did not confirm a canonical Task identity for this reference. Inspect tasks show <task> --json before repeating preflight.',
+                    exit: 2, retryable: false,
+                });
+            }
+            taskId = task.id;
+        }
+        const report = await (0, task_preflight_1.readTaskPreflight)(taskId, {
+            workflow: () => data_provider_1.dataService.getTaskActionability(taskId),
+            execution: () => data_provider_1.dataService.previewTaskStart(taskId, flags.skill ? { skillId: flags.skill } : undefined),
+        });
+        // Only native diagnostic responses establish an identity for _cli; a
+        // requested ref is not itself a confirmed Task record.
+        const nativeId = report.workflow.status === 'observed' ? report.workflow.value.taskId
+            : report.execution.status === 'observed' ? report.execution.value.taskId : null;
+        if (flags.json)
+            this.printJsonOperation({ ok: report.summary === 'eligible_to_attempt', ...report }, {
+                resource: nativeId ? { kind: 'task', id: nativeId } : null,
+                task: nativeId ? { id: nativeId } : null,
+            });
+        else
+            for (const line of (0, task_preflight_1.taskPreflightLines)(report, this.config.bin))
+                this.log(line);
+        if (report.summary !== 'eligible_to_attempt')
+            this.exit(report.summary === 'blocked' ? 1 : 2);
+    }
+}
+exports.default = TasksPreflight;

package/dist/commands/tasks/resource/list.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const list_output_1 = require("../../../lib/list-output");
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
@@ -29,7 +30,7 @@ class TasksResourceList extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         if (flags.json)
-            return this.log(JSON.stringify(result, null, 2));
+            return this.printJsonResult((0, list_output_1.listResult)(result));
         if (!result.data.length)
             return this.log('No Resources linked.');
         for (const item of result.data) {

package/dist/commands/tasks/result/submit.js

@@ -42,6 +42,7 @@ const web_url_1 = require("../../../lib/web-url");
 const api_fetch_1 = require("../../../lib/api-fetch");
 const task_closure_1 = require("../../../lib/task-closure");
 const session_task_write_1 = require("../../../lib/session-task-write");
+const task_write_attribution_1 = require("../../../lib/task-write-attribution");
 function parseJson(value, label) {
     if (!value)
         return undefined;
@@ -92,6 +93,7 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
     async run() {
+        this.setJsonOperation({ command: 'tasks:result:submit', mode: 'execute' });
         this.requireAuth();
         const { args, flags } = await this.parse(TasksResultSubmit);
         const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.task, flagTask: flags.task });
@@ -202,8 +204,13 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: task.id });
+        const attribution = (0, task_write_attribution_1.taskWriteAttribution)(result, 'submittedBy');
         if (flags.json)
-            return this.log(JSON.stringify({ ...result, url }, null, 2));
+            return this.printJsonOperation({ ...result, url, attribution }, {
+                resource: { kind: 'task_result', id: result?.result?.id },
+                task: { id: result?.result?.taskId },
+                ...(typeof result?.idempotent === 'boolean' ? { replayed: result.idempotent } : {}),
+            });
         // Say what came back, never what we hope came back.
         //
         // This line used to read "...; it is ready for review." unconditionally,
@@ -212,6 +219,8 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
         // which the call did not carry. Submitting a Result is not closing a Task;
         // the response now reports where it stands and this prints exactly that.
         this.log(`Submitted Result v${result.result.version} (${result.result.id}) for ${task.id}.`);
+        for (const line of (0, task_write_attribution_1.attributionLines)(attribution))
+            this.log(line);
         for (const line of (0, task_closure_1.closureReport)(result.closure, { closing: false }))
             this.log(line);
         if (url)

package/dist/commands/tasks/review.js

@@ -22,6 +22,7 @@ class TasksReview extends base_command_1.BaseCommand {
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
     async run() {
+        this.setJsonOperation({ command: 'tasks:review', mode: 'execute' });
         this.requireAuth();
         const { args, flags } = await this.parse(TasksReview);
         const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.task, flagTask: flags.task });
@@ -47,7 +48,11 @@ class TasksReview extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         if (flags.json)
-            return this.log(JSON.stringify(result, null, 2));
+            return this.printJsonOperation(result, {
+                resource: { kind: 'task_review', id: result?.review?.id },
+                task: { id: result?.review?.taskId },
+                ...(typeof result?.idempotent === 'boolean' ? { replayed: result.idempotent } : {}),
+            });
         this.log(`Recorded Review: ${flags.decision} for Result ${flags['result-id']}.`);
     }
 }

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

@@ -1,4 +1,6 @@
 import { BaseCommand } from '../../base-command';
+/** " (via CLI credential)" when the revision recorded its credential channel. */
+export declare function revisionChannelSuffix(rev: Record<string, unknown>): string;
 export default class TasksRevisions extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/tasks/revisions.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.revisionChannelSuffix = revisionChannelSuffix;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
+/** " (via CLI credential)" when the revision recorded its credential channel. */
+function revisionChannelSuffix(rev) {
+    const via = rev.metadata?.via;
+    return (0, data_provider_1.principalChannelSuffix)({ kind: 'human', via });
+}
 class TasksRevisions extends base_command_1.BaseCommand {
     static description = 'List revisions for a task';
     static examples = [
@@ -39,7 +45,8 @@ class TasksRevisions extends base_command_1.BaseCommand {
         const rows = items.map((rev) => ({
             version: String(rev.revisionNumber ?? '-'),
             changeType: String(rev.changeType ?? '-'),
-            user: String(rev.userId ?? '-'),
+            // The channel the person's credential came through, when recorded (OSK-16621).
+            user: `${String(rev.userId ?? '-')}${revisionChannelSuffix(rev)}`,
             changes: String(Array.isArray(rev.changes) ? rev.changes.length : 0),
             when: rev.createdAt ? String(rev.createdAt).slice(0, 19).replace('T', ' ') : '-',
         }));

package/dist/commands/tasks/show.js

@@ -245,25 +245,31 @@ function taskFailureLines(t, bin = 'skrr') {
     if (!error && !failedAt && !isFailed)
         return [];
     const lines = [];
-    const attempts = typeof t.executionAttempts === 'number' ? t.executionAttempts : null;
-    const runId = typeof t.lastFinalizedRunId === 'string' ? t.lastFinalizedRunId : null;
-    const facts = [
-        failedAt,
-        attempts != null ? `attempt ${attempts}` : null,
-        runId ? `run ${runId}` : null,
-    ].filter(Boolean);
-    if (facts.length > 0)
-        lines.push(`Failed:      ${facts.join(' · ')}`);
+    // Task failure stamps survive later successful Runs. Neither the lifetime
+    // attempt counter nor lastFinalizedRunId identifies the Run that failed.
+    if (failedAt)
+        lines.push(`Failure recorded: ${failedAt}`);
     if (error) {
         // Labelled with the JSON key, because a reader who needs this in a script
         // needs the key more than they need the prose.
-        lines.push(`Error:       ${error}`);
+        lines.push(`Recorded error: ${error}`);
         lines.push('             (`executionError` in --json)');
     }
     else if (isFailed) {
-        lines.push('Error:       none recorded on the task.');
+        lines.push('Recorded error: none recorded on the task.');
+    }
+    const failure = t.executionFailure;
+    if (failure?.recovery && typeof failure.recovery === 'string' && !error.includes(failure.recovery)) {
+        lines.push(`Recovery:    ${failure.recovery}`);
+    }
+    if (failure?.headline && typeof failure.headline === 'string' && !error.includes(failure.headline)) {
+        lines.push(`Cause:       ${failure.headline}`);
+    }
+    if (failure?.runId) {
+        lines.push(`Diagnostic:  executionFailure in --json (run ${failure.runId})`);
     }
     const ref = String(t.identifier ?? t.id ?? t._id ?? '<task-id>');
+    lines.push(`Latest runs: ${bin} tasks runs ${ref}`);
     lines.push(`Per-run why: ${bin} tasks activity ${ref} --json   (details.error, keyed by runId)`);
     return lines;
 }

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

@@ -8,6 +8,7 @@ export default class TasksStart extends BaseCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         skill: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         branch: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

package/dist/commands/tasks/start.js

@@ -7,6 +7,7 @@ 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");
 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';
@@ -20,6 +21,7 @@ class TasksStart extends base_command_1.BaseCommand {
         '<%= config.bin %> tasks start <task-id> --skill <skill-id>',
         '<%= config.bin %> tasks start OSK-123 --branch',
         '<%= config.bin %> tasks start <task-id> --json',
+        '<%= config.bin %> tasks start <task-id> --dry-run --json',
     ];
     static args = {
         id: core_1.Args.string({
@@ -30,6 +32,7 @@ class TasksStart extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        'dry-run': core_1.Flags.boolean({ description: 'Preview effective unattended execution prerequisites without creating a Run or checking out a branch', exclusive: ['branch'] }),
         task: core_1.Flags.string({
             description: 'Task ID; overrides daemon runtime context',
         }),
@@ -57,6 +60,36 @@ class TasksStart extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        if (flags['dry-run']) {
+            if (flags.branch)
+                this.error('--dry-run cannot check out a branch; omit --branch.', { exit: 2 });
+            let preview;
+            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);
+            }
+            catch (err) {
+                this.handleApiError(err, { subject: `Task ${taskIdentity.id} execution preview` });
+            }
+            if (!(0, task_admission_1.isAdmissionPreview)(preview)) {
+                this.failWithCliError({
+                    message: 'The server did not return a confirmed execution preview. Update the server before using --dry-run.',
+                    code: 'TASK_START_PREVIEW_UNSUPPORTED', exit: 2, retryable: false,
+                });
+            }
+            if (flags.json)
+                this.printJsonResult(preview, { ok: preview.executionAdmission.state !== 'blocked' });
+            else {
+                this.log(`Execution preview for ${preview.taskId}:`);
+                for (const line of (0, task_admission_1.admissionLines)(preview.executionAdmission))
+                    this.log(line);
+                this.log('No Run was created. Starting later rechecks current prerequisites.');
+            }
+            if (preview.executionAdmission.state === 'blocked')
+                this.exit(1);
+            return;
+        }
         // Resolve once before asking the server to start. It makes a title or
         // human-readable ref usable for branch naming, while UUID callers retain
         // their existing one-request behavior when --branch is omitted.
@@ -137,6 +170,8 @@ class TasksStart extends base_command_1.BaseCommand {
         this.log(`Started task ${taskId}${flags.skill ? ` with skill ${flags.skill}` : ''}`);
         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);
         this.log(`Conversation: ${result.conversationId}`);
         this.log(`Session:      ${result.sessionId}`);
         for (const line of startFollowUpLines(this.config.bin, taskIdentity.id))

package/dist/commands/tasks/templates/list.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const list_output_1 = require("../../../lib/list-output");
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
@@ -25,7 +26,7 @@ class TasksTemplatesList extends base_command_1.BaseCommand {
             this.handleApiError(err);
         }
         if (flags.json) {
-            this.log(JSON.stringify(response, null, 2));
+            this.printJsonResult((0, list_output_1.listResult)(response));
             return;
         }
         const items = response?.data ?? [];

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

@@ -6,6 +6,11 @@ import { BaseCommand } from '../../base-command';
  * renders `details` with, so the two surfaces describe one entry the same way.
  */
 export declare function withDetails(item: Record<string, unknown>): string;
+/**
+ * Who, not just which kind: `human:<id> (via CLI credential)` (OSK-16621). A
+ * row written before channels existed renders as it always did.
+ */
+export declare function timelineActor(item: Record<string, unknown>): string;
 export default class TasksTimeline extends BaseCommand {
     static description: string;
     static args: {

package/dist/commands/tasks/timeline.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withDetails = withDetails;
+exports.timelineActor = timelineActor;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
@@ -21,6 +22,13 @@ function withDetails(item) {
     const details = (0, format_1.formatCell)(item.data ?? item.details, '');
     return details ? `${preview} (${details})` : preview;
 }
+/**
+ * Who, not just which kind: `human:<id> (via CLI credential)` (OSK-16621). A
+ * row written before channels existed renders as it always did.
+ */
+function timelineActor(item) {
+    return item.actor ? (0, data_provider_1.formatTaskPrincipal)(item.actor) : '-';
+}
 class TasksTimeline extends base_command_1.BaseCommand {
     static description = 'Show the immutable multi-actor Task Activity timeline';
     static args = {
@@ -67,7 +75,7 @@ class TasksTimeline extends base_command_1.BaseCommand {
                 .replace('T', ' ')
                 .slice(0, 19),
             source: String(item.type ?? '-'),
-            actor: String(item.actor?.kind ?? '-'),
+            actor: timelineActor(item),
             // A lifecycle row's preview is the bare action, so `status_changed`
             // appeared three times in a row without ever naming a status. The
             // answer is in `details` (`status=blocked`), which `tasks activity`

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

@@ -50,6 +50,7 @@ export default class TasksUpdate extends BaseCommand {
         goal: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         cycle: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        unassigned: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'assignee-agent': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'assignee-user': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'dri-agent': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;