@skrr-ai/cli 0.1.14 → 0.1.15

package/dist/lib/task-execution.js

@@ -79,10 +79,15 @@ function satisfiesWaitTarget(task, until) {
     return until === 'terminal' ? exports.TERMINAL_STATUSES.has(status) : status === until;
 }
 function isActiveTask(task) {
-    const status = statusOf(task);
-    return (status === 'in_progress' ||
-        isNonEmptyString(task.checkoutRunId) ||
-        isNonEmptyString(task.sessionId));
+    if (isTerminalTask(task))
+        return false;
+    const reasonCode = task.actionability?.reasonCode;
+    if (typeof reasonCode === 'string')
+        return reasonCode === 'execution_running';
+    // Compatibility for older servers that do not attach actionability. A
+    // workflow status or leftover session is not compute ownership; only the
+    // checkout is a conservative fallback.
+    return isNonEmptyString(task.checkoutRunId);
 }
 function isRecoveredExecutionTask(task) {
     if (!isStartableTask(task))
@@ -178,19 +183,25 @@ async function fetchSpaceTasks(spaceId, limit = 500) {
     return items;
 }
 async function getSpaceCapacity(spaceId, limit = 1000) {
-    const [space, tasks] = await Promise.all([
+    const [space, tasks, preview] = await Promise.all([
         data_provider_1.dataService.getSpace(spaceId),
         fetchSpaceTasks(spaceId, limit),
+        data_provider_1.dataService.previewSpaceAutoExecutor(spaceId),
     ]);
     const activeTasks = tasks.filter(isActiveTask);
-    const maxActiveTasks = normalizePositiveInt(space.autoExecuteMaxActiveTasks, 3);
-    const activeCount = activeTasks.length;
+    const canonicalCapacity = preview?.plan?.capacity;
+    if (!canonicalCapacity) {
+        throw new Error('Space auto-executor preview did not return canonical capacity');
+    }
+    const maxActiveTasks = canonicalCapacity.maxActiveTasks;
+    const activeCount = canonicalCapacity.activeCount;
     return {
         object: 'space_task_capacity',
         space,
         maxActiveTasks,
         activeCount,
-        availableSlots: Math.max(0, maxActiveTasks - activeCount),
+        availableSlots: canonicalCapacity.availableSlots,
+        budget: canonicalCapacity.budget ?? null,
         activeTasks,
         sampledTaskCount: tasks.length,
     };
@@ -314,9 +325,3 @@ function stringValue(value) {
 function isNonEmptyString(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }
-function normalizePositiveInt(value, fallback) {
-    const n = Number(value);
-    if (!Number.isFinite(n) || n <= 0)
-        return fallback;
-    return Math.floor(n);
-}

package/dist/lib/task-transcript.js

@@ -53,7 +53,7 @@ function parseTaskOutputBlock(body) {
     return {
         status: field('status'),
         summary: field('summary'),
-        artifacts: field('artifacts'),
+        artifacts: field('deliverables') || field('artifacts'),
         verdict: field('verdict'),
     };
 }

package/dist/lib/tasks.d.ts

@@ -1,3 +1,4 @@
+import type { ParsedDeliverableCoordinate, ParsedExpectationSpec } from '@skrr-ai/data-provider';
 export declare const TASK_PRIORITIES: readonly ["low", "medium", "high", "critical"];
 /**
  * The kinds `tasks events append --kind` will accept.
@@ -50,6 +51,14 @@ export type TaskCreateFlagValues = {
     'assignee-agent'?: string[];
     'assignee-user'?: string[];
     'execution-mode'?: string;
+    expectations?: Array<{
+        shape?: string;
+        kind?: string;
+        format?: string;
+        target?: string;
+        description?: string;
+        presetKey?: string;
+    }>;
     'start-date'?: string;
     'due-date'?: string;
     estimate?: number;
@@ -62,6 +71,47 @@ export type TaskCreateFlagValues = {
  * true ⇒ 'ephemeral', false ⇒ 'shared', undefined ⇒ undefined (inherit/leave).
  */
 export declare function executionIsolationFromWorktreeFlag(worktree: boolean | undefined): 'shared' | 'ephemeral' | undefined;
+/**
+ * Parse an expectation spec.
+ *
+ * DELEGATES to `@skrr-ai/data-provider`, which owns the grammar and is read by
+ * the API and the web client too. The copy this replaces validated correctly
+ * and then described a syntax it refused — its messages named three different
+ * flags (`--requires`, `--output`, `--accept`) and used `git_ref:origin/main`
+ * as the example, a value the same function rejects. For an agent the refusal
+ * IS the documentation: it hits the error and corrects, so an error naming a
+ * rejected example costs a whole turn and can loop.
+ */
+export declare function parseExpectation(spec: string): {
+    ok: true;
+    value: ParsedExpectationSpec;
+} | {
+    ok: false;
+    error: string;
+};
+/** Parse several, failing on the first that cannot be read. */
+export declare function parseExpectations(specs: string[] | undefined): {
+    ok: true;
+    value: ParsedExpectationSpec[];
+} | {
+    ok: false;
+    error: string;
+};
+export declare const EXPECT_FLAG_HELP: string;
+/**
+ * Parse a deliverable coordinate. Also delegated — `:` and `@` and now `/` all
+ * mean different things, and a second implementation of that grammar is how the
+ * declaring side and the recording side stop agreeing.
+ */
+export declare function parseDeliverableCoordinate(spec: string): {
+    ok: true;
+    value: ParsedDeliverableCoordinate;
+} | {
+    ok: false;
+    error: string;
+};
+/** Lifecycle values a caller may assert, for flag validation. */
+export declare const DELIVERABLE_LIFECYCLE_VALUES: readonly ["local", "in_review", "durable", "blocked", "superseded"];
 export declare function buildTaskCreatePayload(body: TaskRecord, flags?: TaskCreateFlagValues): TaskRecord;
 /**
  * The Agent this CLI process is running AS, if any.

package/dist/lib/tasks.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RECOGNIZED_TASK_VERDICTS = exports.TASK_WORK_EVENT_KINDS = exports.TASK_PRIORITIES = void 0;
+exports.RECOGNIZED_TASK_VERDICTS = exports.DELIVERABLE_LIFECYCLE_VALUES = exports.EXPECT_FLAG_HELP = exports.TASK_WORK_EVENT_KINDS = exports.TASK_PRIORITIES = void 0;
 exports.releasePinRepairGuard = releasePinRepairGuard;
 exports.taskUpdateMutationGuard = taskUpdateMutationGuard;
 exports.executionIsolationFromWorktreeFlag = executionIsolationFromWorktreeFlag;
+exports.parseExpectation = parseExpectation;
+exports.parseExpectations = parseExpectations;
+exports.parseDeliverableCoordinate = parseDeliverableCoordinate;
 exports.buildTaskCreatePayload = buildTaskCreatePayload;
 exports.boundSessionAgentId = boundSessionAgentId;
 exports.applyDaemonSessionDefaults = applyDaemonSessionDefaults;
@@ -106,6 +109,67 @@ function executionIsolationFromWorktreeFlag(worktree) {
         return undefined;
     return worktree ? 'ephemeral' : 'shared';
 }
+/**
+ * Parse an expectation spec.
+ *
+ * DELEGATES to `@skrr-ai/data-provider`, which owns the grammar and is read by
+ * the API and the web client too. The copy this replaces validated correctly
+ * and then described a syntax it refused — its messages named three different
+ * flags (`--requires`, `--output`, `--accept`) and used `git_ref:origin/main`
+ * as the example, a value the same function rejects. For an agent the refusal
+ * IS the documentation: it hits the error and corrects, so an error naming a
+ * rejected example costs a whole turn and can loop.
+ */
+function parseExpectation(spec) {
+    return (0, data_provider_1.parseExpectationSpec)(spec);
+}
+/** Parse several, failing on the first that cannot be read. */
+function parseExpectations(specs) {
+    if (!specs || specs.length === 0) {
+        return { ok: true, value: [] };
+    }
+    const out = [];
+    for (const spec of specs) {
+        const parsed = (0, data_provider_1.parseExpectationSpec)(spec);
+        if (!parsed.ok) {
+            return parsed;
+        }
+        out.push(parsed.value);
+    }
+    return { ok: true, value: out };
+}
+/**
+ * The one-line help every expectation flag shares, so they cannot disagree.
+ *
+ * The vocabulary is read from the owning package, but DEFENSIVELY: oclif
+ * evaluates a flag `description` when the command class body runs, i.e. at
+ * module load, and several suites mock `@skrr-ai/data-provider` with an
+ * explicit allow-list that predates these exports. Under such a mock the arrays
+ * are `undefined`, and a HELP STRING is never worth failing a module load for —
+ * the fallbacks below are a test-environment courtesy, never the vocabulary
+ * anything is validated against. `parseExpectationSpec` runs at call time
+ * against the real module and remains the only authority.
+ */
+const kindsForHelp = Array.isArray(data_provider_1.TASK_OUTCOME_KINDS)
+    ? data_provider_1.TASK_OUTCOME_KINDS.join(', ')
+    : 'code, page, url, file, message, dataset';
+const presetsForHelp = Array.isArray(data_provider_1.EXPECTATION_PRESETS)
+    ? data_provider_1.EXPECTATION_PRESETS.map((preset) => `@${preset.key}`).join(', ')
+    : '@merged-to-main, @pdf-delivered';
+exports.EXPECT_FLAG_HELP = 'What this task must produce, as <kind>[/<format>][:<target>] or @<preset> — ' +
+    `e.g. 'code:origin/main', 'file/pdf:Drive/Reports', '@merged-to-main'. ` +
+    `Kinds: ${kindsForHelp}. Presets: ${presetsForHelp}. ` +
+    'Anything else is stored as a plain-language expectation a person settles. Repeatable.';
+/**
+ * Parse a deliverable coordinate. Also delegated — `:` and `@` and now `/` all
+ * mean different things, and a second implementation of that grammar is how the
+ * declaring side and the recording side stop agreeing.
+ */
+function parseDeliverableCoordinate(spec) {
+    return (0, data_provider_1.parseDeliverableCoordinate)(spec);
+}
+/** Lifecycle values a caller may assert, for flag validation. */
+exports.DELIVERABLE_LIFECYCLE_VALUES = data_provider_1.DELIVERABLE_LIFECYCLES;
 function buildTaskCreatePayload(body, flags = {}) {
     const payload = (0, prompt_1.mergeDefined)(body, {
         templateId: flags.template,
@@ -123,6 +187,7 @@ function buildTaskCreatePayload(body, flags = {}) {
         assigneeAgentIds: flags['assignee-agent'],
         assigneeUserIds: flags['assignee-user'],
         executionMode: flags['execution-mode'],
+        expectations: flags.expectations,
         startDate: flags['start-date'],
         dueDate: flags['due-date'],
         estimate: flags.estimate,