@skrr-ai/cli 0.1.37 → 0.1.38

package/dist/commands/tasks/lifecycle/migrate.js

@@ -5,15 +5,51 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 class TasksLifecycleMigrate extends base_command_1.BaseCommand {
     static description = 'Migrate a bound lifecycle to a newer published version, fencing the old generation';
-    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static examples = [
+        '<%= config.bin %> tasks lifecycle definitions OSK-1234   # where a --version comes from',
+        '<%= config.bin %> tasks lifecycle migrate OSK-1234 --version wfv_… --dry-run',
+    ];
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID or identifier' }),
+    };
     static flags = {
-        version: core_1.Flags.string({ required: true, description: 'Target WorkflowDefinition version id' }),
+        version: core_1.Flags.string({
+            required: true,
+            description: 'Target published version id — `tasks lifecycle definitions <task-id>` prints it',
+        }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Describe what migrating would do and exit without writing',
+        }),
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLifecycleMigrate);
         const taskId = await this.resolveTaskReference(args.id);
+        // Moving a Task between published protocols is not obviously reversible,
+        // and the old output said only that a run had started. A flag rather than a
+        // prompt, so the command stays usable from a script.
+        if (flags['dry-run']) {
+            let current;
+            try {
+                current = await data_provider_1.dataService.getTaskLifecycle(taskId);
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (flags.json)
+                return this.log(JSON.stringify({ dryRun: true, ...current }, null, 2));
+            const lifecycle = current.lifecycle;
+            if (!lifecycle)
+                return this.log('No lifecycle is attached to this Task — nothing to migrate.');
+            this.log(`Would migrate from version ${lifecycle.versionId} to ${flags.version}, as generation ` +
+                `${Number(lifecycle.generation) + 1}.`);
+            this.log(`  It re-enters at the CURRENT stage (${lifecycle.currentStageKey ?? '—'}) when that stage` +
+                " still exists on the target version; otherwise the protocol's entry stage decides.");
+            this.log('  The old generation is fenced — its run can no longer write.');
+            this.log('  Earlier generations stay readable in `tasks lifecycle history`.');
+            return;
+        }
         let result;
         try {
             result = await data_provider_1.dataService.migrateTaskLifecycle({ taskId, versionId: flags.version });
@@ -23,7 +59,10 @@ class TasksLifecycleMigrate extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(result, null, 2));
-        this.log(`Migrated lifecycle — run ${result.run.id} (${result.run.status}).`);
+        const lifecycle = result.lifecycle;
+        this.log(`Migrated to version ${lifecycle?.versionId ?? flags.version} — now generation ` +
+            `${lifecycle?.generation ?? '?'} at stage ${lifecycle?.currentStageKey ?? '—'}` +
+            ` (run ${result.run.id}, ${result.run.status}).`);
     }
 }
 exports.default = TasksLifecycleMigrate;

package/dist/commands/tasks/lifecycle/reopen.d.ts

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

package/dist/commands/tasks/lifecycle/reopen.js

@@ -5,16 +5,50 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 class TasksLifecycleReopen extends base_command_1.BaseCommand {
     static description = 'Fence the current lifecycle generation and reopen at an earlier stage';
-    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static examples = [
+        '<%= config.bin %> tasks lifecycle reopen OSK-1234 --dry-run',
+        '<%= config.bin %> tasks lifecycle reopen OSK-1234 --stage fix --reason "The fix did not take"',
+    ];
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID or identifier' }),
+    };
     static flags = {
         stage: core_1.Flags.string({ description: 'Stage key to re-enter at; defaults to the entry stage' }),
-        reason: core_1.Flags.string({ description: 'Why the lifecycle is reopening' }),
+        reason: core_1.Flags.string({ description: 'Why the lifecycle is reopening; recorded in history' }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Describe what reopening would do and exit without writing',
+        }),
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLifecycleReopen);
         const taskId = await this.resolveTaskReference(args.id);
+        // Reopen advances a generation and is not obviously reversible. A preview
+        // that names the target stage is cheaper than learning what it did by
+        // diffing state afterwards, and a flag keeps the command scriptable where
+        // an interactive prompt would not.
+        if (flags['dry-run']) {
+            let current;
+            try {
+                current = await data_provider_1.dataService.getTaskLifecycle(taskId);
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (flags.json)
+                return this.log(JSON.stringify({ dryRun: true, ...current }, null, 2));
+            const lifecycle = current.lifecycle;
+            if (!lifecycle)
+                return this.log('No lifecycle is attached to this Task — nothing to reopen.');
+            const entry = flags.stage || current.stages?.[0]?.key;
+            this.log(`Would reopen at stage ${entry ?? '(entry stage)'} as generation ${Number(lifecycle.generation) + 1}` +
+                ` (currently generation ${lifecycle.generation}, stage ${lifecycle.currentStageKey ?? '—'}).`);
+            this.log('  The current run is cancelled; its transitions stay readable in history.');
+            this.log("  A terminal Task is brought back to the entry stage's declared status.");
+            this.log('  Stages the earlier generation finished keep reading as done in that generation.');
+            return;
+        }
         let result;
         try {
             result = await data_provider_1.dataService.reopenTaskLifecycle({
@@ -28,7 +62,10 @@ class TasksLifecycleReopen extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(result, null, 2));
-        this.log(`Reopened lifecycle — run ${result.run.id} (${result.run.status}).`);
+        // Name where it landed, not just that it happened.
+        const lifecycle = result.lifecycle;
+        this.log(`Reopened at stage ${lifecycle?.currentStageKey ?? '—'} as generation ${lifecycle?.generation ?? '?'}` +
+            ` — run ${result.run.id} (${result.run.status}). The previous generation stays in history.`);
     }
 }
 exports.default = TasksLifecycleReopen;

package/dist/commands/tasks/lifecycle/transition.js

@@ -42,6 +42,23 @@ class TasksLifecycleTransition extends base_command_1.BaseCommand {
                 this.error('--payload must be a JSON object.', { exit: 2 });
             }
         }
