@skrr-ai/cli 0.1.23 → 0.1.24

package/dist/commands/spaces/work-sync/telemetry.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const work_sync_1 = require("../../../lib/work-sync");
+/**
+ * `skrr spaces work-sync telemetry <space>` — Work Sync's own exit criteria.
+ *
+ * Work Sync v1 is ON at 100% (owner decision, 2026-09-08) with two criteria
+ * knowingly overridden rather than satisfied. The server has computed the verdict
+ * the whole time, and nothing outside the API could read it — so checking the
+ * criteria meant querying the production database by hand, which is why nobody
+ * did. An exit criterion that can only be read by hand is one that does not get
+ * read.
+ *
+ * The verdict is printed as the server decided it. This command does not
+ * re-derive it: the same rule that keeps `tasks expectations` reading the server's
+ * judgement rather than computing its own applies here, and for the same reason —
+ * a CLI that reached a different conclusion from the service would leave the
+ * reader unable to tell which was lying.
+ */
+class SpacesWorkSyncTelemetry extends base_command_1.BaseCommand {
+    static description = "Show Work Sync's convergence telemetry for a Space and the server's rollout verdict";
+    static examples = [
+        '<%= config.bin %> spaces work-sync telemetry <space-id>',
+        '<%= config.bin %> spaces work-sync telemetry <space-id> --json',
+    ];
+    static args = {
+        space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        limit: core_1.Flags.integer({
+            description: 'Most recent telemetry rows to summarize (1-10000, default 5000)',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SpacesWorkSyncTelemetry);
+        let summary;
+        try {
+            summary = await (0, work_sync_1.fetchWorkSyncTelemetrySummary)(args.space, { limit: flags.limit });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(summary, null, 2));
+            return;
+        }
+        this.log(`Verdict:       ${summary.rollout.verdict}`);
+        this.log(`Sampled rows:  ${summary.sampledEvents}`);
+        this.log(`Repair backlog: ${summary.repairBacklog}`);
+        // Zero sampled rows is a REAL answer and the most misread one: it means
+        // nothing has been measured in this Space, not that everything is fine. The
+        // server already distinguishes it (`insufficient_evidence`); say so here too
+        // rather than printing an empty table under a clean-looking verdict.
+        if (summary.sampledEvents === 0) {
+            this.log('');
+            this.log('No telemetry has been recorded for this Space. That is not evidence of health — ' +
+                'it means no board in this Space has reported, so nothing has been measured.');
+            return;
+        }
+        const rows = Object.entries(summary.events).sort(([a], [b]) => a.localeCompare(b));
+        if (rows.length > 0) {
+            this.log('');
+            this.log('Events:');
+            for (const [event, stats] of rows) {
+                const parts = [`count ${stats.count}`];
+                if (stats.mismatchCount > 0)
+                    parts.push(`mismatches ${stats.mismatchCount}`);
+                if (stats.p50DurationMs !== null) {
+                    parts.push(`p50 ${stats.p50DurationMs}ms`, `p95 ${stats.p95DurationMs}ms`);
+                }
+                if (stats.p50Bytes !== null) {
+                    parts.push(`p50 ${stats.p50Bytes}B`, `p95 ${stats.p95Bytes}B`);
+                }
+                this.log(`  ${event.padEnd(20)} ${parts.join(' · ')}`);
+            }
+        }
+        if (summary.rollout.reasons.length > 0) {
+            this.log('');
+            this.log('Holding because:');
+            for (const reason of summary.rollout.reasons) {
+                // An unexplained code is the thing this command exists to avoid: the
+                // reader is being told a rollout is held and needs to know by what.
+                this.log(`  ${reason}`);
+                const explanation = work_sync_1.WORK_SYNC_HOLD_REASONS[reason];
+                if (explanation)
+                    this.log(`    ${explanation}`);
+            }
+        }
+    }
+}
+exports.default = SpacesWorkSyncTelemetry;

package/dist/commands/tasks/activity.js

