@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/tasks/move.js

@@ -5,6 +5,7 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("../../lib/api-fetch");
 const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
 const base_command_1 = require("../../base-command");
+const task_closure_1 = require("../../lib/task-closure");
 const web_url_1 = require("../../lib/web-url");
 const task_resolver_1 = require("../../lib/task-resolver");
 const projects_1 = require("../../lib/projects");
@@ -52,6 +53,9 @@ class TasksMove extends base_command_1.BaseCommand {
             description: 'Who can resolve the exceptional hold',
             options: ['human', 'agent', 'system', 'external'],
         }),
+        force: core_1.Flags.boolean({
+            description: "Close past an owner-declared required Review as a non-owner; the override is recorded on the task's resolution",
+        }),
     };
     async run() {
         this.requireAuth();
@@ -100,6 +104,7 @@ class TasksMove extends base_command_1.BaseCommand {
                             status: flags.status,
                             ...(flags.reason ? { reason: flags.reason } : {}),
                             ...(flags['resolution-actor'] ? { resolutionActor: flags['resolution-actor'] } : {}),
+                            ...(flags.force ? { force: true } : {}),
                         },
                     }));
                     updated = res.task;
@@ -110,6 +115,7 @@ class TasksMove extends base_command_1.BaseCommand {
                         status: flags.status,
                         reason: flags.reason,
                         resolutionActor: flags['resolution-actor'],
+                        force: flags.force === true ? true : undefined,
                     });
                 }
             }
@@ -138,6 +144,29 @@ class TasksMove extends base_command_1.BaseCommand {
             destinations.push(await this.describeProjectDestination(projectId, t));
         }
         this.log(`Moved task ${t.id ?? t._id ?? taskIdentity.id}${ref ? ` (${ref})` : ''} → ${destinations.join(', ')}`);
+        /*
+         * Closing is the actor's call — the server does not refuse outstanding
+         * work, it records it on `resolution.closure`. If the close just written
+         * left things unsettled, say so here so the output and the durable record
+         * tell the same story rather than letting "done" launder open items.
+         */
+        // Read through the SHARED vocabulary. This carried a local structural cast
+        // while `overrode` was missing from `Task['resolution']['closure']` — which
+        // is exactly how one surface comes to know a field the type does not. `t` is
+        // the loosely-typed receipt, so the narrowing cast stays; what matters is
+        // that the shape it names is the one data-provider owns.
+        const resolutionClosure = t.resolution?.closure;
+        /*
+         * Through the shared renderer. This hand-rolled the rendering and pushed
+         * blocker CODES at a human — `Closed over TASK_RESULT_REQUIRED`, which is a
+         * wire identifier and, read plainly, the opposite of what just happened. The
+         * worst instance was the one this batch cares most about: a Task closed over
+         * a reviewer's objection printed `TASK_RESULT_CHANGES_REQUESTED`, rendering
+         * "somebody looked and objected" as an identifier.
+         */
+        for (const sentence of (0, task_closure_1.closureSnapshotLines)(resolutionClosure)) {
+            this.log(`  ${sentence}`);
+        }
     }
     /**
      * Name the project the receipt lands in, resolving its title from the task's

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

@@ -7,6 +7,7 @@ const outbox_1 = require("../../../lib/outbox");
 const task_resolver_1 = require("../../../lib/task-resolver");
 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_endpoints_1 = require("../../../lib/session-task-endpoints");
 function parseJson(value, label) {
     if (!value)
@@ -126,7 +127,16 @@ class TasksResultSubmit extends base_command_1.BaseCommand {
         const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: task.id });
         if (flags.json)
             return this.log(JSON.stringify({ ...result, url }, null, 2));
-        this.log(`Submitted Result v${result.result.version} for ${task.id}; it is ready for review.`);
+        // Say what came back, never what we hope came back.
+        //
+        // This line used to read "...; it is ready for review." unconditionally,
+        // which was false for every Task with an unassessed Expectation — and the
+        // managed instructions told the agent to read the status the call returns,
+        // 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} for ${task.id}.`);
+        for (const line of (0, task_closure_1.closureReport)(result.closure))
+            this.log(line);
         if (url)
             this.log(`Task: ${url}`);
     }

package/dist/commands/tasks/review-queue.d.ts

@@ -0,0 +1,44 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Everything in one Space that is waiting on a judgement, in one pass.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * An agent fans out. One session routinely produces nine Tasks carrying twenty
+ * or more Expectations, and every surface for settling them was built for one
+ * Task at a time — so the cost of CLOSING the work grew linearly with how well
+ * the work was DECOMPOSED, which punishes exactly the decomposition the product
+ * wants. Finding what was owed meant knowing that `tasks expectations` exists
+ * and running it per Task, having first worked out which Tasks to run it on.
+ *
+ * This is a read. It changes nothing, it names every outstanding judgement in
+ * the Space with the evidence already bound to it, and it prints the exact
+ * command that settles each one — so a reviewer can work down a list instead of
+ * reconstructing it.
+ */
+export default class TasksReviewQueue extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        space: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        actionable: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'include-closed': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    /**
+     * An empty queue must not be how you learn a Space id is wrong.
+     *
+     * A UUID-shaped ref is accepted without a lookup (`base-command` short-circuits
+     * on the SHAPE, which is a cheap and correct optimisation nearly everywhere),
+     * and the list route deliberately never 404s — an unknown Space falls back to
+     * the ACL enumeration and returns an honest empty page. Those two reasonable
+     * decisions compose into "Nothing is awaiting a judgement", exit 0, for a
+     * Space that does not exist. A typo read as done.
+     *
+     * So the existence check is paid for ONLY on the path that is about to make
+     * the completeness claim — never on the path that found work.
+     */
+    private assertSpaceExists;
+}

