@skrr-ai/cli 0.1.13 → 0.1.15

package/dist/commands/tasks/create.js

@@ -136,6 +136,12 @@ class TasksCreate extends base_command_1.BaseCommand {
         'dri-user': core_1.Flags.string({
             description: 'Explicit accountable human DRI (separate from assignees)',
         }),
+        expect: core_1.Flags.string({
+            multiple: true,
+            description: tasks_1.EXPECT_FLAG_HELP +
+                " Injected into the agent's instructions and checked against what the run produced. " +
+                'Omit to inherit the space default.',
+        }),
         'execution-mode': core_1.Flags.string({
             description: 'Who executes the task: agent or human. Required when both Humans and Agents are ' +
                 'assigned. Passing "human" with no assignee flags files the task against you, ' +
@@ -184,7 +190,25 @@ class TasksCreate extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
-        const payload = (0, tasks_1.buildTaskCreatePayload)(body, flags);
+        // Resolve --expect BEFORE any write. A bad spec must fail here rather than
+        // reaching the server as a silently-dropped field: a declaration that did
+        // not stick is worse than none, because the board then shows a contract
+        // nobody is enforcing.
+        const parsedExpectations = (0, tasks_1.parseExpectations)(flags.expect);
+        if (!parsedExpectations.ok) {
+            this.failWithCliError({
+                message: parsedExpectations.error,
+                code: 'INVALID_TASK_EXPECTATION',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const payload = (0, tasks_1.buildTaskCreatePayload)(body, {
+            ...flags,
+            expectations: parsedExpectations.ok && parsedExpectations.value.length > 0
+                ? parsedExpectations.value
+                : undefined,
+        });
         const isTemplateInstantiation = typeof payload.templateId === 'string' && payload.templateId.length > 0;
         // Template defaults (including its assigned agents) are part of the saved
         // resource. Do not let the ordinary "who owns an empty task?" policy

package/dist/commands/tasks/deliverable/add.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * `skrr tasks deliverable add <task> <kind>:<identity>[@<location>]`
+ *
+ * The command an agent runs to say what it produced. Deliberately small: one
+ * positional carrying a coordinate it already knows, because the measured
+ * behaviour is that agents emit a real commit sha 77% of the time when asked
+ * for it in a required field, and 0% of the time when asked for it in an
+ * optional structured one.
+ */
+export default class TasksDeliverableAdd extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        coordinate: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        lifecycle: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/deliverable/add.js

@@ -0,0 +1,70 @@
+"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 tasks_1 = require("../../../lib/tasks");
+/**
+ * `skrr tasks deliverable add <task> <kind>:<identity>[@<location>]`
+ *
+ * The command an agent runs to say what it produced. Deliberately small: one
+ * positional carrying a coordinate it already knows, because the measured
+ * behaviour is that agents emit a real commit sha 77% of the time when asked
+ * for it in a required field, and 0% of the time when asked for it in an
+ * optional structured one.
+ */
+class TasksDeliverableAdd extends base_command_1.BaseCommand {
+    static description = 'Record something this task produced (a commit, a page, a URL, a file, a message, a dataset)';
+    static examples = [
+        '<%= config.bin %> tasks deliverable add <task-id> code:a1b2c3d@origin/main',
+        '<%= config.bin %> tasks deliverable add <task-id> page:d_92@Engineering/deploy',
+        '<%= config.bin %> tasks deliverable add <task-id> file/pdf:f_71@Drive/Reports',
+        '<%= config.bin %> tasks deliverable add <task-id> code:a1b2c3d --lifecycle in_review',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+        coordinate: core_1.Args.string({
+            description: '<kind>[/<format>]:<identity>[@<location>] — e.g. code:a1b2c3d@origin/main, ' +
+                'file/pdf:report_92@Drive/Reports',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        lifecycle: core_1.Flags.string({
+            options: ['local', 'in_review', 'durable', 'blocked', 'superseded'],
+            description: 'How far along it is. Defaults to `local` — recording that a commit exists is not a ' +
+                'claim that it landed. Only an external receipt should assert `durable`.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksDeliverableAdd);
+        const parsed = (0, tasks_1.parseDeliverableCoordinate)(args.coordinate);
+        if (!parsed.ok) {
+            // For an agent this message IS the documentation — it hits the error and
+            // corrects, so the refusal carries the whole form and vocabulary.
+            this.error(parsed.error, { exit: 1 });
+            return;
+        }
+        let result;
+        try {
+            result = await data_provider_1.dataService.addTaskDeliverable(args.task, {
+                ...parsed.value,
+                ...(flags.lifecycle ? { lifecycle: flags.lifecycle } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const where = parsed.value.location ? ` at ${parsed.value.location}` : '';
+        this.log(`Recorded ${parsed.value.kind}:${parsed.value.identity}${where} (${flags.lifecycle || 'local'}).`);
+    }
+}
+exports.default = TasksDeliverableAdd;

package/dist/commands/tasks/events/append.d.ts

@@ -15,7 +15,7 @@ export default class TasksEventsAppend extends BaseCommand {
         changed: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         next: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         evidence: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        artifact: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        deliverable: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/tasks/events/append.js

@@ -15,7 +15,7 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
     static examples = [
         '<%= config.bin %> tasks events append <task-id> --kind checkpoint --idempotency-key "<task-id>:first-pass" --summary "Parser handles nested fences"',
         '<%= config.bin %> tasks events append <task-id> --kind decision --idempotency-key "<task-id>:storage-choice" --summary "Chose the CRDT path" --evidence "A direct contentHtml write is reverted by the next render tick"',
-        '<%= config.bin %> tasks events append <task-id> --kind verification --idempotency-key "<task-id>:verified" --summary "Repro no longer reproduces" --artifact <commit-sha>',
+        '<%= config.bin %> tasks events append <task-id> --kind verification --idempotency-key "<task-id>:verified" --summary "Repro no longer reproduces" --deliverable <commit-sha>',
     ];
     static args = {
         id: core_1.Args.string({
@@ -54,9 +54,9 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
         evidence: core_1.Flags.string({
             description: 'Why it is true — an observation, command output, or a before → after',
         }),
-        artifact: core_1.Flags.string({
+        deliverable: core_1.Flags.string({
             multiple: true,
-            description: 'Durable reference: a file path, commit sha, or URL. Repeatable. "in the conversation" is not an artifact',
+            description: 'Durable reference: a file path, commit sha, or URL. Repeatable. "in the conversation" is not a deliverable',
         }),
     };
     async run() {
@@ -70,7 +70,7 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
             changed: flags.changed,
             next: flags.next,
             evidence: flags.evidence,
-            artifacts: flags.artifact?.map((ref) => ({ label: 'artifact', ref })),
+            artifacts: flags.deliverable?.map((ref) => ({ label: 'deliverable', ref })),
         };
         const path = await (0, session_task_endpoints_1.sessionScopedTaskPath)('event');
         let result;

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

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

package/dist/commands/tasks/expectations.js

@@ -0,0 +1,92 @@
+"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");
+/**
+ * `skrr tasks expectations <task>` — what this task owes, and how far each got.
+ *
+ * Reads the SERVER's verdict rather than recomputing one. The judge and the
+ * completion gate are the same module, so a CLI that decided "met" for itself
+ * could disagree with the gate that refuses the task — and the reader would
+ * have no way to tell which was lying.
+ */
+const STATE_LABEL = {
+    met: 'done',
+    waived: 'dropped',
+    blocked: 'stuck',
+    underway: 'on its way',
+    owed: 'not yet',
+    unjudged: 'needs a person',
+};
+function line(expectation) {
+    const label = STATE_LABEL[expectation.state] || expectation.state;
+    // A judged expectation is stated as NOT a gate. A list that reads like a
+    // contract while enforcing nothing is worse than no list, because it is
+    // trusted.
+    const gate = expectation.gating ? '' : '  (does not block completion)';
+    const from = expectation.source === 'space' ? '  [space default]' : '';
+    return `  ${expectation.id.padEnd(18)} ${label.padEnd(14)} ${expectation.sentence}${gate}${from}`;
+}
+class TasksExpectations extends base_command_1.BaseCommand {
+    static description = 'Show what a task must produce and how far each expectation got ("Done when")';
+    static examples = [
+        '<%= config.bin %> tasks expectations <task-id>',
+        '<%= config.bin %> tasks expectations <task-id> --json',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksExpectations);
+        let acceptance;
+        try {
+            acceptance = await data_provider_1.dataService.getTaskAcceptance(args.task);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(acceptance, null, 2));
+            return;
+        }
+        if (acceptance.expectations.length === 0) {
+            // An empty contract is a real answer, not an unfilled field. Say so
+            // plainly rather than prompting for something most tasks do not owe.
+            this.log('Nothing durable is expected of this task.');
+            return;
+        }
+        // The evidence read fails OPEN by design, so "produced nothing" and "we
+        // could not look" are indistinguishable downstream unless the server says
+        // which happened. Never print the first when it might be the second.
+        if (!acceptance.evidenceRead) {
+            this.warn('Could not read what this task produced — the states below may understate it. ' +
+                'This is not a claim that nothing was produced.');
+        }
+        this.log('Done when:');
+        for (const expectation of acceptance.expectations) {
+            this.log(line(expectation));
+        }
+        const gating = acceptance.expectations.filter((e) => e.gating);
+        const met = gating.filter((e) => e.met).length;
+        this.log('');
+        this.log(`${met} of ${gating.length} met  ·  overall: ${acceptance.state}`);
+        // Only the ones actually stored on the task can be judged. A space default
+        // is synthesised per read, so pointing at `tasks judge` for one would send
+        // the reader at a command that can only refuse it.
+        const settleable = acceptance.expectations.filter((e) => e.state === 'unjudged' && e.source !== 'space').length;
+        if (settleable > 0) {
+            this.log(`${settleable} awaiting a person — settle with \`${this.config.bin} tasks judge\`.`);
+        }
+        const inherited = acceptance.unjudged - settleable;
+        if (inherited > 0) {
+            this.log(`${inherited} inherited from the space default — declare them on the task to settle them.`);
+        }
+    }
+}
+exports.default = TasksExpectations;

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

@@ -0,0 +1,29 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks judge <task> <expectation-id> --verdict met --reason "<why>"`
+ *
+ * Settle a `judged` expectation — one whose text nothing here can evaluate.
+ *
+ * Only a judged one. A checkable expectation is settled by recording what was
+ * produced, and letting a person mark it met by hand would make the deliverables
+ * ledger optional, which is the same as not having one. The server refuses that
+ * case with an error naming the command to use instead.
+ *
+ * The reason is REQUIRED, for the same purpose a waiver's is: a verdict with no
+ * reason is indistinguishable from a click, and the entire value of a judged
+ * expectation is that somebody actually looked.
+ */
+export default class TasksJudge extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        expectation: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        verdict: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/judge.js

@@ -0,0 +1,68 @@
+"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");
+/**
+ * `skrr tasks judge <task> <expectation-id> --verdict met --reason "<why>"`
+ *
+ * Settle a `judged` expectation — one whose text nothing here can evaluate.
+ *
+ * Only a judged one. A checkable expectation is settled by recording what was
+ * produced, and letting a person mark it met by hand would make the deliverables
+ * ledger optional, which is the same as not having one. The server refuses that
+ * case with an error naming the command to use instead.
+ *
+ * The reason is REQUIRED, for the same purpose a waiver's is: a verdict with no
+ * reason is indistinguishable from a click, and the entire value of a judged
+ * expectation is that somebody actually looked.
+ */
+class TasksJudge extends base_command_1.BaseCommand {
+    static description = 'Settle a judged expectation with a verdict and a stated reason';
+    static examples = [
+        '<%= config.bin %> tasks judge <task-id> e2 --verdict met --reason "Read it end to end; a non-engineer follows it."',
+        '<%= config.bin %> tasks judge <task-id> e2 --verdict unmet --reason "Still assumes the reader knows the schema."',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+        expectation: core_1.Args.string({
+            description: 'Expectation id (see `tasks expectations`)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        verdict: core_1.Flags.string({
+            options: ['met', 'unmet'],
+            required: true,
+            description: 'Whether the expectation was met.',
+        }),
+        reason: core_1.Flags.string({
+            required: true,
+            description: 'What you looked at. A verdict without one is not a judgement.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksJudge);
+        let result;
+        try {
+            result = await data_provider_1.dataService.judgeTaskExpectation(args.task, {
+                expectationId: args.expectation,
+                verdict: flags.verdict,
+                reason: flags.reason,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Recorded ${args.expectation} as ${flags.verdict}: ${flags.reason}`);
+    }
+}
+exports.default = TasksJudge;

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

@@ -1,6 +1,17 @@
 import type { TaskListParams } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
 type ListFlags = Record<string, unknown>;
+/**
+ * What the zero-row case is allowed to say. The bare `No tasks.` was step 3
+ * of `GETTING_STARTED.md` and named no next step; a new user reading it hit
+ * three of these in a row and concluded the product was empty. Follow the
+ * `commitments/list.ts` pattern: name the command that fixes THIS empty state,
+ * with the specific `--status in_progress` hint kept because a reaped run
+ * genuinely hides here (a real bug, not a first-run scenario).
+ *
+ * Exported and pure so the wording is testable without an oclif runtime.
+ */
+export declare function emptyTasksMessage(flags: ListFlags, bin?: string): string;
 /**
  * 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

package/dist/commands/tasks/list.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyTasksMessage = emptyTasksMessage;
 exports.buildListParams = buildListParams;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
@@ -7,6 +8,86 @@ const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 const format_1 = require("../../lib/format");
 const tasks_1 = require("../../lib/tasks");
+/**
+ * Names of `tasks list` flags that narrow the result set. Used to distinguish
+ * "no tasks anywhere" from "no tasks matching your filters" — the first case
+ * wants a create-command hint, the second wants a loosen-filters hint. Kept
+ * as a set so a new filter added to `buildListParams` shows up here at review
+ * time rather than silently changing the empty state.
+ */
+const FILTER_FLAGS = new Set([
+    'goal',
+    'project',
+    'cycle',
+    'parent',
+    'status',
+    'status-type',
+    'execution-state',
+    'actionable-by',
+    'actionable-for-agent',
+    'needs-me',
+    'actionability-state',
+    'actionability-reason',
+    'priority',
+    'estimate',
+    'min-estimate',
+    'assignee-agent',
+    'assignee-user',
+    'dri',
+    'dri-kind',
+    'mine',
+    'explicit-only',
+    'subscribed',
+    'include-snoozed',
+    'external-key',
+    'blocked-by',
+    'blocks',
+    'due-before',
+    'due-after',
+    'overdue',
+    'tag',
+    'label-id',
+    'q',
+]);
+/**
+ * What the zero-row case is allowed to say. The bare `No tasks.` was step 3
+ * of `GETTING_STARTED.md` and named no next step; a new user reading it hit
+ * three of these in a row and concluded the product was empty. Follow the
+ * `commitments/list.ts` pattern: name the command that fixes THIS empty state,
+ * with the specific `--status in_progress` hint kept because a reaped run
+ * genuinely hides here (a real bug, not a first-run scenario).
+ *
+ * Exported and pure so the wording is testable without an oclif runtime.
+ */
+function emptyTasksMessage(flags, bin = 'skrr') {
+    const activeFilters = Array.from(FILTER_FLAGS).filter((name) => {
+        const value = flags[name];
+        if (value === undefined || value === null || value === false)
+            return false;
+        if (typeof value === 'string' && value.length === 0)
+            return false;
+        if (Array.isArray(value) && value.length === 0)
+            return false;
+        return true;
+    });
+    const lines = ['No tasks.'];
+    if (activeFilters.length === 0) {
+        lines.push('');
+        lines.push(`  → Create your first one: \`${bin} tasks create --title "..." --space <space-id>\``);
+        lines.push(`  → List spaces to find one: \`${bin} spaces list\``);
+    }
+    else if (flags.status === 'in_progress' && !flags['execution-state']) {
+        // `--status in_progress` filters the board column only. A run that was
+        // reaped/reset (e.g. a stuck-task timeout) is moved OFF `in_progress` but
+        // keeps its execution markers, so it hides here. Point the operator at
+        // the execution-state views that still surface it.
+        lines.push('');
+        lines.push('Note: `--status in_progress` shows only the board column. A reaped or reset run');
+        lines.push('      no longer has that status. Try `--execution-state active` (running now) or');
+        lines.push(`      \`--execution-state recovered\` (reaped, startable), or \`${bin} tasks active\`.`);
+    }
+    return lines.join('\n');
+}
 /**
  * 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
@@ -303,17 +384,7 @@ class TasksList extends base_command_1.BaseCommand {
         const r = response;
         const items = r?.data ?? [];
         if (items.length === 0) {
-            this.log('No tasks.');
-            // `--status in_progress` filters the board column only. A run that was
-            // reaped/reset (e.g. a stuck-task timeout) is moved OFF `in_progress` but
-            // keeps its execution markers, so it hides here. Point the operator at the
-            // execution-state views that still surface it.
-            if (flags.status === 'in_progress' && !flags['execution-state']) {
-                this.log('');
-                this.log('Note: `--status in_progress` shows only the board column. A reaped or reset run');
-                this.log('      no longer has that status. Try `--execution-state active` (running now) or');
-                this.log('      `--execution-state recovered` (reaped, startable), or `skrr tasks active`.');
-            }
+            this.log(emptyTasksMessage(flags, this.config.bin));
             return;
         }
         const rows = items.map((t) => {

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

@@ -18,7 +18,7 @@ export default class TasksReport extends BaseCommand {
         finding: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         evidence: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         next: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        artifact: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        deliverable: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/tasks/report.js

@@ -18,7 +18,7 @@ class TasksReport extends base_command_1.BaseCommand {
     static description = 'Record a self-contained outcome, findings, evidence, and next actions';
     static examples = [
         '<%= config.bin %> tasks report <task-id> --outcome "Adopt the event ledger" --finding "The task page omits work-event details" --evidence "Task detail reads only legacy activity" --next "Add an Outcome section"',
-        '<%= config.bin %> tasks report <task-id> --kind handoff --outcome "Ready for review" --finding "All acceptance criteria are met" --artifact "src/task.ts" --json',
+        '<%= config.bin %> tasks report <task-id> --kind handoff --outcome "Ready for review" --finding "All acceptance criteria are met" --deliverable "src/task.ts" --json',
     ];
     static args = {
         id: core_1.Args.string({
@@ -48,7 +48,7 @@ class TasksReport extends base_command_1.BaseCommand {
             multiple: true,
         }),
         next: core_1.Flags.string({ description: 'A follow-up or next action (repeatable)', multiple: true }),
-        artifact: core_1.Flags.string({
+        deliverable: core_1.Flags.string({
             description: 'Durable file, commit, PR, or URL (repeatable)',
             multiple: true,
         }),
@@ -92,7 +92,7 @@ class TasksReport extends base_command_1.BaseCommand {
             idempotencyKey: (0, outbox_1.idempotencyKeyFor)('task-report', task.id, JSON.stringify({ report, kind: flags.kind })),
             kind,
             ...(0, task_report_1.taskReportEventFields)(report),
-            artifacts: flags.artifact?.map((ref) => ({ label: 'artifact', ref })),
+            artifacts: flags.deliverable?.map((ref) => ({ label: 'deliverable', ref })),
         };
         const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('event');
         let result;

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

@@ -10,6 +10,7 @@ export default class TasksUpdate extends BaseCommand {
         task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        expect: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'description-format': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         priority: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/update.js

@@ -5,8 +5,9 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
-const task_resolver_1 = require("../../lib/task-resolver");
 const tasks_1 = require("../../lib/tasks");
+const task_resolver_1 = require("../../lib/task-resolver");
+const tasks_2 = require("../../lib/tasks");
 const create_1 = require("./create");
 class TasksUpdate extends base_command_1.BaseCommand {
     static description = 'Update an existing task (partial patch). Status and PROJECT changes go through ' +
@@ -41,6 +42,11 @@ class TasksUpdate extends base_command_1.BaseCommand {
             description: 'Path to a JSON file (or "-" for stdin) to use as the patch body; may include taskId',
         }),
         title: core_1.Flags.string({ description: 'New title' }),
+        expect: core_1.Flags.string({
+            multiple: true,
+            description: tasks_1.EXPECT_FLAG_HELP +
+                ' Replaces the whole list; pass "clear" to drop it and inherit the space default.',
+        }),
         description: core_1.Flags.string({ description: 'New description' }),
         'description-format': core_1.Flags.string({
             description: 'Input format for --description or from-json description',
@@ -48,7 +54,7 @@ class TasksUpdate extends base_command_1.BaseCommand {
         }),
         priority: core_1.Flags.string({
             description: 'New priority',
-            options: [...tasks_1.TASK_PRIORITIES],
+            options: [...tasks_2.TASK_PRIORITIES],
         }),
         'start-date': core_1.Flags.string({ description: 'New planned start date (ISO string)' }),
         'due-date': core_1.Flags.string({ description: 'New due date (ISO string)' }),
@@ -198,8 +204,32 @@ class TasksUpdate extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        // `--expect clear` is an explicit empty list, which the API turns into $unset —
+        // distinct from omitting the flag, which leaves the declaration untouched.
+        // Without the sentinel there is no way to say "stop requiring an output"
+        // short of hand-writing --from-json.
+        // `--expect clear` empties the list; otherwise the flags REPLACE it, because
+        // a partial patch of a list has no honest meaning — "add one" and "this is
+        // now the whole contract" are different requests and the flag can only be
+        // one of them.
+        let expectationsPatch;
+        if (flags.expect !== undefined && flags.expect.length > 0) {
+            if (flags.expect.length === 1 && flags.expect[0].trim() === 'clear') {
+                expectationsPatch = null;
+            }
+            else {
+                const parsed = (0, tasks_1.parseExpectations)(flags.expect);
+                if (!parsed.ok) {
+                    this.error(parsed.error, { exit: 1 });
+                }
+                else {
+                    expectationsPatch = parsed.value;
+                }
+            }
+        }
         const payload = (0, prompt_1.mergeDefined)((0, task_resolver_1.stripTaskIdentityFields)(body), {
             title: flags.title,
+            expectations: expectationsPatch === null ? [] : (expectationsPatch ?? undefined),
             description: flags.description,
             descriptionFormat: flags['description-format'],
             priority: flags.priority,
@@ -231,7 +261,7 @@ class TasksUpdate extends base_command_1.BaseCommand {
             labelIds: flags['label-id'],
             // Worktree isolation override. --worktree ⇒ 'ephemeral', --no-worktree ⇒
             // 'shared', omitted ⇒ unchanged. (Clear-to-inherit via --from-json.)
-            executionIsolation: (0, tasks_1.executionIsolationFromWorktreeFlag)(flags.worktree),
+            executionIsolation: (0, tasks_2.executionIsolationFromWorktreeFlag)(flags.worktree),
             // A mutation option, not a field — `undefined` unless explicitly asked
             // for, so it never counts toward the "nothing to update" check below.
             repairReleasePins: flags['repair-release-pins'] ? true : undefined,
@@ -253,7 +283,7 @@ class TasksUpdate extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
-        const mutationGuardFailure = (0, tasks_1.taskUpdateMutationGuard)(payload);
+        const mutationGuardFailure = (0, tasks_2.taskUpdateMutationGuard)(payload);
         if (mutationGuardFailure) {
             this.failWithCliError({
                 message: mutationGuardFailure.message,