+        /*
+         * The fence only protects the interval it is given.
+         *
+         * `--expected-revision` is the caller's claim about the state they DECIDED
+         * against. When it is omitted this command re-reads the lifecycle and sends
+         * back what it just read — and a compare-and-set whose expected value was
+         * fetched microseconds before the write can only catch that microsecond,
+         * never the interval that matters, which is between the human's read and
+         * their write. So the default is a convenience, not protection, and it was
+         * silent about that: a `confirm` decided at revision 0 applied against
+         * revision 1 and closed a Task, with nothing in the output saying the world
+         * had moved in between.
+         *
+         * Kept as the default because requiring a number on every call would be
+         * paid by everyone to protect a minority of flows — but it now says what it
+         * fenced on and how to fence properly.
+         */
         let expectedRevision = flags['expected-revision'];
         if (expectedRevision === undefined) {
             let current;
@@ -55,6 +72,10 @@ class TasksLifecycleTransition extends base_command_1.BaseCommand {
                 this.error('No lifecycle is attached to this Task.', { exit: 2 });
             }
             expectedRevision = current.lifecycle.revision;
+            if (!flags.json) {
+                this.log(`Fencing on revision ${expectedRevision}, read just now — not the revision you saw. ` +
+                    'Pass --expected-revision <n> to fence on the state you decided against.');
+            }
         }
         const idempotencyKey = flags['idempotency-key'] ?? `cli-lifecycle:${taskId}:${args.transition}:r${expectedRevision}`;
         let response;
@@ -71,8 +92,18 @@ class TasksLifecycleTransition extends base_command_1.BaseCommand {
             this.handleApiError(error);
         }
         if (flags.json)
-            return this.log(JSON.stringify(response, null, 2));
-        (0, task_lifecycle_output_1.renderLifecycleTransitionResult)(response, (line) => this.log(line));
+            this.log(JSON.stringify(response, null, 2));
+        else
+            (0, task_lifecycle_output_1.renderLifecycleTransitionResult)(response, (line) => this.log(line));
+        // Exit non-zero when the write did not land. `applied` is the only verdict
+        // that means the stage moved; `rejected`, `superseded` and `gated` all mean
+        // it did not. Exiting 0 on all four made
+        // `transition A && transition B` run B after A had been fenced off — which
+        // is precisely the lost update `expectedRevision` exists to prevent, waved
+        // through by the shell.
+        if (response.status !== 'applied') {
+            this.exit(1);
+        }
     }
 }
 exports.default = TasksLifecycleTransition;

package/dist/commands/tasks/list.js