package/dist/commands/tasks/review-queue.js

@@ -0,0 +1,314 @@
+"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_closure_1 = require("../../lib/task-closure");
+const web_url_1 = require("../../lib/web-url");
+/**
+ * Everything in one Space that is waiting on a judgement, in one pass.
+ *
+ * WHY THIS EXISTS
+ * ---------------
+ * An agent fans out. One session routinely produces nine Tasks carrying twenty
+ * or more Expectations, and every surface for settling them was built for one
+ * Task at a time — so the cost of CLOSING the work grew linearly with how well
+ * the work was DECOMPOSED, which punishes exactly the decomposition the product
+ * wants. Finding what was owed meant knowing that `tasks expectations` exists
+ * and running it per Task, having first worked out which Tasks to run it on.
+ *
+ * This is a read. It changes nothing, it names every outstanding judgement in
+ * the Space with the evidence already bound to it, and it prints the exact
+ * command that settles each one — so a reviewer can work down a list instead of
+ * reconstructing it.
+ */
+class TasksReviewQueue extends base_command_1.BaseCommand {
+    static description = 'Every Expectation in a Space still awaiting a judgement, with its evidence and the command that settles it';
+    static examples = [
+        '<%= config.bin %> tasks review-queue --space <space-id>',
+        '<%= config.bin %> tasks review-queue --space <space-id> --json',
+        '<%= config.bin %> tasks review-queue --space <space-id> --actionable',
+    ];
+    static flags = {
+        space: core_1.Flags.string({ description: 'Space id', required: true }),
+        actionable: core_1.Flags.boolean({
+            description: 'Only Tasks where a Result is already in — the ones a reviewer can act on',
+        }),
+        limit: core_1.Flags.integer({ description: 'Maximum Tasks to inspect (default 100)', default: 100 }),
+        'include-closed': core_1.Flags.boolean({
+            description: 'Also list Tasks already closed — for auditing what was closed over',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(TasksReviewQueue);
+        /**
+         * `response.data`, read from the TYPE rather than guessed.
+         *
+         * The first version of this read `response.tasks`, which does not exist —
+         * and the failure was silent in the worst possible direction: an empty array
+         * printed "Nothing is awaiting a judgement" for a Space with twenty-three
+         * unassessed Expectations. A reviewer would have believed they were done.
+         *
+         * `COMMAND_INDEX.md` warns about exactly this ("read the wrong key and you
+         * get an empty result rather than an error, which looks exactly like 'no
+         * rows matched'"). So the shape is taken from `TaskListResponse` and a
+         * missing envelope is an ERROR, never an empty queue: this command's whole
+         * value is telling someone there is nothing left, and it may only say that
+         * when it actually looked.
+         */
+        /*
+         * Follow the cursor — a truncated list is the same silent false negative
+         * as a misread envelope, one page later. This command's whole value is
+         * "there is nothing left," and a tail it never saw breaks that claim.
+         * `--limit` caps how many Tasks get inspected, not how many pages get read.
+         */
+        if (flags.limit < 1) {
+            // Inspecting zero Tasks and then saying "nothing is owed" is the exact
+            // unlooked-for empty answer this command refuses to give.
+            this.error('--limit must be at least 1.', { exit: 1 });
+        }
+        /*
+         * oclif's `required: true` asserts the flag was SUPPLIED, not that it says
+         * anything. `--space ""` — an unset shell variable, which is how it happens
+         * — satisfied it, and the empty string was then dropped from the query
+         * string as falsy, so the command silently widened from one Space to every
+         * Space the caller can see and reported that as the answer.
+         */
+        if (!flags.space.trim()) {
+            this.error('--space needs a Space id; it was given an empty value.', { exit: 1 });
+        }
+        const tasks = [];
+        /*
+         * Whether the scan actually reached the end.
+         *
+         * The loop already followed the cursor, and then stopped at `--limit` with
+         * `has_more` still true and threw that fact away — so a Space with 95 owed
+         * Expectations reported on the first 11 and printed the same sentence it
+         * prints for a Space that owes nothing. The comment above states the
+         * principle this had to satisfy; nothing recorded whether it had.
+         */
+        let truncated = false;
+        try {
+            let cursor;
+            for (;;) {
+                const response = await data_provider_1.dataService.listTasks({
+                    spaceId: flags.space,
+                    limit: Math.min(100, flags.limit - tasks.length),
+                    ...(cursor ? { cursor } : {}),
+                });
+                if (!response || !Array.isArray(response.data)) {
+                    this.error('The task list came back in a shape this command does not recognise, so it cannot ' +
+                        'say whether anything is owed. Refusing to report an empty queue.', { exit: 1 });
+                }
+                tasks.push(...response.data);
+                if (!response.has_more || !response.next_cursor)
+                    break;
+                if (tasks.length >= flags.limit) {
+                    truncated = true;
+                    break;
+                }
+                cursor = response.next_cursor;
+            }
+        }
+        catch (error) {
+            this.handleApiError(error);
+            return;
+        }
+        /**
+         * Acceptance is read per Task, and a Task whose acceptance cannot be read is
+         * REPORTED rather than dropped. A queue that silently omitted a row would be
+         * worse than no queue: the reviewer would believe they had seen everything.
+         */
+        const rows = [];
+        /*
+         * A finished Task is not a worklist item.
+         *
+         * Closing is the closer's call now, so a Task can reach `done` over
+         * Expectations nobody judged — and those rows stayed in the queue forever,
+         * captioned in the present tense ("settling these will not close it") about
+         * something already closed. Every forced close permanently added noise to
+         * the list a reviewer is supposed to work down. `--include-closed` keeps the
+         * old view for anyone auditing what was closed over.
+         */
+        const CLOSED_STATUS_TYPES = new Set(['completed', 'cancelled']);
+        const candidates = tasks.filter((task) => flags['include-closed'] || !CLOSED_STATUS_TYPES.has(String(task.statusType ?? '')));
+        const skippedClosed = tasks.length - candidates.length;
+        /*
+         * Acceptance is one request per Task and there is no batch endpoint, so the
+         * serial loop this replaces took 61 seconds on 100 Tasks and printed nothing
+         * at all until it finished. Bounded rather than `Promise.all`: 100
+         * simultaneous authorized reads hit the same cascade the `/cards` endpoint
+         * exists to avoid. Results are written by INDEX so output order stays the
+         * list's order regardless of which request returns first.
+         */
+        const ACCEPTANCE_CONCURRENCY = 6;
+        const settled = new Array(candidates.length).fill(null);
+        let next = 0;
+        const worker = async () => {
+            for (;;) {
+                const index = next;
+                next += 1;
+                if (index >= candidates.length)
+                    return;
+                const task = candidates[index];
+                const taskId = String(task.id ?? task._id ?? '');
+                if (!taskId)
+                    continue;
+                const base = {
+                    taskId,
+                    identifier: String(task.identifier ?? taskId),
+                    title: String(task.title ?? '(untitled)'),
+                    status: String(task.status ?? '-'),
+                    hasResult: Boolean(task.currentResultId),
+                };
+                try {
+                    const acceptance = await data_provider_1.dataService.getTaskAcceptance(taskId);
+                    const awaiting = acceptance.expectations.filter((e) => e.gating && !e.met);
+                    if (awaiting.length > 0)
+                        settled[index] = { ...base, awaiting };
+                }
+                catch (error) {
+                    settled[index] = {
+                        ...base,
+                        awaiting: [],
+                        error: error?.message || 'unreadable',
+                    };
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(ACCEPTANCE_CONCURRENCY, candidates.length) }, worker));
+        rows.push(...settled.filter((row) => row !== null));
+        const visible = flags.actionable ? rows.filter((row) => row.hasResult || row.error) : rows;
+        if (flags.json) {
+            this.log(JSON.stringify({
+                space: flags.space,
+                inspected: candidates.length,
+                truncated,
+                ...(skippedClosed > 0 ? { skippedClosed } : {}),
+                owedTasks: rows.length,
+                tasks: visible,
+            }, null, 2));
+            return;
+        }
+        /*
+         * "Nothing is owed" may only be said by a scan that reached the end.
+         *
+         * One sentence used to cover four different states — a clean queue, a
+         * truncated scan, a filter that emptied the list, and a Space that does not
+         * exist — and in three of them it was false. Each now says its own thing,
+         * and the two that cannot support the claim refuse to make it, in the same
+         * shape as the misread-envelope guard above.
+         */
+        if (truncated && rows.length === 0) {
+            this.error(`Inspected only the first ${candidates.length} Task(s) of a longer list in ${flags.space}, ` +
+                'so it cannot say whether anything is owed. Refusing to report an empty queue. ' +
+                'Re-run with a larger --limit.', { exit: 1 });
+        }
+        if (rows.length === 0) {
+            await this.assertSpaceExists(flags.space);
+            this.log(`Nothing in ${flags.space} is awaiting a judgement.`);
+            if (skippedClosed > 0) {
+                this.log(`  (${skippedClosed} closed Task(s) skipped — see them with --include-closed.)`);
+            }
+            return;
+        }
+        if (visible.length === 0) {
+            this.log(`${rows.length} Task(s) in ${flags.space} owe judgements, but none has a Result yet — ` +
+                're-run without --actionable to see them.');
+            return;
+        }
+        let total = 0;
+        for (const row of visible) {
+            this.log('');
+            this.log(`${row.identifier}  ${row.title}`);
+            if (row.error) {
+                this.log(`  could not read its Expectations: ${row.error}`);
+                continue;
+            }
+            /*
+             * State the fact, not a gate. This read "no Result submitted yet — settling
+             * these will not close it", which implied that a Result is what stands
+             * between these judgements and a close. Since `56a6ded703` it is not: a
+             * Task closes without one and the absence is recorded on
+             * `resolution.closure`. What a reviewer needs to know is only that there is
+             * no Result to judge the work against yet.
+             */
+            if (!row.hasResult) {
+                this.log('  no Result submitted yet — nothing to judge the work against');
+            }
+            for (const expectation of row.awaiting) {
+                total += 1;
+                this.log(`  ${expectation.id}  ${expectation.sentence || expectation.text || ''}`);
+                /*
+                 * The judgement itself, not just the KIND of judge.
+                 *
+                 * `[last judged by person]` named no person, no decision, no date and no
+                 * reason — so a reviewer working down this list could see that someone
+                 * had looked and not what they concluded, which is the one thing they
+                 * need before looking again. The acceptance projection carries all of it
+                 * now; this is where it was being dropped.
+                 */
+                if (expectation.assessedByKind) {
+                    const decision = expectation.decision || 'judged';
+                    const when = expectation.assessedAt
+                        ? ` on ${String(expectation.assessedAt).slice(0, 10)}`
+                        : '';
+                    const why = expectation.reason ? `: ${expectation.reason}` : '';
+                    this.log(`      ${decision} by ${(0, task_closure_1.describeAssessor)(expectation.assessedByKind)}${when}${why}`);
+                }
+                if (expectation.evidenceLevel) {
+                    this.log(`      evidence: ${expectation.evidenceLevel}${expectation.requiredEvidence ? ` (asked for ${expectation.requiredEvidence})` : ''}`);
+                }
+            }
+            const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: row.taskId });
+            if (url)
+                this.log(`  ${url}`);
+        }
+        this.log('');
+        this.log(`${total} Expectation(s) awaiting a judgement across ${visible.length} Task(s).`);
+        if (truncated) {
+            this.log(`Only the first ${candidates.length} Task(s) were inspected and more remain — ` +
+                're-run with a larger --limit to see the rest.');
+        }
+        if (skippedClosed > 0) {
+            this.log(`${skippedClosed} closed Task(s) skipped — see them with --include-closed.`);
+        }
+        this.log('');
+        this.log('Settle one:   skrr tasks expectations assess <task-id> <expectation-id> \\');
+        this.log('                --decision met --reason "..."');
+        this.log('Settle a Task: skrr tasks expectations assess <task-id> --all \\');
+        this.log('                --decision met --reason "..."');
+    }
+    /**
+     * An empty queue must not be how you learn a Space id is wrong.
+     *
+     * A UUID-shaped ref is accepted without a lookup (`base-command` short-circuits
+     * on the SHAPE, which is a cheap and correct optimisation nearly everywhere),
+     * and the list route deliberately never 404s — an unknown Space falls back to
+     * the ACL enumeration and returns an honest empty page. Those two reasonable
+     * decisions compose into "Nothing is awaiting a judgement", exit 0, for a
+     * Space that does not exist. A typo read as done.
+     *
+     * So the existence check is paid for ONLY on the path that is about to make
+     * the completeness claim — never on the path that found work.
+     */
+    async assertSpaceExists(spaceId) {
+        try {
+            await data_provider_1.dataService.getSpace(spaceId);
+        }
+        catch (error) {
+            // The status rides the error itself here, the way `base-command` reads it
+            // (`e.status === 404`) — not on a nested `response`.
+            const status = error?.status;
+            if (status === 404 || status === 403) {
+                this.error(`No Space ${spaceId} is visible to you, so there is nothing to report on. ` +
+                    'Check the id with `skrr spaces list`.', { exit: 2 });
+            }
+            // Any other failure is about this read, not about the Space. Let the
+            // empty answer stand rather than turning a blip into a false "not found".
+        }
+    }
+}
+exports.default = TasksReviewQueue;

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