@@ -6,6 +6,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const format_1 = require("../../lib/format");
+const task_legacy_1 = require("../../lib/task-legacy");
 function activityRow(entry) {
     const actor = entry.actor;
     const actorText = actor
@@ -110,7 +111,10 @@ class TasksActivity extends base_command_1.BaseCommand {
         const r = response;
         const items = r?.data ?? [];
         if (items.length === 0) {
-            this.log('No activity.');
+            // "No activity." was a claim about the TASK. It is only ever a claim about
+            // this VIEW: a Task predating the canonical model has its history in the
+            // legacy activity log, which this endpoint does not read.
+            this.log(await (0, task_legacy_1.emptyCanonicalView)(args.id, 'Activity'));
             return;
         }
         (0, format_1.renderTable)(items.map(activityRow), [

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

@@ -1,9 +1,13 @@
 import { BaseCommand } from '../../base-command';
-export declare function describePendingReview({ statusType, taskId, resultId, bin, }: {
+export declare function describePendingReview({ statusType, taskId, resultId, bin, advisories, }: {
     statusType: unknown;
     taskId: string;
     resultId?: string;
     bin: string;
+    advisories?: Array<{
+        code: string;
+        message: string;
+    }>;
 }): string | null;
 export default class TasksComplete extends BaseCommand {
     static description: string;

package/dist/commands/tasks/complete.js

@@ -43,11 +43,24 @@ function optionalString(value) {
 function stringArray(value) {
     return Array.isArray(value) ? value.map((item) => String(item).trim()).filter(Boolean) : [];
 }
-function describePendingReview({ statusType, taskId, resultId, bin, }) {
+function describePendingReview({ statusType, taskId, resultId, bin, advisories, }) {
     if (statusType !== 'review')
         return null;
-    return ('The Result was submitted, but the Task is not done yet. An independent reviewer must ' +
-        `accept this exact Result with: ${bin} tasks review ${taskId} --result-id ${resultId || '<result-id>'} --decision accepted`);
+    // Say which thing is actually holding the Task. This used to assert a missing
+    // reviewer unconditionally, so a Task held by unmet Expectations was reported
+    // as needing review — and the command it handed over failed every time, both
+    // because the block was elsewhere and because a submitter may not accept their
+    // own Result (`TASK_REVIEW_SELF_ACCEPTANCE`).
+    const expectationAdvisory = (advisories || []).find((row) => row.code === 'task_acceptance_not_met' || /expectation/i.test(row.code || ''));
+    if (expectationAdvisory) {
+        return ('The Result was submitted, but the Task is not done yet: its Expectations are not all ' +
+            `settled. ${expectationAdvisory.message} ` +
+            `Settle each with: ${bin} tasks expectations assess ${taskId} <expectation-id> ` +
+            '--decision met|waived --reason "..."');
+    }
+    return ('The Result was submitted, but the Task is not done yet. It is waiting on an independent ' +
+        `accepted Review — someone OTHER than the submitter runs: ${bin} tasks review ${taskId} ` +
+        `--result-id ${resultId || '<result-id>'} --decision accepted`);
 }
 class TasksComplete extends base_command_1.BaseCommand {
     static description = 'Submit one versioned Result and advance the Task workflow';
@@ -247,6 +260,7 @@ class TasksComplete extends base_command_1.BaseCommand {
             taskId,
             resultId: result.result.id,
             bin: this.config.bin,
+            advisories: result.advisories,
         });
         if (pending)
             this.log(pending);

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

@@ -58,6 +58,7 @@ export default class TasksCreate extends BaseCommand {
         'dri-agent': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'dri-user': 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>;
+        'review-policy': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'execution-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'start-date': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'due-date': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/create.js

@@ -192,6 +192,13 @@ class TasksCreate extends base_command_1.BaseCommand {
                 " Injected into the agent's instructions and checked against what the run produced. " +
                 'Omit to inherit the space default.',
         }),
+        'review-policy': core_1.Flags.string({
+            options: ['none', 'required'],
+            description: 'Whether closing this Task needs someone other than the Result author to accept it. ' +
+                "Default 'none': the Expectations you declare are already your definition of done. " +
+                "Use 'required' when the work warrants a second pair of eyes — it applies to every " +
+                'executor, human or agent.',
+        }),
         'execution-mode': core_1.Flags.string({
             description: 'Who executes the task: agent or human. Required when both Humans and Agents are ' +
                 'assigned. Passing "human" with no assignee flags files the task against you, ' +

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

@@ -17,7 +17,20 @@ const tasks_1 = require("../../../lib/tasks");
  * optional structured one.
  */
 class TasksDeliverableAdd extends base_command_1.BaseCommand {
-    static description = 'Record something this task produced (a commit, a page, a URL, a file, a message, a dataset)';
+    static description = 'Record something this task produced (a commit, a page, a URL, a file, a message, a dataset).\n' +
+        '\n' +
+        'IDENTITY is the part before @; LOCATION is the part after it. They are not the same ' +
+        'grammar as `--expect`, where the same-looking `code:origin/main` names a DESTINATION ' +
+        'rather than a thing that exists. Here `origin/main` is where the commit landed, and ' +
+        'the commit SHA is what is identified.\n' +
+        '\n' +
+        'Two Deliverables share one Resource when their identity matches, scoped to the ' +
+        'workspace. A bare relative path has no global meaning, so `docs/report.md` from two ' +
+        'different repositories in one workspace IS the same Resource — pass --provider and a ' +
+        "provider id when you mean a specific system's object, which moves the identity into " +
+        "that provider's namespace. Without --version or a content digest the version is " +
+        '`locator_only`: nothing pins which revision it is, and a later sighting of the same ' +
+        'coordinate may be different bytes.';
     static examples = [
         '<%= config.bin %> tasks deliverable add <task-id> code:a1b2c3d@origin/main',
         '<%= config.bin %> tasks deliverable add <task-id> page:d_92@Engineering/deploy',
@@ -27,8 +40,9 @@ class TasksDeliverableAdd extends base_command_1.BaseCommand {
     static args = {
         task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
         coordinate: core_1.Args.string({
-            description: '<kind>[/<format>]:<identity>[@<location>] — e.g. code:a1b2c3d@origin/main, ' +
-                'file/pdf:report_92@Drive/Reports',
+            description: '<kind>[/<format>]:<identity>[@<location>] — identity before @, location after. ' +
+                'e.g. code:a1b2c3d@origin/main, file/pdf:report_92@Drive/Reports. ' +
+                'Kinds: code, file, page, url, message, dataset',
             required: true,
             ignoreStdin: true,
         }),
@@ -44,7 +58,11 @@ class TasksDeliverableAdd extends base_command_1.BaseCommand {
             hidden: true,
         }),
         title: core_1.Flags.string({ description: 'Human-readable Deliverable name' }),
-        provider: core_1.Flags.string({ description: 'Provider, such as github or drive' }),
+        provider: core_1.Flags.string({
+            description: 'Provider, such as github or drive. This CHANGES the Resource identity: it moves the ' +
+                "key from the locator namespace into the provider's, so the same coordinate with and " +
+                'without --provider are two different Resources',
+        }),
         version: core_1.Flags.string({ description: 'Exact provider version, such as a full commit SHA' }),
         'content-digest': core_1.Flags.string({ description: 'Integrity digest for this exact version' }),
         expectation: core_1.Flags.string({ multiple: true, description: 'Expectation id this satisfies' }),

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

@@ -4,6 +4,25 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const task_resolver_1 = require("../../../lib/task-resolver");
+/**
+ * `locator_only` is the storage word, and it appeared on nearly every row with
+ * nothing saying what it meant. It is not a defect — it is the honest statement
+ * that nothing pins WHICH revision this is — so the label says that.
+ */
+function fidelityLabel(value) {
+    switch (value) {
+        case 'managed_copy':
+            return 'exact version archived';
+        case 'content_digest':
+            return 'exact version (content verified)';
+        case 'provider_version':
+            return 'exact version (provider revision)';
+        case 'locator_only':
+            return 'version not pinned — the coordinate may change under you';
+        default:
+            return value || 'unknown fidelity';
+    }
+}
 class TasksDeliverableList extends base_command_1.BaseCommand {
     static description = 'List Deliverables with exact version, location, and evidence state';
     static args = {
@@ -29,8 +48,10 @@ class TasksDeliverableList extends base_command_1.BaseCommand {
         if (!result.data.length)
             return this.log('No Deliverables recorded.');
         for (const item of result.data) {
-            this.log(`${item.linkId} · ${item.title || item.identity || item.kind}\n` +
-                `  ${item.location || 'no locator'} · ${item.versionFidelity} · ${item.status} · ${item.evidenceLevel}`);
+            this.log(`${item.linkId} · ${item.kind}${item.format ? `/${item.format}` : ''} · ` +
+                `${item.title || item.identity || '(untitled)'}\n` +
+                `  ${item.location || 'no locator'} · ${fidelityLabel(item.versionFidelity)} · ` +
+                `${item.status} · ${item.evidenceLevel}`);
         }
     }
 }

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

@@ -10,8 +10,16 @@ const task_artifact_flags_1 = require("../../../lib/task-artifact-flags");
 const tasks_1 = require("../../../lib/tasks");
 class TasksEventsAppend extends base_command_1.BaseCommand {
     static hidden = true;
-    static summary = 'Append a typed, durable task event';
-    static description = 'Compatibility adapter for historical Event vocabulary; use `tasks updates add`.';
+    // The SUMMARY is what `tasks --help` and the first line of `--help` show, and
+    // it is the only line most readers see. Saying only "Append a typed, durable
+    // task event" there while the deprecation lived in the long DESCRIPTION meant
+    // the retired vocabulary read as the intended path — which is how it kept
+    // getting exercised.
+    static summary = 'DEPRECATED compatibility spelling for `tasks updates add` — append a legacy task event';
+    static description = 'DEPRECATED compatibility adapter for the historical Event vocabulary. Every kind is ' +
+        'stored as a canonical Update, so `--kind handoff` and `--kind checkpoint` both become ' +
+        '`progress`, and `--kind started|lifecycle` writes only to the Activity ledger and will ' +
+        'NOT appear in `tasks updates list`. Use `tasks updates add` instead.';
     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"',
@@ -91,7 +99,27 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
         }
         if (path && result && typeof result === 'object' && 'entry' in result)
             result = result.entry;
-        this.log(flags.json ? JSON.stringify(result, null, 2) : `Appended event to task ${task.id}.`);
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        // The old receipt named neither what was written nor where to find it, so a
+        // caller could not tell a successful compatibility write from a no-op — and
+        // this command silently becomes a canonical Update of a DIFFERENT type.
+        const written = result || {};
+        if (written.canonicalType) {
+            this.log(`Recorded on ${task.id} as a ${written.canonicalType} Update` +
+                `${written.id ? ` (${written.id})` : ''}.`);
+            this.log(`\`tasks events append\` is a compatibility spelling; \`${this.config.bin} tasks updates add\` ` +
+                `is the canonical command, and \`${this.config.bin} tasks updates list\` reads them back.`);
+            return;
+        }
+        // `--kind started|lifecycle` produces no Update at all: it writes a
+        // `task.lifecycle.changed` row to the Activity ledger. The old receipt was
+        // byte-identical to the Update case, so a caller was told "appended" and
+        // then could not find it in the surface the deprecation notice points at.
+        this.log(`Recorded on ${task.id} in the Activity ledger` +
+            `${written.id ? ` (${written.id})` : ''} — NOT as a Task Update.`);
+        this.log(`Read it with \`${this.config.bin} tasks activity ${task.id}\`; it will not appear in ` +
+            `\`${this.config.bin} tasks updates list\`.`);
     }
 }
 exports.default = TasksEventsAppend;

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

@@ -3,7 +3,7 @@ export default class TasksExpectationsAssess extends BaseCommand {
     static description: string;
     static args: {
         task: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
-        expectation: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        expectation: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
         task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/expectations/assess.js

@@ -9,9 +9,24 @@ const api_fetch_1 = require("../../../lib/api-fetch");
 const session_task_endpoints_1 = require("../../../lib/session-task-endpoints");
 class TasksExpectationsAssess extends base_command_1.BaseCommand {
     static description = 'Assess one current Task Expectation with evidence and a reason';
+    // Both positionals are declared optional because oclif REJECTS an args table
+    // whose optional entry precedes a required one — it throws `Invalid argument
+    // spec` at parse time, before any network call, which made this command
+    // impossible to invoke in any form. Since a declared Expectation hard-gates
+    // closure (`TaskClosurePolicy.assertTaskMayClose`) and re-assessment is the
+    // only way back, that parse failure was a permanent close-deadlock for every
+    // Task carrying one. The two supported shapes are disambiguated in `run()`.
     static args = {
-        task: core_1.Args.string({ required: false, ignoreStdin: true, description: 'Task id or ref' }),
-        expectation: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Expectation id' }),
+        task: core_1.Args.string({
+            required: false,
+            ignoreStdin: true,
+            description: 'Task id or ref; omit inside a task runtime',
+        }),
+        expectation: core_1.Args.string({
+            required: false,
+            ignoreStdin: true,
+            description: 'Expectation id',
+        }),
     };
     static flags = {
         task: core_1.Flags.string({ description: 'Task id; overrides runtime context' }),
@@ -31,7 +46,18 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksExpectationsAssess);
-        const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.task, flagTask: flags.task });
+        // `assess <task> <expectation>` gives both; `assess <expectation>` inside a
+        // task runtime gives one, and it is the Expectation.
+        const expectationId = args.expectation ?? args.task;
+        if (!expectationId) {
+            this.error('An Expectation id is required: `tasks expectations assess <task> <expectation>`', {
+                exit: 1,
+            });
+        }
+        const task = (0, task_resolver_1.resolveTaskIdentity)({
+            positionalId: args.expectation ? args.task : undefined,
+            flagTask: flags.task,
+        });
         const evidenceRefs = (flags.evidence || []).map((raw) => {
             const split = raw.indexOf(':');
             if (split < 1)
@@ -53,16 +79,16 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
         try {
             const data = {
                 ...payload,
-                expectationId: args.expectation,
+                expectationId,
                 idempotencyKey: flags['idempotency-key'] ||
-                    (0, outbox_1.idempotencyKeyFor)('task-expectation-assessment', task.id, JSON.stringify({ expectationId: args.expectation, ...payload })),
+                    (0, outbox_1.idempotencyKeyFor)('task-expectation-assessment', task.id, JSON.stringify({ expectationId, ...payload })),
             };
             const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('assessment');
             result = sessionPath
                 ? await (0, api_fetch_1.apiFetch)(sessionPath, { method: 'POST', body: data })
                 : await data_provider_1.dataService.assessTaskExpectation({
                     taskId: task.id,
-                    expectationId: args.expectation,
+                    expectationId,
                     data,
                 });
         }
@@ -71,7 +97,7 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(result, null, 2));
-        this.log(`Recorded ${args.expectation} as ${flags.decision}.`);
+        this.log(`Recorded ${expectationId} as ${flags.decision}.`);
     }
 }
 exports.default = TasksExpectationsAssess;

package/dist/commands/tasks/expectations.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
+const data_provider_2 = 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.
@@ -23,16 +24,58 @@ const STATE_LABEL = {
     owed: 'not yet',
     unassessed: 'needs assessment',
 };
+/**
+ * The evidence gap, on the rows where a reader can act on it.
+ *
+ * `unverified` and `underway` BOTH mean "something was produced and pinned to
+ * this Expectation, and it is not enough yet" — they differ only in whether the
+ * thing has been observed as available. Printing the gap on the first and
+ * nothing on the second is what made the careful path unreadable: an operator
+ * who pinned a deliverable saw `on its way` and had no way to learn that the
+ * bar was `external_receipt` and their own report could never clear it.
+ *
+ * It stays off the rows where it is noise: a met or waived row has nothing
+ * outstanding, and an `owed`/`unassessed` row has no deliverable to compare
+ * against, so naming a required authority there describes a hypothetical.
+ */
+const PINNED_STATES = new Set(['unverified', 'underway']);
+function evidenceGap(expectation) {
+    /*
+     * A `met` row settled BELOW its declared bar says so.
+     *
+     * `@merged-to-main` asks for `external_receipt` and is satisfiable by a person
+     * typing "I checked git log". That is allowed on purpose — refusing it is the
+     * deadlock the ladder exists to prevent — but every surface then read as though
+     * a receipt had arrived: the row said `done`, the rollup said `met`, and the
+     * recorded gap was visible only to someone who dumped the assessment rows and
+     * already knew the field existed.
+     */
+    if (expectation.evidenceShortfall) {
+        const { provided, required } = expectation.evidenceShortfall;
+        return `  (vouched at ${provided}, asked for ${required})`;
+    }
+    if (!PINNED_STATES.has(expectation.state))
+        return '';
+    if (!expectation.evidenceLevel || !expectation.requiredEvidence)
+        return '';
+    if (expectation.evidenceLevel === expectation.requiredEvidence)
+        return '';
+    return `  (has ${expectation.evidenceLevel}, needs ${expectation.requiredEvidence})`;
+}
 function line(expectation) {
     const label = STATE_LABEL[expectation.state] || expectation.state;
     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.evidenceLevel}, needs ${expectation.requiredEvidence})`
-        : '';
-    return `  ${expectation.id.padEnd(18)} ${label.padEnd(18)} ${expectation.text}${evidence}${from}`;
+    /*
+     * `sentence` before `text`.
+     *
+     * The server resolves `sentence` through `describeExpectation`, which is what
+     * appends a preset's destination — so `@wiki-page-published:Engineering/Deploy`
+     * and the same preset at `Ops/Oncall` are distinguishable. Printing `text`
+     * rendered the preset's fixed copy and dropped the one part that says WHICH
+     * thing is owed. The fallback is for a row that predates the resolved field.
+     */
+    const sentence = expectation.sentence || expectation.text;
+    return `  ${expectation.id.padEnd(18)} ${label.padEnd(18)} ${sentence}${evidenceGap(expectation)}${from}`;
 }
 class TasksExpectations extends base_command_1.BaseCommand {
     static description = 'Show what must be true before the Task can close and the evidence-backed assessment state';
@@ -79,12 +122,36 @@ class TasksExpectations extends base_command_1.BaseCommand {
             this.log(line(expectation));
         }
         const gating = acceptance.expectations.filter((e) => e.gating);
-        const met = gating.filter((e) => e.met).length;
+        // `met: true` is the GATE's answer — a waiver unblocks closure exactly as a
+        // pass does — but it is the wrong REPORT. Counting them together printed
+        // "2 of 2 met" for a Task where one expectation was dropped, which is the
+        // one thing a reader checking this line needs to know.
+        const waived = gating.filter((e) => e.state === 'waived').length;
+        const met = gating.filter((e) => e.met).length - waived;
         this.log('');
-        this.log(`${met} of ${gating.length} met  ·  overall: ${acceptance.state}`);
+        this.log(`${met} of ${gating.length} met${waived > 0 ? ` · ${waived} waived` : ''}  ·  overall: ${acceptance.state}`);
         // Space defaults are copied into the Task at creation. `source=space`
         // remains useful provenance, but these are Task-owned Expectations now and
         // are assessed exactly like explicitly declared ones.
+        /*
+         * A typed check nothing evaluates behaves exactly like `manual`.
+         *
+         * `EXPECTATION_CHECK_METHODS` declares six methods and the judge evaluates
+         * one: a `deliverable` check is compared against the ledger, and
+         * `task_state`, `goal_state`, `metric` and `llm_review` return `unassessed`
+         * forever. Verified against production — a `metric` check naming measureId,
+         * operator and target stores fine and is never looked at. The row read
+         * identically to a hand-written sentence, so somebody who chose
+         * `metric: cycle_time lt 2` had no way to learn the platform was not
+         * measuring it (OSK-8488).
+         */
+        const unevaluated = acceptance.expectations.filter((e) => (0, data_provider_2.declaresUnevaluatedCheck)(e));
+        if (unevaluated.length > 0) {
+            const methods = [...new Set(unevaluated.map((e) => e.check?.method).filter(Boolean))].join(', ');
+            this.log(`${unevaluated.length} declare${unevaluated.length === 1 ? 's' : ''} a typed check nothing ` +
+                `evaluates yet (${methods}) — a person settles ${unevaluated.length === 1 ? 'it' : 'them'} ` +
+                'exactly as if the check said `manual`.');
+        }
         const settleable = acceptance.expectations.filter((e) => e.state === 'unassessed').length;
         if (settleable > 0) {
             this.log(`${settleable} awaiting assessment — use \`${this.config.bin} tasks expectations assess\`.`);
@@ -98,7 +165,40 @@ class TasksExpectations extends base_command_1.BaseCommand {
                 `\`${this.config.bin} tasks deliverable confirm\`, or lower the bar with ` +
                 `\`${this.config.bin} tasks trust\`.`);
         }
-        if (gating.length > met) {
+        // `underway` had no trailer at all, which is why pinning a deliverable read
+        // as no progress: the row said `on its way` and nothing named the lever.
+        // A Deliverable is recorded `local` by default, so this is the state the
+        // ORDINARY `tasks deliverable add` lands in — the common case, not an edge.
+        const underway = acceptance.expectations.filter((e) => e.state === 'underway').length;
+        if (underway > 0) {
+            this.log(`${underway} recorded but not yet observed as available — say it arrived with ` +
+                `\`${this.config.bin} tasks deliverable confirm\`, or re-record it with ` +
+                `\`--status available\`.`);
+        }
+        // Counted separately from the unmet ones: these no longer block anything, and
+        // the reader's question about them is not "what do I do" but "how good is this
+        // record". Saying it once beats repeating the rungs on every row.
+        const shortfalls = acceptance.expectations.filter((e) => e.evidenceShortfall).length;
+        if (shortfalls > 0) {
+            this.log(`${shortfalls} settled below the evidence ${shortfalls === 1 ? 'bar it' : 'bars they'} ` +
+                `declared — allowed, and recorded as such on the assessment.`);
+        }
+        // Said once, for the whole task: `external_receipt` is the one bar no CLI
+        // command can clear. The only receipt producer in the platform is PR
+        // integration, so an operator staring at a row that needs one would
+        // otherwise keep looking for the command that supplies it.
+        const receiptBarred = acceptance.expectations.filter((e) => !e.met && e.requiredEvidence === 'external_receipt').length;
+        if (receiptBarred > 0) {
+            this.log(`${receiptBarred} ask${receiptBarred === 1 ? 's' : ''} for an external provider receipt, ` +
+                `which only an integration can supply — settle by hand with ` +
+                `\`${this.config.bin} tasks expectations assess\` (the gap is recorded), or lower the ` +
+                `bar with \`${this.config.bin} tasks trust\`.`);
+        }
+        // Settled, not "met" — a waiver settles an Expectation as surely as a pass,
+        // and splitting the two in the count above must not make this trailer fire
+        // on a Task where nothing is actually outstanding.
+        const settled = gating.filter((e) => e.met).length;
+        if (gating.length > settled) {
             this.log('');
             this.log('The current Result cannot be accepted while these Expectations remain unmet.');
         }

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

@@ -1,5 +1,4 @@
 import { BaseCommand } from '../../base-command';
-/** Compatibility command name. The authoritative object is Result, not output. */
 export default class TasksOutput extends BaseCommand {
     static hidden: boolean;
     static description: string;

package/dist/commands/tasks/output.js

@@ -7,6 +7,19 @@ const task_resolver_1 = require("../../lib/task-resolver");
 const web_url_1 = require("../../lib/web-url");
 const task_transcript_1 = require("../../lib/task-transcript");
 /** Compatibility command name. The authoritative object is Result, not output. */
+/**
+ * "awaiting review" is only true while a review can still be recorded.
+ *
+ * A closed Task refuses one outright (`TASK_REOPEN_REQUIRED`), so printing
+ * "awaiting" described a state that could never be left — and the reader has no
+ * way to tell that from a review that is genuinely pending.
+ */
+function reviewLine(review, task) {
+    if (review?.decision)
+        return review.decision;
+    const terminal = ['completed', 'cancelled'].includes(String(task?.statusType ?? ''));
+    return terminal ? 'none recorded — the Task is closed' : 'awaiting review';
+}
 class TasksOutput extends base_command_1.BaseCommand {
     static hidden = true;
     static description = 'Show the current Result, Review, Deliverables, and final Run reply';
@@ -93,10 +106,17 @@ class TasksOutput extends base_command_1.BaseCommand {
             if (result.conclusion) {
                 this.log(`  conclusion (${result.conclusion.type}): ${JSON.stringify(result.conclusion.value)}`);
             }
-            this.log(`Review:  ${review?.decision || 'awaiting review'}`);
+            this.log(`Review:  ${reviewLine(review, task)}`);
             if (review?.rationale)
                 this.log(`  ${review.rationale}`);
         }
+        else if (task.specVersion === undefined) {
+            // A Task predating the canonical model has no TaskResult row and never
+            // will. "none submitted" reads as "the work was never reported", which
+            // for a completed legacy Task is the opposite of the truth.
+            this.log('Result:  not recorded under the canonical model (this Task predates it)');
+            this.log('         its closeout is in `skrr tasks comments list` / `tasks transcript`');
+        }
         else {
             this.log('Result:  none submitted');
         }

package/dist/commands/tasks/report.js

@@ -14,7 +14,9 @@ const web_url_1 = require("../../lib/web-url");
  */
 class TasksReport extends base_command_1.BaseCommand {
     static hidden = true;
-    static description = 'Submit a versioned Result with findings, evidence, and next actions';
+    static description = 'DEPRECATED compatibility spelling for `tasks result submit`. Every call submits a ' +
+        'versioned Result; `--kind` is ignored. Use `tasks result submit` (submit only) or ' +
+        '`tasks complete` (submit and close).';
     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 a Result section"',
         '<%= config.bin %> tasks report <task-id> --kind handoff --outcome "Ready for review" --finding "All expectations are met" --deliverable "file:src/task.ts" --json',