@skrr-ai/cli 0.1.22 → 0.1.24

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

@@ -1,4 +1,5 @@
 import { BaseCommand } from '../../base-command';
+import { type TaskRecord } from '../../lib/tasks';
 /**
  * Whether the estimate we asked for survived the write. (S3 dogfood finding)
  *
@@ -25,6 +26,9 @@ import { BaseCommand } from '../../base-command';
  * silently-dropped assignee (OSK-4857).
  */
 export declare function droppedEstimateWarning(requested: number | undefined, written: Record<string, unknown> | null | undefined, spaceId?: string | null): string | null;
+/** A create may have committed before any of these response failures surfaced. */
+export declare function taskCreateMayHaveCommitted(error: unknown): boolean;
+export declare function taskMatchesCreateIdentity(task: TaskRecord, payload: TaskRecord): boolean;
 export default class TasksCreate extends BaseCommand {
     static description: string;
     static examples: string[];
@@ -54,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>;
@@ -63,6 +68,7 @@ export default class TasksCreate extends BaseCommand {
         worktree: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
+    private createTaskOrRecover;
     /**
      * Predict the create route's `ASSIGNEE_NOT_IN_SPACE` degradation for a
      * DEFAULTED assignee, so `--dry-run` does not report a payload the real

package/dist/commands/tasks/create.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.droppedEstimateWarning = droppedEstimateWarning;
+exports.taskCreateMayHaveCommitted = taskCreateMayHaveCommitted;
+exports.taskMatchesCreateIdentity = taskMatchesCreateIdentity;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
@@ -51,6 +53,53 @@ function droppedEstimateWarning(requested, written, spaceId) {
         'estimate scale, so the value is discarded rather than rejected. ' +
         'Set one with `spaces update <space> --estimate-scale <scale> --estimate-migration <clear|migrate>`.');
 }
+function taskCreateFailureCode(error) {
+    const failure = error;
+    if (typeof failure?.body === 'string') {
+        try {
+            const parsed = JSON.parse(failure.body);
+            if (typeof parsed.code === 'string')
+                return parsed.code;
+            if (typeof parsed.errorType === 'string')
+                return parsed.errorType;
+        }
+        catch {
+            // Non-JSON response bodies carry no typed code.
+        }
+    }
+    return typeof failure?.code === 'string' ? failure.code : undefined;
+}
+/** A create may have committed before any of these response failures surfaced. */
+function taskCreateMayHaveCommitted(error) {
+    const failure = error;
+    const status = failure?.status ?? failure?.response?.status;
+    if (typeof status === 'number' && status >= 500)
+        return true;
+    if (taskCreateFailureCode(error) === 'TASK_EXTERNAL_KEY_CONFLICT')
+        return true;
+    const code = failure?.code || '';
+    if (['ECONNRESET', 'ETIMEDOUT', 'EAI_AGAIN', 'ENOTFOUND'].includes(code))
+        return true;
+    return /fetch failed|socket hang up|timed? ?out/i.test(failure?.message || '');
+}
+function taskMatchesCreateIdentity(task, payload) {
+    for (const field of [
+        'externalKey',
+        'title',
+        'spaceId',
+        'goalId',
+        'projectId',
+        'parentId',
+        'commitmentId',
+    ]) {
+        const requested = payload[field];
+        if (requested === undefined || requested === null || requested === '')
+            continue;
+        if (String(task[field] ?? '') !== String(requested))
+            return false;
+    }
+    return true;
+}
 class TasksCreate extends base_command_1.BaseCommand {
     static description = 'Create a new task';
     static examples = [
@@ -143,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, ' +
@@ -357,8 +413,11 @@ class TasksCreate extends base_command_1.BaseCommand {
             });
         }
         let created;
+        let createRecovery;
         try {
-            created = await data_provider_1.dataService.createTask(payload);
+            const result = await this.createTaskOrRecover(payload);
+            created = result.task;
+            createRecovery = result.recovery;
         }
         catch (err) {
             // The CLI resolves the assignee default BEFORE sending, so by the time
@@ -405,7 +464,9 @@ class TasksCreate extends base_command_1.BaseCommand {
                     'Add it to the space, or pass an assignee explicitly.',
             };
             try {
-                created = await data_provider_1.dataService.createTask(payload);
+                const result = await this.createTaskOrRecover(payload);
+                created = result.task;
+                createRecovery = result.recovery;
             }
             catch (retryErr) {
                 this.handleApiError(retryErr);
@@ -423,10 +484,18 @@ class TasksCreate extends base_command_1.BaseCommand {
             // bound". Surface the same decision plain mode prints under `assignment`
             // — a scripted caller is exactly the audience that never sees the note.
             // (OSK-4856)
-            this.log(JSON.stringify({ ...created, url, assignment: defaultAgentResolution }, null, 2));
+            this.log(JSON.stringify({
+                ...created,
+                url,
+                assignment: defaultAgentResolution,
+                ...(createRecovery ? { recovery: createRecovery } : {}),
+            }, null, 2));
             return;
         }
-        this.log(`Created task ${(0, tasks_1.formatTaskLabel)(created)}`);
+        this.log(`${createRecovery ? 'Recovered' : 'Created'} task ${(0, tasks_1.formatTaskLabel)(created)}`);
+        if (createRecovery) {
+            this.log('The create response was uncertain, so skrr resolved the external key and returned the existing task instead of creating a duplicate.');
+        }
         // Say so when nobody was assigned. The task exists either way — this is the
         // line that stops "unassigned" from being a silent outcome.
         if (defaultAgentResolution.note)
@@ -435,6 +504,47 @@ class TasksCreate extends base_command_1.BaseCommand {
             this.log(`View it at ${url}`);
         await (0, task_instruction_offer_1.maybeOfferTaskManagementInstructions)((message) => this.log(message));
     }
+    async createTaskOrRecover(payload) {
+        try {
+            return {
+                task: await data_provider_1.dataService.createTask(payload),
+            };
+        }
+        catch (error) {
+            const externalKey = typeof payload.externalKey === 'string' ? payload.externalKey.trim() : '';
+            if (!externalKey || !taskCreateMayHaveCommitted(error))
+                throw error;
+            try {
+                const existing = await (0, tasks_1.findTaskByExternalKey)({
+                    externalKey,
+                    spaceId: payload.spaceId,
+                    goalId: payload.goalId,
+                    parentId: payload.parentId,
+                });
+                if (existing.task &&
+                    existing.duplicates.length === 0 &&
+                    taskMatchesCreateIdentity(existing.task, payload)) {
+                    return {
+                        task: existing.task,
+                        recovery: {
+                            kind: 'external_key_reconciliation',
+                            externalKey,
+                            originalFailureCode: taskCreateFailureCode(error) ?? null,
+                            originalStatus: error?.status ??
+                                error?.response?.status ??
+                                null,
+                            note: 'The original create response was uncertain; the existing matching task is the canonical result.',
+                        },
+                    };
+                }
+            }
+            catch {
+                // Preserve the original failure. A failed reconciliation is not proof
+                // that the write did or did not commit.
+            }
+            throw error;
+        }
+    }
     /**
      * Predict the create route's `ASSIGNEE_NOT_IN_SPACE` degradation for a
      * DEFAULTED assignee, so `--dry-run` does not report a payload the real

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

@@ -16,7 +16,15 @@ export default class TasksDeliverableAdd extends BaseCommand {
         coordinate: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         lifecycle: 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>;
+        provider: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'content-digest': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        expectation: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'run-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'idempotency-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

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

@@ -3,6 +3,9 @@ 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 outbox_1 = require("../../../lib/outbox");
+const api_fetch_1 = require("../../../lib/api-fetch");
+const session_task_endpoints_1 = require("../../../lib/session-task-endpoints");
 const tasks_1 = require("../../../lib/tasks");
 /**
  * `skrr tasks deliverable add <task> <kind>:<identity>[@<location>]`
@@ -14,28 +17,57 @@ 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',
         '<%= config.bin %> tasks deliverable add <task-id> file/pdf:f_71@Drive/Reports',
-        '<%= config.bin %> tasks deliverable add <task-id> code:a1b2c3d --lifecycle in_review',
+        '<%= config.bin %> tasks deliverable add <task-id> code:a1b2c3d --status in_review',
     ];
     static args = {
         task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
         coordinate: core_1.Args.string({
-            description: '<kind>[/<format>]:<identity>[@<location>] — e.g. code:a1b2c3d@origin/main, ' +
-                'file/pdf:report_92@Drive/Reports',
+            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,
         }),
     };
     static flags = {
+        status: core_1.Flags.string({
+            options: ['local', 'in_review', 'available', 'unavailable', 'superseded'],
+            description: 'Observed availability. Defaults to `local`; evidence strength is recorded separately.',
+        }),
         lifecycle: core_1.Flags.string({
-            options: ['local', 'in_review', 'durable', 'blocked', 'superseded'],
-            description: 'How far along it is. Defaults to `local` — recording that a commit exists is not a ' +
-                'claim that it landed. Only an external receipt should assert `durable`.',
+            options: ['local', 'in_review', 'available', 'unavailable', 'superseded'],
+            description: 'Deprecated compatibility alias for --status',
+            hidden: true,
+        }),
+        title: core_1.Flags.string({ description: 'Human-readable Deliverable name' }),
+        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' }),
+        'run-id': core_1.Flags.string({ description: 'Run that produced it' }),
+        'idempotency-key': core_1.Flags.string({ description: 'Stable retry key' }),
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
     };
     async run() {
@@ -48,12 +80,31 @@ class TasksDeliverableAdd extends base_command_1.BaseCommand {
             this.error(parsed.error, { exit: 1 });
             return;
         }
+        if (flags.status && flags.lifecycle && flags.status !== flags.lifecycle) {
+            this.error('--status and deprecated --lifecycle cannot disagree', { exit: 1 });
+        }
+        const status = flags.status || flags.lifecycle;
         let result;
         try {
-            result = await data_provider_1.dataService.addTaskDeliverable(args.task, {
+            const payload = {
                 ...parsed.value,
-                ...(flags.lifecycle ? { lifecycle: flags.lifecycle } : {}),
-            });
+                ...(status ? { status } : {}),
+                title: flags.title,
+                provider: flags.provider,
+                version: flags.version,
+                contentDigest: flags['content-digest'],
+                expectationIds: flags.expectation,
+                runId: flags['run-id'],
+                idempotencyKey: flags['idempotency-key'] ||
+                    (0, outbox_1.idempotencyKeyFor)('task-deliverable', args.task, JSON.stringify({ coordinate: parsed.value, status })),
+            };
+            const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('deliverable');
+            result = sessionPath
+                ? await (0, api_fetch_1.apiFetch)(sessionPath, {
+                    method: 'POST',
+                    body: payload,
+                })
+                : await data_provider_1.dataService.addTaskDeliverable(args.task, payload);
         }
         catch (err) {
             this.handleApiError(err);
@@ -64,7 +115,7 @@ class TasksDeliverableAdd extends base_command_1.BaseCommand {
             return;
         }
         const where = parsed.value.location ? ` at ${parsed.value.location}` : '';
-        this.log(`Recorded ${parsed.value.kind}:${parsed.value.identity}${where} (${flags.lifecycle || 'local'}).`);
+        this.log(`Recorded Deliverable ${result.link.id}: ${parsed.value.kind}:${parsed.value.identity}${where} (${status || 'local'}; self reported).`);
     }
 }
 exports.default = TasksDeliverableAdd;

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

@@ -1,6 +1,6 @@
 import { BaseCommand } from '../../../base-command';
 /**
- * `skrr tasks deliverable confirm <task> <kind>:<identity>[@<location>] --reason "<what you checked>"`
+ * `skrr tasks deliverable confirm <task> <resource-link-id> --reason "<what you checked>"`
  *
  * Somebody looked, and it is there.
  *
@@ -16,16 +16,16 @@ import { BaseCommand } from '../../../base-command';
  * are: the entire value of a confirmation is that a person actually looked, and
  * a confirmation with nothing written down is indistinguishable from a click.
  *
- * It UPSERTS. Confirming something the executor never recorded is legitimate —
- * the thing is there either way — and making a person file the row first before
- * they may vouch for it is ceremony that buys nothing.
+ * It confirms an exact linked Resource Version. A person never retypes identity
+ * or location during confirmation, because either may now name a different
+ * version than the one the Task actually delivered.
  */
 export default class TasksDeliverableConfirm extends BaseCommand {
     static description: string;
     static examples: string[];
     static args: {
         task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
-        coordinate: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        link: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
         reason: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;

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

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
-const tasks_1 = require("../../../lib/tasks");
 /**
- * `skrr tasks deliverable confirm <task> <kind>:<identity>[@<location>] --reason "<what you checked>"`
+ * `skrr tasks deliverable confirm <task> <resource-link-id> --reason "<what you checked>"`
  *
  * Somebody looked, and it is there.
  *
@@ -21,20 +20,19 @@ const tasks_1 = require("../../../lib/tasks");
  * are: the entire value of a confirmation is that a person actually looked, and
  * a confirmation with nothing written down is indistinguishable from a click.
  *
- * It UPSERTS. Confirming something the executor never recorded is legitimate —
- * the thing is there either way — and making a person file the row first before
- * they may vouch for it is ceremony that buys nothing.
+ * It confirms an exact linked Resource Version. A person never retypes identity
+ * or location during confirmation, because either may now name a different
+ * version than the one the Task actually delivered.
  */
 class TasksDeliverableConfirm extends base_command_1.BaseCommand {
     static description = 'Confirm you checked a deliverable and it is there — the evidence an expectation needs when nothing observes it automatically';
     static examples = [
-        '<%= config.bin %> tasks deliverable confirm <task-id> file/pdf:report_92@Drive/Reports --reason "Opened it; all four sections are there."',
-        '<%= config.bin %> tasks deliverable confirm <task-id> message:m_51@#general --reason "Read the thread; it went out at 09:04."',
+        '<%= config.bin %> tasks deliverable confirm <task-id> <resource-link-id> --reason "Opened the exact version; all four sections are there."',
     ];
     static args = {
         task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
-        coordinate: core_1.Args.string({
-            description: '<kind>[/<format>]:<identity>[@<location>] — the thing you checked',
+        link: core_1.Args.string({
+            description: 'Task Resource link id for the exact version you checked',
             required: true,
             ignoreStdin: true,
         }),
@@ -49,17 +47,10 @@ class TasksDeliverableConfirm extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksDeliverableConfirm);
-        const parsed = (0, tasks_1.parseDeliverableCoordinate)(args.coordinate);
-        if (!parsed.ok) {
-            // For an agent the refusal IS the documentation — it hits the error and
-            // corrects — so it carries the whole form and vocabulary.
-            this.error(parsed.error, { exit: 1 });
-            return;
-        }
         let result;
         try {
             result = await data_provider_1.dataService.confirmTaskDeliverable(args.task, {
-                ...parsed.value,
+                linkId: args.link,
                 reason: flags.reason,
             });
         }
@@ -71,7 +62,7 @@ class TasksDeliverableConfirm extends base_command_1.BaseCommand {
             this.log(JSON.stringify(result, null, 2));
             return;
         }
-        this.log(`Confirmed ${parsed.value.kind}:${parsed.value.identity}: ${flags.reason}`);
+        this.log(`Confirmed Deliverable link ${args.link}: ${flags.reason}`);
     }
 }
 exports.default = TasksDeliverableConfirm;

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksDeliverableList extends BaseCommand {
+    static description: string;
+    static args: {
+        task: 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,58 @@
+"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_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 = {
+        task: core_1.Args.string({ required: false, ignoreStdin: true, description: 'Task id or ref' }),
+    };
+    static flags = {
+        task: core_1.Flags.string({ description: 'Task id; overrides runtime context' }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksDeliverableList);
+        const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.task, flagTask: flags.task });
+        let result;
+        try {
+            result = await data_provider_1.dataService.listTaskDeliverables(task.id);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        if (!result.data.length)
+            return this.log('No Deliverables recorded.');
+        for (const item of result.data) {
+            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}`);
+        }
+    }
+}
+exports.default = TasksDeliverableList;

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

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksEventsAppend extends BaseCommand {
+    static hidden: boolean;
     static summary: string;
     static description: string;
     static examples: string[];
@@ -16,6 +17,7 @@ export default class TasksEventsAppend extends BaseCommand {
         next: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         evidence: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         deliverable: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        artifact: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

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

@@ -6,12 +6,20 @@ const base_command_1 = require("../../../base-command");
 const task_resolver_1 = require("../../../lib/task-resolver");
 const api_fetch_1 = require("../../../lib/api-fetch");
 const session_task_endpoints_1 = require("../../../lib/session-task-endpoints");
+const task_artifact_flags_1 = require("../../../lib/task-artifact-flags");
 const tasks_1 = require("../../../lib/tasks");
 class TasksEventsAppend extends base_command_1.BaseCommand {
-    static summary = 'Append a typed, durable task event';
-    static description = 'Records one meaningful work boundary — a decision, a material change, evidence, a blocker, ' +
-        'or a handoff — on the task you are executing. Not a log of tool calls: an event that is ' +
-        'worth reading six weeks from now. `skrr tasks timeline <id>` reads them back.';
+    static hidden = true;
+    // 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"',
@@ -58,11 +66,16 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
             multiple: true,
             description: 'Durable reference: a file path, commit sha, or URL. Repeatable. "in the conversation" is not a deliverable',
         }),
+        artifact: core_1.Flags.string({
+            multiple: true,
+            description: 'Compatibility alias for --deliverable used by older managed instruction blocks',
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksEventsAppend);
         const task = (0, task_resolver_1.resolveTaskIdentity)({ positionalId: args.id, flagTask: flags.task });
+        const deliverables = (0, task_artifact_flags_1.mergeTaskArtifactFlags)(flags.deliverable, flags.artifact);
         const data = {
             idempotencyKey: flags['idempotency-key'],
             kind: flags.kind,
@@ -70,7 +83,9 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
             changed: flags.changed,
             next: flags.next,
             evidence: flags.evidence,
-            artifacts: flags.deliverable?.map((ref) => ({ label: 'deliverable', ref })),
+            artifacts: deliverables.length
+                ? deliverables.map((ref) => ({ label: 'deliverable', ref }))
+                : undefined,
         };
         const path = await (0, session_task_endpoints_1.sessionScopedTaskPath)('event');
         let result;
@@ -84,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/events/list.d.ts

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksEventsList extends BaseCommand {
+    static hidden: boolean;
     static description: string;
     static args: {
         id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;

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

@@ -7,6 +7,7 @@ const task_resolver_1 = require("../../../lib/task-resolver");
 const format_1 = require("../../../lib/format");
 const tasks_1 = require("../../../lib/tasks");
 class TasksEventsList extends base_command_1.BaseCommand {
+    static hidden = true;
     static description = 'List durable task events';
     static args = {
         id: core_1.Args.string({

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

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksEventsTail extends BaseCommand {
+    static hidden: boolean;
     static description: string;
     static args: {
         id: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;

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

@@ -5,6 +5,7 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const task_resolver_1 = require("../../../lib/task-resolver");
 class TasksEventsTail extends base_command_1.BaseCommand {
+    static hidden = true;
     static description = 'Follow new task events';
     static args = { id: core_1.Args.string({ required: false, ignoreStdin: true }) };
     static flags = {