@@ -146,13 +146,13 @@ function buildListParams(flags, assigneeUserId) {
         ...(flag('actionability-reason')
             ? { actionabilityReason: flag('actionability-reason') }
             : {}),
-        ...(flag('actionable-by') ||
-            flag('actionable-for-agent') ||
-            flag('needs-me') ||
-            flag('actionability-state') ||
-            flag('actionability-reason')
-            ? { includeActionability: true }
-            : {}),
+        // This table always renders a NEXT column, so it always has to ask for the
+        // data behind it. Requesting it only alongside an actionability FILTER left
+        // the default board printing a header with nothing under it — and a plain
+        // `tasks list` is exactly where a person looks to find out what anything is
+        // waiting for. The server computes it in one batched read, so the cost is
+        // a column that works rather than a column that is there.
+        includeActionability: true,
         ...(flag('priority') ? { priority: flag('priority') } : {}),
         ...(flag('estimate') !== undefined ? { estimate: flag('estimate') } : {}),
         ...(flag('min-estimate') !== undefined
@@ -427,8 +427,13 @@ class TasksList extends base_command_1.BaseCommand {
                 priority: String(t.priority ?? '-'),
                 estimate: t.estimate === null || t.estimate === undefined ? '-' : String(t.estimate),
                 assignees,
+                // `reason` is the sentence the server wrote for a person; `reasonCode`
+                // is the enum it wrote for a machine. Printing the code rendered every
+                // stage of every lifecycle as `human:lifecycle_stage` — six different
+                // waits, one string — while the sentence naming the stage sat unread in
+                // the same payload.
                 next: actionability
-                    ? `${String(actionability.nextActor ?? '-')}:${String(actionability.reasonCode ?? actionability.state ?? '-')}`
+                    ? `${String(actionability.nextActor ?? '-')}: ${String(actionability.reason || actionability.reasonCode || actionability.state || '-')}`
                     : String(t.executionMode ?? '-'),
                 match: String(t._matchField ?? '-'),
             };
@@ -440,7 +445,9 @@ class TasksList extends base_command_1.BaseCommand {
             { key: 'priority', header: 'PRIORITY' },
             { key: 'estimate', header: 'ESTIMATE' },
             { key: 'assignees', header: 'ASSIGNEES' },
-            { key: 'next', header: 'NEXT' },
+            // Bounded: the reason is a sentence, and an unbounded column wraps the
+            // table into unreadability on a narrow terminal.
+            { key: 'next', header: 'NEXT', maxWidth: 46 },
             // Only meaningful on a search — the server computes it from the same
             // relevance rank that orders the rows, and a plain listing has none.
             ...(flags.q ? [{ key: 'match', header: 'MATCH' }] : []),

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");
@@ -155,19 +156,16 @@ class TasksMove extends base_command_1.BaseCommand {
         // 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;
-        if (resolutionClosure?.overrode?.includes('TASK_RESULT_REVIEW_REQUIRED')) {
-            this.log('  Closed past the owner-declared required Review — the override is recorded (resolution.closure.overrode).');
-        }
-        if (resolutionClosure?.closable === false) {
-            const parts = [];
-            const unmet = resolutionClosure.expectations?.unmet?.length ?? 0;
-            if (unmet > 0) {
-                parts.push(`${unmet} Expectation${unmet === 1 ? '' : 's'} still unmet`);
-            }
-            parts.push(...(resolutionClosure.blockers || []).filter((code) => code !== 'TASK_EXPECTATIONS_NOT_MET' && code !== 'TASK_RESULT_REVIEW_REQUIRED'));
-            if (parts.length) {
-                this.log(`  Closed over ${parts.join('; ')} (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}`);
         }
     }
     /**

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

@@ -23,7 +23,22 @@ export default class TasksReviewQueue extends BaseCommand {
         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

@@ -35,6 +35,9 @@ class TasksReviewQueue extends base_command_1.BaseCommand {
             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() {
@@ -66,7 +69,27 @@ class TasksReviewQueue extends base_command_1.BaseCommand {
             // 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 (;;) {
@@ -80,8 +103,12 @@ class TasksReviewQueue extends base_command_1.BaseCommand {
                         'say whether anything is owed. Refusing to report an empty queue.', { exit: 1 });
                 }
                 tasks.push(...response.data);
-                if (!response.has_more || !response.next_cursor || tasks.length >= flags.limit)
+                if (!response.has_more || !response.next_cursor)
+                    break;
+                if (tasks.length >= flags.limit) {
+                    truncated = true;
                     break;
+                }
                 cursor = response.next_cursor;
             }
         }
@@ -95,34 +122,101 @@ class TasksReviewQueue extends base_command_1.BaseCommand {
          * worse than no queue: the reviewer would believe they had seen everything.
          */
         const rows = [];
-        for (const task of tasks) {
-            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)
-                    rows.push({ ...base, awaiting });
-            }
-            catch (error) {
-                rows.push({ ...base, awaiting: [], error: error?.message || 'unreadable' });
+        /*
+         * 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, tasks: visible }, null, 2));
+            this.log(JSON.stringify({
+                space: flags.space,
+                inspected: candidates.length,
+                truncated,
+                ...(skippedClosed > 0 ? { skippedClosed } : {}),
+                owedTasks: rows.length,
+                tasks: visible,
+            }, null, 2));
             return;
         }
-        if (visible.length === 0) {
+        /*
+         * "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;
@@ -133,18 +227,37 @@ class TasksReviewQueue extends base_command_1.BaseCommand {
                 this.log(`  could not read its Expectations: ${row.error}`);
                 continue;
             }
-            // A Task with no Result yet is listed but marked: its Expectations are
-            // owed, and settling them still leaves it unclosable. Saying so here stops
-            // a reviewer working through a list that cannot finish.
+            /*
+             * 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 — settling these will not close it');
+                this.log('  no Result submitted yet — nothing to judge the work against');
             }
             for (const expectation of row.awaiting) {
                 total += 1;
-                const settledBy = expectation.assessedByKind
-                    ? ` [last judged by ${(0, task_closure_1.describeAssessor)(expectation.assessedByKind)}]`
-                    : '';
-                this.log(`  ${expectation.id}  ${expectation.sentence || expectation.text || ''}${settledBy}`);
+                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})` : ''}`);
                 }
@@ -155,11 +268,47 @@ class TasksReviewQueue extends base_command_1.BaseCommand {
         }
         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)
  *