@skrr-ai/cli 0.1.14 → 0.1.17

package/dist/commands/tasks/deliverable/confirm.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 tasks_1 = require("../../../lib/tasks");
+/**
+ * `skrr tasks deliverable confirm <task> <kind>:<identity>[@<location>] --reason "<what you checked>"`
+ *
+ * Somebody looked, and it is there.
+ *
+ * WHY THIS IS A SEPARATE COMMAND from `deliverable add`. Recording and vouching
+ * are different claims. `add` says "this exists, and I am the one who made it";
+ * this says "I checked, independently of whoever made it". Five of the six
+ * outcome kinds have no automatic observer — nothing in the platform watches a
+ * Drive folder or a Slack channel — so without this rung an expectation for a
+ * PDF or a posted message could only ever be closed by waiving it, which
+ * records "we decided we did not need this" about work that was actually done.
+ *
+ * The reason is required, for the same purpose a waiver's and a judgement's
+ * are: the entire value of a confirmation is that a person actually looked, and
+ * a confirmation with nothing written down is indistinguishable from a click.
+ *
+ * It UPSERTS. Confirming something the executor never recorded is legitimate —
+ * the thing is there either way — and making a person file the row first before
+ * they may vouch for it is ceremony that buys nothing.
+ */
+class TasksDeliverableConfirm extends base_command_1.BaseCommand {
+    static description = 'Confirm you checked a deliverable and it is there — the evidence an expectation needs when nothing observes it automatically';
+    static examples = [
+        '<%= config.bin %> tasks deliverable confirm <task-id> file/pdf:report_92@Drive/Reports --reason "Opened it; all four sections are there."',
+        '<%= config.bin %> tasks deliverable confirm <task-id> message:m_51@#general --reason "Read the thread; it went out at 09:04."',
+    ];
+    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>] — the thing you checked',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        reason: core_1.Flags.string({
+            required: true,
+            description: 'What you looked at. A confirmation without one is not a confirmation.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksDeliverableConfirm);
+        const parsed = (0, tasks_1.parseDeliverableCoordinate)(args.coordinate);
+        if (!parsed.ok) {
+            // For an agent the refusal IS the documentation — it hits the error and
+            // corrects — so it carries the whole form and vocabulary.
+            this.error(parsed.error, { exit: 1 });
+            return;
+        }
+        let result;
+        try {
+            result = await data_provider_1.dataService.confirmTaskDeliverable(args.task, {
+                ...parsed.value,
+                reason: flags.reason,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Confirmed ${parsed.value.kind}:${parsed.value.identity}: ${flags.reason}`);
+    }
+}
+exports.default = TasksDeliverableConfirm;

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,111 @@
+"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',
+    // Its own word, because its next action is its own: somebody looks, rather
+    // than somebody works. Reading it as 'not yet' sends people to redo finished
+    // work, which is precisely the confusion the state was added to remove.
+    unverified: 'needs a look',
+    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]' : '';
+    // Only shown when the work exists and the evidence is short — stating the
+    // required authority on every row would be noise on the rows where it is
+    // already satisfied or not yet relevant.
+    const evidence = expectation.state === 'unverified'
+        ? `  (has ${expectation.evidenceAuthority}, needs ${expectation.requiredAuthority})`
+        : '';
+    return `  ${expectation.id.padEnd(18)} ${label.padEnd(14)} ${expectation.sentence}${evidence}${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\`.`);
+        }
+        // Named separately from `unjudged`, and with a different command, because
+        // the two look alike on the board and are not: one needs a verdict on prose,
+        // the other needs somebody to look at a thing that already exists.
+        const unverified = acceptance.expectations.filter((e) => e.state === 'unverified').length;
+        if (unverified > 0) {
+            this.log(`${unverified} produced but not vouched for — confirm with ` +
+                `\`${this.config.bin} tasks deliverable confirm\`, or lower the bar with ` +
+                `\`${this.config.bin} tasks trust\`.`);
+        }
+        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/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

@@ -7,6 +7,7 @@ const api_fetch_1 = require("../../lib/api-fetch");
 const outbox_1 = require("../../lib/outbox");
 const task_report_1 = require("../../lib/task-report");
 const task_resolver_1 = require("../../lib/task-resolver");
+const tasks_1 = require("../../lib/tasks");
 const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
 const web_url_1 = require("../../lib/web-url");
 /**
@@ -18,7 +19,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 +49,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,8 +93,31 @@ 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 })),
         };
+        // THE SAME BRIDGE `tasks complete` CARRIES, for the same reason.
+        //
+        // `--deliverable` here is prose for a work event's `artifacts` list, and
+        // the ledger the completion gate reads is written by `tasks deliverable
+        // add`. Three commands in this CLI answer to the word and only one of them
+        // writes the ledger — and the project's own operating instructions teach
+        // this spelling. So a value that is unambiguously a coordinate is forwarded
+        // to the ledger too; prose is left exactly as it was, because guessing a
+        // coordinate out of prose fills the ledger with rows nobody can look up.
+        for (const ref of flags.deliverable ?? []) {
+            const parsed = (0, tasks_1.parseDeliverableCoordinate)(ref);
+            if (!parsed.ok) {
+                continue;
+            }
+            try {
+                await data_provider_1.dataService.addTaskDeliverable(task.id, parsed.value);
+            }
+            catch {
+                // Best-effort: a report must still be posted when the ledger write
+                // fails, and the completion gate's refusal names the command that
+                // writes it.
+            }
+        }
         const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('event');
         let result;
         try {

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

@@ -0,0 +1,35 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks trust <task> <expectation-id> --level <authority> --reason "<why>"`
+ *
+ * Move how much evidence one expectation demands.
+ *
+ * A DECISION, not an edit — which is why it is its own command rather than a
+ * field on `tasks update`. It is the one control that turns a refusal into a
+ * pass with no new work done, so a reader later has to be able to see that it
+ * happened and why. Buried in a list patch it would record neither.
+ *
+ * Lowering is the common direction and it is legitimate: a contract that cannot
+ * express "an agent's word is enough for this one" pushes its authors back to
+ * declaring nothing at all, which is the failure the whole feature exists to
+ * end. Raising takes the same reason and costs nothing to allow.
+ *
+ * The three levels, weakest first:
+ *   self_reported       whoever did the work says it is done
+ *   human_confirmed     someone else looked and said so
+ *   observation_backed  the platform saw it itself (a merge webhook, an upload)
+ */
+export default class TasksTrust 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: {
+        level: 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/trust.js

@@ -0,0 +1,75 @@
+"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 trust <task> <expectation-id> --level <authority> --reason "<why>"`
+ *
+ * Move how much evidence one expectation demands.
+ *
+ * A DECISION, not an edit — which is why it is its own command rather than a
+ * field on `tasks update`. It is the one control that turns a refusal into a
+ * pass with no new work done, so a reader later has to be able to see that it
+ * happened and why. Buried in a list patch it would record neither.
+ *
+ * Lowering is the common direction and it is legitimate: a contract that cannot
+ * express "an agent's word is enough for this one" pushes its authors back to
+ * declaring nothing at all, which is the failure the whole feature exists to
+ * end. Raising takes the same reason and costs nothing to allow.
+ *
+ * The three levels, weakest first:
+ *   self_reported       whoever did the work says it is done
+ *   human_confirmed     someone else looked and said so
+ *   observation_backed  the platform saw it itself (a merge webhook, an upload)
+ */
+class TasksTrust extends base_command_1.BaseCommand {
+    static description = 'Set how much evidence one expectation demands, with a stated reason';
+    static examples = [
+        '<%= config.bin %> tasks trust <task-id> e1 --level self_reported --reason "Internal draft; nobody else needs to check it."',
+        '<%= config.bin %> tasks trust <task-id> e2 --level observation_backed --reason "Customer-facing; I want the platform to see it land."',
+    ];
+    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 = {
+        level: core_1.Flags.string({
+            options: [...data_provider_1.DELIVERABLE_AUTHORITIES],
+            required: true,
+            description: 'How well evidenced the answer must be: self_reported (the doer says so), ' +
+                'human_confirmed (someone else looked), observation_backed (the platform saw it).',
+        }),
+        reason: core_1.Flags.string({
+            required: true,
+            description: 'Why this bar. Required — it is the record.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksTrust);
+        let result;
+        try {
+            result = await data_provider_1.dataService.setTaskExpectationTrust(args.task, {
+                expectationId: args.expectation,
+                level: flags.level,
+                reason: flags.reason,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`${args.expectation} now needs ${flags.level}: ${flags.reason}`);
+    }
+}
+exports.default = TasksTrust;

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,

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

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks waive <task> <expectation-id> --reason "<why>"`
+ *
+ * Drop a requirement, on the record. The expectation is KEPT and marked, never
+ * deleted: deleting it expresses the same decision while destroying the only
+ * evidence that it was ever owed, which is what someone asking "why wasn't this
+ * done?" needs to read.
+ *
+ * The reason is required for the same purpose — a waiver without one is
+ * indistinguishable from having forgotten.
+ */
+export default class TasksWaive 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: {
+        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>;
+}