@@ -1,4 +1,15 @@
 import { BaseCommand } from '../../base-command';
+/**
+ * Where to look next — as COMMANDS, not as facts about the task.
+ *
+ * These used to print as `What the agent produced: skrr tasks output <ref>`,
+ * in the same `Label: value` grammar as every line above them, so the line read
+ * as a statement of what the agent had produced. It also printed on tasks no
+ * agent had ever run, asserting output that did not exist (OSK-9669). They are
+ * now a visibly separate list, and only once a run, a conversation or a Result
+ * exists for them to show.
+ */
+export declare function taskPointerLines(t: Record<string, unknown>, ref: string, bin?: string): string[];
 /**
  * The failure rows of `tasks show`, when there are any. (S3 dogfood finding)
  *

package/dist/commands/tasks/show.js

@@ -1,14 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskPointerLines = taskPointerLines;
 exports.taskFailureLines = taskFailureLines;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const api_fetch_1 = require("../../lib/api-fetch");
 const session_task_endpoints_1 = require("../../lib/session-task-endpoints");
 const base_command_1 = require("../../base-command");
+const task_closure_1 = require("../../lib/task-closure");
 const task_resolver_1 = require("../../lib/task-resolver");
 const web_url_1 = require("../../lib/web-url");
 const html_text_1 = require("../../lib/html-text");
+/**
+ * Where to look next — as COMMANDS, not as facts about the task.
+ *
+ * These used to print as `What the agent produced: skrr tasks output <ref>`,
+ * in the same `Label: value` grammar as every line above them, so the line read
+ * as a statement of what the agent had produced. It also printed on tasks no
+ * agent had ever run, asserting output that did not exist (OSK-9669). They are
+ * now a visibly separate list, and only once a run, a conversation or a Result
+ * exists for them to show.
+ */
+function taskPointerLines(t, ref, bin = 'skrr') {
+    const hasSomethingToShow = Boolean(t.conversationId || t.lastFinalizedRunId || t.checkoutRunId || t.currentResultId);
+    if (!hasSomethingToShow)
+        return [];
+    const pointers = [
+        [`${bin} tasks output ${ref}`, 'what the agent produced'],
+    ];
+    if (t.conversationId) {
+        pointers.push([`${bin} tasks transcript ${ref}`, 'the full agent transcript']);
+    }
+    const width = Math.max(...pointers.map(([command]) => command.length));
+    return [
+        '',
+        'See also:',
+        ...pointers.map(([command, what]) => `  ${command.padEnd(width)}  ${what}`),
+    ];
+}
 /**
  * The failure rows of `tasks show`, when there are any. (S3 dogfood finding)
  *
@@ -173,6 +202,87 @@ class TasksShow extends base_command_1.BaseCommand {
         // question and this is the answer to it.
         for (const line of taskFailureLines(t, this.config.bin))
             this.log(line);
+        /*
+         * Closing is the actor's call — a Task may be `done` with work still
+         * outstanding, and `resolution.closure` is where the server recorded what
+         * it stood on at close. Show it so a bare "done" never reads as "clean."
+         */
+        const resolution = t.resolution;
+        /*
+         * Same renderer as the `tasks move` receipt, so the two cannot disagree
+         * about a Task they are both describing.
+         *
+         * This copy showed an owner's ordinary close as an override:
+         * `TASK_RESULT_REVIEW_REQUIRED` lands in `blockers` whenever the policy is
+         * unsatisfied — including when the owner, who is not bound by the Review
+         * they declared, closes it themselves — and this rendered it identically to
+         * a genuine forced close. So the only read surface for "was this gate
+         * overridden?" could not answer the question.
+         */
+        if (resolution?.closure) {
+            const sentences = (0, task_closure_1.closureSnapshotLines)(resolution.closure);
+            if (sentences.length > 0) {
+                this.log(`Resolution:  ${resolution.kind ?? '-'} — ${sentences.join(' ')}`);
+            }
+        }
+        /*
+         * A Result orphaned by a spec edit is not the same as no Result.
+         *
+         * Editing a `description` or an Expectation advances `specVersion`, which
+         * unsets `currentResultId` by design — the old answer replied to a question
+         * that has changed. But every CLI surface then reported the Task as though
+         * nothing had ever been submitted, and the prior Result is still there. The
+         * web already says this correctly ("No Result answers the current Task spec
+         * vN", plus the previous one); the CLI said nothing at all.
+         *
+         * The extra request is paid only in the ambiguous case — when there is no
+         * current Result — and `tasks show` is a detail view, so one call to
+         * distinguish "nobody answered" from "the answer is out of date" is worth
+         * it. A failed lookup degrades to silence rather than to a claim.
+         */
+        const taskSpecVersion = Number(t.specVersion) || 1;
+        if (t.currentResultId) {
+            this.log(`Result:      ${String(t.currentResultId)} (answers spec v${taskSpecVersion})`);
+            /*
+             * The Review on that Result, with its REASON.
+             *
+             * Closing over a `changes_requested` Review is allowed and recorded, and
+             * the closure line says "a reviewer requested changes" — the verdict. What
+             * they asked for lived only on the Review row, which no text surface
+             * printed, so the objection survived as a fact and lost its content. One
+             * read, on a detail view, only when there is a Result to have been
+             * reviewed; a failed read says nothing rather than implying no Review.
+             */
+            try {
+                const history = await data_provider_1.dataService.listTaskResults(taskIdentity.id);
+                const review = (history?.reviews || []).find((row) => row.resultId === String(t.currentResultId));
+                if (review) {
+                    const who = (0, task_closure_1.describeAssessor)(review.reviewedBy?.kind);
+                    const when = review.reviewedAt ? ` on ${String(review.reviewedAt).slice(0, 10)}` : '';
+                    const why = review.rationale ? `: ${review.rationale}` : '';
+                    this.log(`Review:      ${review.decision} by ${who}${when}${why}`);
+                }
+            }
+            catch {
+                // Silence, not "no Review": this read failing is not evidence of absence.
+            }
+        }
+        else {
+            let priorLine = 'none submitted';
+            try {
+                const history = await data_provider_1.dataService.listTaskResults(taskIdentity.id);
+                const prior = history?.results?.[0];
+                if (prior) {
+                    priorLine =
+                        `none answers spec v${taskSpecVersion} — previous v${prior.version} ` +
+                            `answered spec v${prior.specVersion ?? '?'}`;
+                }
+            }
+            catch {
+                priorLine = 'none answers the current spec (earlier Results could not be read)';
+            }
+            this.log(`Result:      ${priorLine}`);
+        }
         this.log(`Executor:    ${t.executionMode ?? 'legacy / inferred'}`);
         this.log(`Priority:    ${t.priority ?? '-'}`);
         this.log(`Parent:      ${t.parentId ?? '-'}`);
