@skrr-ai/cli 0.1.14 → 0.1.17

package/dist/commands/spaces/update.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 tasks_1 = require("../../lib/tasks");
 const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
@@ -70,6 +71,29 @@ class SpacesUpdate extends base_command_1.BaseCommand {
             allowNo: true,
             description: 'Whether rollups treat an unestimated task as --default-estimate',
         }),
+        'default-expect': core_1.Flags.string({
+            multiple: true,
+            description: tasks_1.EXPECT_FLAG_HELP +
+                ' This is the space DEFAULT, and it is where the contract actually gets set: nobody ' +
+                'declares one per task, but a space default is configured once and then holds. A ' +
+                'per-task --expect wins. Merged into deliveryPolicy without clobbering its other fields.',
+        }),
+        'delivery-mode': core_1.Flags.string({
+            options: ['none', 'branch', 'pr', 'pr_automerge', 'direct'],
+            description: "How this space's coding tasks integrate their work. 'pr' opens a pull request; " +
+                "'direct' pushes to the integration branch. Note that auto-merging modes are gated " +
+                'by --auto-merge-tier: naming one here does not by itself authorise landing code.',
+        }),
+        'integration-branch': core_1.Flags.string({
+            description: "The branch this space's coding tasks integrate into, e.g. main or dev. Also the " +
+                'default target for a code expectation that names none.',
+        }),
+        'auto-merge-tier': core_1.Flags.string({
+            options: ['off', 'checks_only', 'trusted'],
+            description: 'How far a task may go without a person. "off" (default) downgrades every auto-merging ' +
+                'mode to a human-approved PR; "checks_only" honours pr_automerge; "trusted" also honours ' +
+                "direct. This is the space owner's sanction and it outranks any per-task override.",
+        }),
         'worktree-isolation': core_1.Flags.string({
             options: ['shared', 'ephemeral'],
             description: "Space default for how this space's autonomous task runs use git worktrees. " +
@@ -105,8 +129,24 @@ class SpacesUpdate extends base_command_1.BaseCommand {
         // which the API replaces wholesale on update. Merge into the policy the user
         // supplied via --from-json, else the space's current policy, so setting just
         // the isolation default never clobbers mode / integrationBranch / trust tier.
+        // Parse before any write: a bad spec must fail here, not reach the server
+        // as a silently-dropped field. A space default nobody is enforcing is worse
+        // than none, because every task under it then shows a contract that isn't real.
+        let defaultExpectations;
+        if (flags['default-expect'] !== undefined && flags['default-expect'].length > 0) {
+            const parsed = (0, tasks_1.parseExpectations)(flags['default-expect']);
+            if (!parsed.ok) {
+                this.error(parsed.error, { exit: 1 });
+            }
+            else {
+                defaultExpectations = parsed.value;
+            }
+        }
         const isolation = flags['worktree-isolation'];
-        if (isolation) {
+        const deliveryMode = flags['delivery-mode'];
+        const integrationBranch = flags['integration-branch'];
+        const autoMergeTier = flags['auto-merge-tier'];
+        if (isolation || defaultExpectations || deliveryMode || integrationBranch || autoMergeTier) {
             let basePolicy = {};
             if (payload.deliveryPolicy && typeof payload.deliveryPolicy === 'object') {
                 basePolicy = { ...payload.deliveryPolicy };
@@ -123,7 +163,14 @@ class SpacesUpdate extends base_command_1.BaseCommand {
                     // Fall through: send a policy carrying only the isolation default.
                 }
             }
-            payload.deliveryPolicy = { ...basePolicy, executionIsolation: isolation };
+            payload.deliveryPolicy = {
+                ...basePolicy,
+                ...(isolation ? { executionIsolation: isolation } : {}),
+                ...(deliveryMode ? { mode: deliveryMode } : {}),
+                ...(integrationBranch ? { integrationBranch } : {}),
+                ...(autoMergeTier ? { autoMergeTrustTier: autoMergeTier } : {}),
+                ...(defaultExpectations ? { defaultExpectations } : {}),
+            };
         }
         // Goal links are NOT part of the PATCH body — the server rejects a PATCH
         // /api/spaces/:id carrying `goalIds` with `space_relations_atomic_only` and

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

@@ -1,6 +1,7 @@
 import { dataService } from '@skrr-ai/data-provider';
 import type { TaskReport } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
+import { type TaskDeliveryReceipt } from '../../lib/git-task';
 type CompletionStatus = 'completed' | 'failed';
 type TaskCommentResult = Awaited<ReturnType<typeof dataService.addTaskComment>>;
 type MovedTaskResult = Awaited<ReturnType<typeof dataService.moveTask>>;
@@ -9,15 +10,18 @@ export interface CompleteEndpointResponse {
     task: MovedTaskResult | null;
     comment: TaskCommentResult | null;
     commentFailed?: boolean;
+    deliveryHeld?: boolean;
+    deliveryReason?: string;
 }
 export interface CompleteTransport {
     /** POST /api/tasks/:taskId/complete — atomic move + TASK_OUTPUT comment. */
     postComplete: (taskId: string, payload: {
         status: CompletionStatus;
         summary: string;
-        artifacts: string;
+        deliverables: string;
         verdict: string;
         report?: TaskReport;
+        deliveryReceipt?: TaskDeliveryReceipt;
     }) => Promise<CompleteEndpointResponse>;
     /** Legacy step 1 — POST /api/tasks/:taskId/comments. */
     addComment: (taskId: string, body: string) => Promise<TaskCommentResult>;
@@ -31,6 +35,8 @@ export interface DurableCompletionResult {
     movedTask: MovedTaskResult | null;
     moved: boolean;
     commentFailed: boolean;
+    deliveryHeld?: boolean;
+    deliveryReason?: string;
     /** true when the atomic /complete endpoint handled the finalization. */
     usedAtomicEndpoint: boolean;
 }
@@ -60,7 +66,7 @@ export declare function resolveCompletionTarget(taskRef: string, lookup: (taskRe
  * The repo contract calls this "the only terminal closeout", and a task has one
  * canonical outcome — but a second run used to succeed silently, post another
  * TASK_OUTPUT block, and leave `tasks output` rendering the throwaway one as
- * authoritative. The real summary and its artifacts link were still on the task
+ * authoritative. The real summary and its deliverables link were still on the task
  * but no longer canonical, which is the worst of the available failures: no
  * error, no warning, exit 0, and a record that now says something different.
  *
@@ -120,9 +126,10 @@ export declare function completeTaskDurably(opts: {
     status: CompletionStatus;
     body: string;
     summary: string;
-    artifacts: string;
+    deliverables: string;
     verdict: string;
     report?: TaskReport;
+    deliveryReceipt?: TaskDeliveryReceipt;
     noMove: boolean;
     transport: CompleteTransport;
 }): Promise<DurableCompletionResult>;
@@ -139,8 +146,8 @@ export default class TasksComplete extends BaseCommand {
         amend: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         status: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         summary: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        artifacts: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
-        artifact: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        deliverables: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        deliverable: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         verdict: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         outcome: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         finding: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/complete.js

@@ -21,6 +21,39 @@ const task_instruction_offer_1 = require("../../lib/task-instruction-offer");
 const task_transcript_1 = require("../../lib/task-transcript");
 const web_url_1 = require("../../lib/web-url");
 const tasks_1 = require("../../lib/tasks");
+const git_task_1 = require("../../lib/git-task");
+/**
+ * Forward any `--deliverable` value that is really a ledger coordinate.
+ *
+ * FAIL-OPEN, and quietly. This is a convenience bridge on the completion path:
+ * the completion itself is the operation the caller asked for, and a ledger
+ * write that fails must not take it down. A caller who needed the row and did
+ * not get it meets the gate's refusal, which names the command that writes it.
+ *
+ * `local`, never anything stronger — this is the executor talking about its own
+ * work, which is exactly what the authority ladder is built to weigh.
+ */
+async function recordCoordinateDeliverables({ taskId, values, warn, }) {
+    const seen = new Set();
+    for (const value of values) {
+        const raw = (value ?? '').trim();
+        if (!raw || raw === 'none' || seen.has(raw)) {
+            continue;
+        }
+        seen.add(raw);
+        const parsed = (0, tasks_1.parseDeliverableCoordinate)(raw);
+        if (!parsed.ok) {
+            continue;
+        }
+        try {
+            await data_provider_1.dataService.addTaskDeliverable(taskId, parsed.value);
+        }
+        catch {
+            warn(`Recorded "${raw}" in the report but not in the deliverables ledger. ` +
+                `If the task refuses to close, run \`tasks deliverable add\` for it.`);
+        }
+    }
+}
 /**
  * Mutation endpoints require the task's canonical UUID even though the CLI
  * accepts human-readable refs and titles. Resolve the display reference before
@@ -55,7 +88,7 @@ async function resolveCompletionTarget(taskRef, lookup) {
  * The repo contract calls this "the only terminal closeout", and a task has one
  * canonical outcome — but a second run used to succeed silently, post another
  * TASK_OUTPUT block, and leave `tasks output` rendering the throwaway one as
- * authoritative. The real summary and its artifacts link were still on the task
+ * authoritative. The real summary and its deliverables link were still on the task
  * but no longer canonical, which is the worst of the available failures: no
  * error, no warning, exit 0, and a record that now says something different.
  *
@@ -128,7 +161,7 @@ exports.TaskCompletionMismatchError = TaskCompletionMismatchError;
  * error handling.
  */
 async function completeTaskDurably(opts) {
-    const { taskId, status, body, summary, artifacts, verdict, report, noMove, transport } = opts;
+    const { taskId, status, body, summary, deliverables, verdict, report, deliveryReceipt, noMove, transport, } = opts;
     if (noMove) {
         const comment = await transport.addComment(taskId, body);
         return {
@@ -143,9 +176,10 @@ async function completeTaskDurably(opts) {
         const response = await transport.postComplete(taskId, {
             status,
             summary,
-            artifacts,
+            deliverables,
             verdict,
             ...(report ? { report } : {}),
+            ...(deliveryReceipt ? { deliveryReceipt } : {}),
         });
         // Reconcile before reporting. On the session-scoped path the server owns
         // the task selection, so a divergence here means the task we were asked to
@@ -160,6 +194,8 @@ async function completeTaskDurably(opts) {
             movedTask: response.task ?? null,
             moved: true,
             commentFailed: response.commentFailed === true,
+            ...(response.deliveryHeld ? { deliveryHeld: true } : {}),
+            ...(response.deliveryReason ? { deliveryReason: response.deliveryReason } : {}),
             usedAtomicEndpoint: true,
         };
     }
@@ -174,7 +210,13 @@ async function completeTaskDurably(opts) {
     // behavior (comment first, then move).
     const comment = await transport.addComment(taskId, body);
     const movedTask = await transport.moveTask(taskId, status === 'completed' ? 'done' : 'failed');
-    return { comment, movedTask, moved: true, commentFailed: false, usedAtomicEndpoint: false };
+    return {
+        comment,
+        movedTask,
+        moved: true,
+        commentFailed: false,
+        usedAtomicEndpoint: false,
+    };
 }
 class TasksComplete extends base_command_1.BaseCommand {
     static description = 'Post a canonical TASK_OUTPUT comment and finish a task';
@@ -199,7 +241,7 @@ class TasksComplete extends base_command_1.BaseCommand {
             description: 'Task ID or identifier; overrides daemon runtime context',
         }),
         'from-json': core_1.Flags.string({
-            description: 'Path to JSON with taskId, status, summary, artifacts, and verdict; "-" for stdin',
+            description: 'Path to JSON with taskId, status, summary, deliverables, and verdict; "-" for stdin',
         }),
         amend: core_1.Flags.boolean({
             description: 'Supersede the canonical outcome of an already-completed task. Without it, a differing report on a closed task is refused',
@@ -210,13 +252,13 @@ class TasksComplete extends base_command_1.BaseCommand {
             default: 'completed',
         }),
         summary: core_1.Flags.string({ description: 'Completion summary' }),
-        artifacts: core_1.Flags.string({
-            description: 'Artifacts produced, or "none". Repeatable, and interchangeable with --artifact. ' +
-                `The whole TASK_OUTPUT block (status + summary + artifacts + verdict) must fit in ${data_provider_1.TASK_OUTPUT_BODY_MAX} ` +
+        deliverables: core_1.Flags.string({
+            description: 'Deliverables produced, or "none". Repeatable, and interchangeable with --deliverable. ' +
+                `The whole TASK_OUTPUT block (status + summary + deliverables + verdict) must fit in ${data_provider_1.TASK_OUTPUT_BODY_MAX} ` +
                 'characters — link to commits, PRs, or file paths rather than pasting content.',
-            // Repeatable, even though `--artifact` already is. The two spellings sit
-            // one letter apart and both read as "the artifacts go here", so the wrong
-            // one gets typed — and oclif answered that with "Flag --artifacts can only
+            // Repeatable, even though `--deliverable` already is. The two spellings sit
+            // one letter apart and both read as "the deliverables go here", so the wrong
+            // one gets typed — and oclif answered that with "Flag --deliverables can only
             // be specified once", which names the flag you used and not the sibling
             // that does what you wanted. Dogfooded (OSK-266) by losing a completion
             // call to exactly that, then re-running with the two references pre-joined
@@ -224,9 +266,9 @@ class TasksComplete extends base_command_1.BaseCommand {
             multiple: true,
             default: ['none'],
         }),
-        artifact: core_1.Flags.string({
+        deliverable: core_1.Flags.string({
             description: 'A single artifact reference (repeatable); joined with commas. Prefer this ' +
-                'over pre-joining into --artifacts.',
+                'over pre-joining into --deliverables.',
             multiple: true,
         }),
         verdict: core_1.Flags.string({ description: 'Final verdict', default: 'approved' }),
@@ -271,13 +313,13 @@ class TasksComplete extends base_command_1.BaseCommand {
             summary: flags.summary,
             // Both spellings, pooled, then normalized to the one-line form the server
             // stores. Pooling rather than letting one win: someone who passes both has
-            // named artifacts in each, and silently dropping half of them is worse
+            // named deliverables in each, and silently dropping half of them is worse
             // than either flag being unavailable.
-            artifacts: (0, data_provider_1.normalizeTaskOutputArtifacts)([
-                ...(flags.artifact ?? []),
+            deliverables: (0, data_provider_1.normalizeTaskOutputDeliverables)([
+                ...(flags.deliverable ?? []),
                 // The literal default is dropped when it is only the default; a user
-                // who typed `--artifacts none` alongside a real one meant the real one.
-                ...(flags.artifacts ?? []).filter((value) => value !== 'none'),
+                // who typed `--deliverables none` alongside a real one meant the real one.
+                ...(flags.deliverables ?? []).filter((value) => value !== 'none'),
             ]) || 'none',
             verdict: flags.verdict,
         });
@@ -312,14 +354,14 @@ class TasksComplete extends base_command_1.BaseCommand {
         }
         let status;
         let summary;
-        let artifacts;
+        let deliverables;
         let verdict;
         let report;
         try {
             status = normalizeStatus(input.status);
             summary = requireOutputField(input.summary, 'summary');
-            artifacts =
-                optionalOutputField((0, data_provider_1.normalizeTaskOutputArtifacts)(input.artifacts)) || 'none';
+            deliverables =
+                optionalOutputField((0, data_provider_1.normalizeTaskOutputDeliverables)(input.deliverables)) || 'none';
             verdict =
                 optionalOutputField(input.verdict) || (status === 'completed' ? 'approved' : 'failed');
             const jsonReport = input.report && typeof input.report === 'object'
@@ -360,7 +402,7 @@ class TasksComplete extends base_command_1.BaseCommand {
         // budget the server enforces. Discovering an undocumented cap by HTTP 400
         // after a run has already finished is the failure being fixed; a caller must
         // be able to see the limit without provoking it.
-        const budget = (0, data_provider_1.measureTaskOutputBudget)({ status, summary, artifacts, verdict });
+        const budget = (0, data_provider_1.measureTaskOutputBudget)({ status, summary, deliverables, verdict });
         if (!budget.fits) {
             this.failWithCliError({
                 message: (0, data_provider_1.describeTaskOutputOverflow)(budget),
@@ -375,14 +417,21 @@ class TasksComplete extends base_command_1.BaseCommand {
                 },
             });
         }
-        const body = formatTaskOutput({ status, summary, artifacts, verdict });
+        const body = formatTaskOutput({ status, summary, deliverables, verdict });
+        // Artifact text such as a commit SHA is a delivery claim. The local probe
+        // both verifies remote-default ancestry and anchors a commit that has no
+        // local branch before the completion request can release this run.
+        const deliveryReceipt = status === 'completed' && !flags['no-move']
+            ? ((0, git_task_1.inspectTaskDeliveryArtifacts)({ deliverables, taskRef: taskIdentity.id }) ?? undefined)
+            : undefined;
         // Computed once, OUTSIDE the try, so the original attempt and the queued
         // replay carry the same key. Must match the payload the outbox stores.
         const completionPayload = {
             summary,
-            artifacts,
+            deliverables,
             verdict,
             ...(report ? { report } : {}),
+            ...(deliveryReceipt ? { deliveryReceipt } : {}),
             noMove: !!flags['no-move'],
         };
         const completionIdempotencyKey = (0, outbox_1.idempotencyKeyFor)('task-complete', taskIdentity.id, JSON.stringify(completionPayload));
@@ -456,7 +505,7 @@ class TasksComplete extends base_command_1.BaseCommand {
             if (decision === 'refuse') {
                 this.failWithCliError({
                     message: `Task ${completionTaskId} is already ${priorStatus}, and this report differs from its canonical ` +
-                        `outcome — completing again would silently replace it (artifacts included).\n` +
+                        `outcome — completing again would silently replace it (deliverables included).\n` +
                         `  → re-run with \`--amend\` to supersede it deliberately, or read what is there now with ` +
                         `\`${this.config.bin} tasks output ${completionTaskId}\`.`,
                     code: 'TASK_ALREADY_COMPLETED',
@@ -466,6 +515,31 @@ class TasksComplete extends base_command_1.BaseCommand {
                 });
             }
         }
+        // THE THIRD SPELLING, BRIDGED.
+        //
+        // `--deliverable` here is PROSE for the TASK_OUTPUT block. The ledger the
+        // completion gate reads is written by `tasks deliverable add`, and nothing
+        // connected the two — so an agent that ran
+        // `tasks complete --deliverable code:abc@origin/main` had, from its own
+        // point of view, recorded its deliverable, and was then refused by a gate
+        // whose message told it to record its deliverable.
+        //
+        // Three surfaces in one CLI answer to the word (`tasks deliverable add`,
+        // this flag, and `tasks report --deliverable`), and the project's own
+        // operating instructions teach the two that do NOT write the ledger. That
+        // is a documentation problem only if you believe people read the docs
+        // before the error; the cheaper fix is to make the wrong spelling do the
+        // right thing when what was typed is unambiguously a coordinate.
+        //
+        // Deliberately narrow: only values that PARSE as `<kind>:<identity>` are
+        // forwarded. A prose reference like `report.pdf` is left exactly as it was —
+        // guessing a coordinate out of prose is how the ledger fills with rows
+        // nobody can look up again.
+        await recordCoordinateDeliverables({
+            taskId: completionTaskId,
+            values: [...(flags.deliverable ?? []), ...(flags.deliverables ?? [])],
+            warn: (message) => this.warn(message),
+        });
         let result;
         try {
             result = await completeTaskDurably({
@@ -473,9 +547,10 @@ class TasksComplete extends base_command_1.BaseCommand {
                 status,
                 body,
                 summary,
-                artifacts,
+                deliverables,
                 verdict,
                 report,
+                deliveryReceipt,
                 noMove: !!flags['no-move'],
                 transport: {
                     postComplete: (taskId, payload) => (0, api_fetch_1.apiFetch)(
@@ -496,7 +571,7 @@ class TasksComplete extends base_command_1.BaseCommand {
             });
         }
         catch (err) {
-            // The completion summary/artifacts/verdict are authored content — the
+            // The completion summary/deliverables/verdict are authored content — the
             // record of what the agent actually did. Losing that to a 503 costs the
             // reasoning, not just a retry, so an OUTAGE queues it durably (OSK-2806)
             // while every 4xx still fails immediately through handleApiError.
@@ -531,11 +606,12 @@ class TasksComplete extends base_command_1.BaseCommand {
             taskOutput: {
                 status,
                 summary,
-                artifacts,
+                deliverables,
                 verdict,
                 ...(report ? { report } : {}),
                 body,
             },
+            ...(result.deliveryHeld ? { deliveryHeld: true, deliveryReason: result.deliveryReason } : {}),
         };
         if (flags.json) {
             const url = movedTask
@@ -558,6 +634,9 @@ class TasksComplete extends base_command_1.BaseCommand {
                 ? `Task ${completedTaskId} was already ${newStatus}; the outcome was amended.`
                 : `Moved task ${completedTaskId} to ${newStatus}`);
         }
+        if (result.deliveryHeld) {
+            this.warn('Delivery is not verified on the default branch; the task was held at in_review instead of done.');
+        }
         if (report) {
             const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, movedTask ?? { id: completedTaskId });
             if (url)

package/dist/commands/tasks/continue-ready.js

@@ -70,7 +70,15 @@ class TasksContinueReady extends base_command_1.BaseCommand {
                 this.handleApiError(err);
             }
         }
-        const freeSlots = capacity ? capacity.availableSlots : Number.POSITIVE_INFINITY;
+        // `availableSlots` is null for an UNLIMITED space, which is the default.
+        // `Math.min(n, null)` is 0, so the previous arithmetic silently computed a
+        // start limit of zero and reported every ready task as "skipped for
+        // capacity" on exactly the spaces that had no capacity limit at all. The
+        // platform's own helper warns about this: callers must branch on null
+        // rather than do arithmetic on it (SpaceTaskConcurrency.availableSlotsFor).
+        const freeSlots = capacity && capacity.availableSlots !== null
+            ? capacity.availableSlots
+            : Number.POSITIVE_INFINITY;
         const startLimit = Math.max(0, Math.min(flags['max-starts'], freeSlots));
         const selected = ready.slice(0, startLimit);
         const skippedForCapacity = ready.slice(startLimit);

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

@@ -53,6 +53,7 @@ export default class TasksCreate extends BaseCommand {
         'assignee-user': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         '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>;
         '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

@@ -71,7 +71,8 @@ class TasksCreate extends base_command_1.BaseCommand {
             description: 'Validate and print the create payload without writing a task',
         }),
         'from-json': core_1.Flags.string({
-            description: 'Path to a JSON file (or "-" for stdin) to use as the request body',
+            description: 'Path to a JSON file (or "-" for stdin) to use as the request body. ' +
+                'Accepts stored names (projectId, goalId) and create-flag aliases (project, goal, spawnedBy).',
         }),
         template: core_1.Flags.string({
             description: 'Saved task template ID, or an exact template name with --space. Creates its whole task tree; supplied task flags override the root.',
@@ -136,6 +137,12 @@ class TasksCreate extends base_command_1.BaseCommand {
         'dri-user': core_1.Flags.string({
             description: 'Explicit accountable human DRI (separate from assignees)',
         }),
+        expect: core_1.Flags.string({
+            multiple: true,
+            description: tasks_1.EXPECT_FLAG_HELP +
+                " Injected into the agent's instructions and checked against what the run produced. " +
+                'Omit to inherit the space default.',
+        }),
         '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, ' +
@@ -184,7 +191,25 @@ class TasksCreate extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
-        const payload = (0, tasks_1.buildTaskCreatePayload)(body, flags);
+        // Resolve --expect BEFORE any write. A bad spec must fail here rather than
+        // reaching the server as a silently-dropped field: a declaration that did
+        // not stick is worse than none, because the board then shows a contract
+        // nobody is enforcing.
+        const parsedExpectations = (0, tasks_1.parseExpectations)(flags.expect);
+        if (!parsedExpectations.ok) {
+            this.failWithCliError({
+                message: parsedExpectations.error,
+                code: 'INVALID_TASK_EXPECTATION',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const payload = (0, tasks_1.buildTaskCreatePayload)(body, {
+            ...flags,
+            expectations: parsedExpectations.ok && parsedExpectations.value.length > 0
+                ? parsedExpectations.value
+                : undefined,
+        });
         const isTemplateInstantiation = typeof payload.templateId === 'string' && payload.templateId.length > 0;
         // Template defaults (including its assigned agents) are part of the saved
         // resource. Do not let the ordinary "who owns an empty task?" policy

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

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * `skrr tasks deliverable add <task> <kind>:<identity>[@<location>]`
+ *
+ * The command an agent runs to say what it produced. Deliberately small: one
+ * positional carrying a coordinate it already knows, because the measured
+ * behaviour is that agents emit a real commit sha 77% of the time when asked
+ * for it in a required field, and 0% of the time when asked for it in an
+ * optional structured one.
+ */
+export default class TasksDeliverableAdd 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>>;
+    };
+    static flags: {
+        lifecycle: 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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const tasks_1 = require("../../../lib/tasks");
+/**
+ * `skrr tasks deliverable add <task> <kind>:<identity>[@<location>]`
+ *
+ * The command an agent runs to say what it produced. Deliberately small: one
+ * positional carrying a coordinate it already knows, because the measured
+ * behaviour is that agents emit a real commit sha 77% of the time when asked
+ * for it in a required field, and 0% of the time when asked for it in an
+ * 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 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',
+    ];
+    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',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        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`.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksDeliverableAdd);
+        const parsed = (0, tasks_1.parseDeliverableCoordinate)(args.coordinate);
+        if (!parsed.ok) {
+            // For an agent this message IS the documentation — it hits the error and
+            // corrects, so the refusal carries the whole form and vocabulary.
+            this.error(parsed.error, { exit: 1 });
+            return;
+        }
+        let result;
+        try {
+            result = await data_provider_1.dataService.addTaskDeliverable(args.task, {
+                ...parsed.value,
+                ...(flags.lifecycle ? { lifecycle: flags.lifecycle } : {}),
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const where = parsed.value.location ? ` at ${parsed.value.location}` : '';
+        this.log(`Recorded ${parsed.value.kind}:${parsed.value.identity}${where} (${flags.lifecycle || 'local'}).`);
+    }
+}
+exports.default = TasksDeliverableAdd;

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

@@ -0,0 +1,35 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * `skrr tasks deliverable confirm <task> <kind>:<identity>[@<location>] --reason "<what you checked>"`
+ *
+ * Somebody looked, and it is there.
+ *
+ * WHY THIS IS A SEPARATE COMMAND from `deliverable add`. Recording and vouching
+ * are different claims. `add` says "this exists, and I am the one who made it";
+ * this says "I checked, independently of whoever made it". Five of the six
+ * outcome kinds have no automatic observer — nothing in the platform watches a
+ * Drive folder or a Slack channel — so without this rung an expectation for a
+ * PDF or a posted message could only ever be closed by waiving it, which
+ * records "we decided we did not need this" about work that was actually done.
+ *
+ * The reason is required, for the same purpose a waiver's and a judgement's
+ * are: the entire value of a confirmation is that a person actually looked, and
+ * a confirmation with nothing written down is indistinguishable from a click.
+ *
+ * It UPSERTS. Confirming something the executor never recorded is legitimate —
+ * the thing is there either way — and making a person file the row first before
+ * they may vouch for it is ceremony that buys nothing.
+ */
+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>>;
+    };
+    static flags: {
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}