@@ -291,11 +401,36 @@ class TasksShow extends base_command_1.BaseCommand {
             }
         }
         const ref = String(t.id ?? t._id ?? taskIdentity.id);
-        this.log('');
-        this.log(`What the agent produced: skrr tasks output ${ref}`);
-        if (t.conversationId) {
-            this.log(`Full agent transcript:   skrr tasks transcript ${ref}`);
+        /**
+         * Where this Task stands, on the surface people already open.
+         *
+         * `tasks expectations <id>` answers this well and is reachable only if you
+         * already know it exists — its one pointer lives in the `--expect` help of
+         * `tasks create`, which you read while AUTHORING and not while closing. So
+         * an agent that submitted a Result had no cheap way to learn the Task was
+         * still owed, and reasonably concluded from the CLI's own output that it was
+         * not. Say it here, where the question is actually asked.
+         *
+         * Read, not recomputed, and never fatal: a Task page must still render when
+         * the acceptance read fails, and it must not invent a state it could not
+         * fetch.
+         */
+        try {
+            const acceptance = await data_provider_1.dataService.getTaskAcceptance(ref);
+            const gating = acceptance.expectations.filter((e) => e.gating);
+            if (gating.length > 0) {
+                const settled = gating.filter((e) => e.met).length;
+                this.log('');
+                this.log(`Expectations: ${settled} of ${gating.length} settled  ·  overall: ${acceptance.state}` +
+                    (settled < gating.length ? `  —  skrr tasks expectations ${ref}` : ''));
+            }
         }
+        catch {
+            // Silent: a Task this caller can VIEW but whose acceptance they cannot
+            // read is a permissions shape, not something to shout about mid-page.
+        }
+        for (const line of taskPointerLines(t, ref, this.config.bin))
+            this.log(line);
     }
 }
 exports.default = TasksShow;

package/dist/commands/tasks/trust.js

@@ -41,8 +41,13 @@ class TasksTrust extends base_command_1.BaseCommand {
         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).',
+            description: 
+            // `observation_backed` is a RETIRED rung name for this domain — the flag
+            // rejects it, so the only two values the help explained were one real one
+            // and one the command refuses. The four the enum actually accepts:
+            'How well evidenced the answer must be: self_reported (the doer says so), ' +
+                'human_confirmed (a person confirmed it), system_observed (the platform saw it), ' +
+                'external_receipt (a provider receipt proves it).',
         }),
         reason: core_1.Flags.string({
             required: true,

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>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         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>;