@skrr-ai/cli 0.1.14 → 0.1.17

package/dist/lib/git-task.js

@@ -34,11 +34,162 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitTaskError = void 0;
+exports.commitArtifacts = commitArtifacts;
+exports.inspectTaskDeliveryArtifacts = inspectTaskDeliveryArtifacts;
 exports.currentGitBranch = currentGitBranch;
 exports.currentGitTaskBranch = currentGitTaskBranch;
 exports.checkoutTaskBranch = checkoutTaskBranch;
 const node_child_process_1 = require("node:child_process");
 const taskReferences = __importStar(require("@skrr-ai/data-provider"));
+const COMMIT_ARTIFACT_RE = /(?:^|[\s,;:(/])(?:commit\s+)?([0-9a-f]{7,40})(?=$|[\s,;:)?#])/gi;
+const GITHUB_PR_ARTIFACT_RE = /https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/\d+/i;
+function runCommand(command, args, cwd) {
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 15_000,
+    });
+    return {
+        status: result.status,
+        stdout: typeof result.stdout === 'string' ? result.stdout.trim() : '',
+        stderr: typeof result.stderr === 'string' ? result.stderr.trim() : '',
+    };
+}
+function commitArtifacts(deliverables) {
+    const commits = [];
+    for (const match of deliverables.matchAll(COMMIT_ARTIFACT_RE)) {
+        const sha = match[1].toLowerCase();
+        if (!commits.includes(sha))
+            commits.push(sha);
+    }
+    return commits;
+}
+function safeTaskBranchRef(taskRef, sha) {
+    const match = taskRef.match(/[A-Za-z][A-Za-z0-9]{1,31}-\d{1,12}/);
+    const label = match?.[0].toUpperCase() || 'recovery';
+    return `oversky/task/${label}/recovery-${sha.slice(0, 12)}`;
+}
+function resolveRemoteDefault(cwd, remote, runner) {
+    const live = runner('git', ['ls-remote', '--symref', remote, 'HEAD'], cwd);
+    if (live.status === 0) {
+        const match = live.stdout.match(/^ref:\s+refs\/heads\/(\S+)\s+HEAD$/m);
+        if (match)
+            return match[1];
+    }
+    const symbolic = runner('git', ['symbolic-ref', '--quiet', '--short', `refs/remotes/${remote}/HEAD`], cwd);
+    if (symbolic.status === 0 && symbolic.stdout.startsWith(`${remote}/`)) {
+        return symbolic.stdout.slice(remote.length + 1);
+    }
+    for (const fallback of ['main', 'master']) {
+        if (runner('git', ['show-ref', '--verify', '--quiet', `refs/remotes/${remote}/${fallback}`], cwd)
+            .status === 0) {
+            return fallback;
+        }
+    }
+    return null;
+}
+/**
+ * Build a receipt for commit/PR deliverables before `tasks complete` writes
+ * anything. Commit reachability is checked against a freshly fetched remote
+ * default branch. A locally dangling commit is first anchored under refs/heads
+ * so even a held completion cannot leave it exposed to `git gc`.
+ */
+function inspectTaskDeliveryArtifacts(opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const runner = opts.runner ?? runCommand;
+    const commits = commitArtifacts(opts.deliverables);
+    const verifiedCommits = [];
+    let containingBranch;
+    for (const claimed of commits) {
+        const resolved = runner('git', ['rev-parse', '--verify', `${claimed}^{commit}`], cwd);
+        if (resolved.status !== 0 || !/^[0-9a-f]{40}$/i.test(resolved.stdout))
+            continue;
+        const sha = resolved.stdout.toLowerCase();
+        verifiedCommits.push(sha);
+        const branches = runner('git', ['for-each-ref', '--format=%(refname:short)', '--contains', sha, 'refs/heads'], cwd);
+        const firstBranch = branches.stdout.split('\n').find(Boolean);
+        if (firstBranch) {
+            containingBranch ||= firstBranch;
+            continue;
+        }
+        const recoveryBranch = safeTaskBranchRef(opts.taskRef, sha);
+        const existing = runner('git', ['show-ref', '--verify', '--quiet', `refs/heads/${recoveryBranch}`], cwd);
+        if (existing.status !== 0) {
+            const anchored = runner('git', ['update-ref', `refs/heads/${recoveryBranch}`, sha], cwd);
+            if (anchored.status !== 0) {
+                throw new Error(`Commit ${sha} is not reachable from a named local branch, and ${recoveryBranch} ` +
+                    'could not be created. Completion was refused so the commit is not reported as safe.');
+            }
+            containingBranch ||= recoveryBranch;
+        }
+        else {
+            containingBranch ||= recoveryBranch;
+        }
+    }
+    const prUrl = opts.deliverables.match(GITHUB_PR_ARTIFACT_RE)?.[0];
+    if (prUrl) {
+        const viewed = runner('gh', [
+            'pr',
+            'view',
+            prUrl,
+            '--json',
+            'mergedAt,headRefName,headRefOid,baseRefName,mergeCommit,url',
+        ], cwd);
+        if (viewed.status === 0) {
+            try {
+                const pr = JSON.parse(viewed.stdout);
+                const headSha = typeof pr.headRefOid === 'string' ? pr.headRefOid : undefined;
+                const mergeCommit = pr.mergeCommit && typeof pr.mergeCommit === 'object'
+                    ? pr.mergeCommit.oid
+                    : undefined;
+                return {
+                    kind: 'pull_request',
+                    state: pr.mergedAt ? 'integrated' : 'pr_open',
+                    prUrl,
+                    ...(typeof pr.headRefName === 'string' ? { branch: pr.headRefName } : {}),
+                    ...(headSha && /^[0-9a-f]{7,40}$/i.test(headSha) ? { headSha } : {}),
+                    ...(typeof pr.baseRefName === 'string' ? { integrationBranch: pr.baseRefName } : {}),
+                    ...(typeof mergeCommit === 'string' && /^[0-9a-f]{7,40}$/i.test(mergeCommit)
+                        ? { mergeCommit }
+                        : {}),
+                };
+            }
+            catch {
+                // Invalid/unavailable gh evidence is not proof of integration.
+            }
+        }
+        return { kind: 'pull_request', state: 'pr_open', prUrl };
+    }
+    if (!commits.length || verifiedCommits.length !== commits.length)
+        return null;
+    const remotes = runner('git', ['remote'], cwd).stdout.split('\n').filter(Boolean);
+    const remote = remotes.includes('origin') ? 'origin' : remotes[0];
+    const integrationBranch = remote ? resolveRemoteDefault(cwd, remote, runner) : null;
+    let integrated = false;
+    if (remote && integrationBranch) {
+        const fetched = runner('git', [
+            'fetch',
+            '--quiet',
+            '--no-tags',
+            remote,
+            `+refs/heads/${integrationBranch}:refs/remotes/${remote}/${integrationBranch}`,
+        ], cwd);
+        integrated =
+            fetched.status === 0 &&
+                verifiedCommits.every((sha) => runner('git', ['merge-base', '--is-ancestor', sha, `refs/remotes/${remote}/${integrationBranch}`], cwd).status === 0);
+    }
+    const headSha = verifiedCommits[verifiedCommits.length - 1];
+    return {
+        kind: 'commit',
+        state: integrated ? 'integrated' : 'branch_ready',
+        commitShas: verifiedCommits,
+        headSha,
+        ...(containingBranch ? { branch: containingBranch } : {}),
+        ...(integrationBranch ? { integrationBranch } : {}),
+        ...(integrated ? { mergeCommit: headSha } : {}),
+    };
+}
 class GitTaskError extends Error {
     code;
     constructor(message, code) {

package/dist/lib/instruction-blocks.d.ts

@@ -0,0 +1,29 @@
+import type { AgentPromptBlockEntry, AgentPromptComposition, InstructionBlock, InstructionBlockCatalogResponse } from '@skrr-ai/data-provider';
+/**
+ * Helpers shared by the reusable Block Library commands and the per-Agent
+ * composition commands.  Keep this deliberately about data shape, not HTTP:
+ * the server remains the authority that resolves versions, bindings and
+ * rendered text before an Agent is saved.
+ */
+export declare function parseJsonFlag<T>(value: string | undefined, flag: string): T | undefined;
+export declare function parseStringArrayFlag(value: string | undefined, flag: string): string[] | undefined;
+/** Parse repeated `--binding key=value` flags without ever guessing a key. */
+export declare function parseBindings(values: string[] | undefined): Record<string, string> | undefined;
+/**
+ * Read the structured source when it exists; otherwise preserve the legacy
+ * prompt byte-for-byte as one inline entry before changing anything.  This is
+ * the same compatibility move as the server-side resolver, so `add` never
+ * drops an Agent's existing instructions merely because it predates Blocks.
+ */
+export declare function compositionForAgent(agent: {
+    promptComposition?: unknown;
+    instructions?: unknown;
+}): AgentPromptComposition;
+export declare function nextInstanceId(kind?: 'inline' | 'library'): string;
+export declare function entryByInstance(composition: AgentPromptComposition, instanceId: string): AgentPromptBlockEntry;
+export declare function replaceEntry(composition: AgentPromptComposition, instanceId: string, replacement: AgentPromptBlockEntry): AgentPromptComposition;
+export declare function removeEntry(composition: AgentPromptComposition, instanceId: string): AgentPromptComposition;
+/** Move one instance immediately before or after a different existing instance. */
+export declare function moveEntry(composition: AgentPromptComposition, instanceId: string, anchorId: string, placement: 'before' | 'after'): AgentPromptComposition;
+export declare function findBlock(catalog: InstructionBlockCatalogResponse, reference: string): InstructionBlock | undefined;
+export declare function renderInstructionBlockDetail(block: InstructionBlock): string[];

package/dist/lib/instruction-blocks.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonFlag = parseJsonFlag;
+exports.parseStringArrayFlag = parseStringArrayFlag;
+exports.parseBindings = parseBindings;
+exports.compositionForAgent = compositionForAgent;
+exports.nextInstanceId = nextInstanceId;
+exports.entryByInstance = entryByInstance;
+exports.replaceEntry = replaceEntry;
+exports.removeEntry = removeEntry;
+exports.moveEntry = moveEntry;
+exports.findBlock = findBlock;
+exports.renderInstructionBlockDetail = renderInstructionBlockDetail;
+const node_crypto_1 = require("node:crypto");
+/**
+ * Helpers shared by the reusable Block Library commands and the per-Agent
+ * composition commands.  Keep this deliberately about data shape, not HTTP:
+ * the server remains the authority that resolves versions, bindings and
+ * rendered text before an Agent is saved.
+ */
+function parseJsonFlag(value, flag) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error(`${flag} must be valid JSON`);
+    }
+}
+function parseStringArrayFlag(value, flag) {
+    const parsed = parseJsonFlag(value, flag);
+    if (parsed === undefined)
+        return undefined;
+    if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== 'string')) {
+        throw new Error(`${flag} must be a JSON array of strings`);
+    }
+    return parsed;
+}
+/** Parse repeated `--binding key=value` flags without ever guessing a key. */
+function parseBindings(values) {
+    if (!values?.length)
+        return undefined;
+    const bindings = {};
+    for (const value of values) {
+        const separator = value.indexOf('=');
+        if (separator < 1) {
+            throw new Error(`Invalid binding "${value}". Use --binding key=value.`);
+        }
+        const key = value.slice(0, separator).trim();
+        if (!/^[a-z][a-z0-9_]{0,63}$/.test(key)) {
+            throw new Error(`Invalid binding key "${key}".`);
+        }
+        if (Object.prototype.hasOwnProperty.call(bindings, key)) {
+            throw new Error(`Binding "${key}" was supplied more than once.`);
+        }
+        bindings[key] = value.slice(separator + 1).trim();
+    }
+    return bindings;
+}
+/**
+ * Read the structured source when it exists; otherwise preserve the legacy
+ * prompt byte-for-byte as one inline entry before changing anything.  This is
+ * the same compatibility move as the server-side resolver, so `add` never
+ * drops an Agent's existing instructions merely because it predates Blocks.
+ */
+function compositionForAgent(agent) {
+    const composition = agent.promptComposition;
+    if (composition &&
+        typeof composition === 'object' &&
+        !Array.isArray(composition) &&
+        composition.schemaVersion === 1 &&
+        Array.isArray(composition.entries)) {
+        return composition;
+    }
+    const instructions = agent.instructions;
+    if (typeof instructions === 'string' && instructions.length) {
+        return {
+            schemaVersion: 1,
+            entries: [
+                {
+                    instanceId: nextInstanceId('inline'),
+                    enabled: true,
+                    source: { kind: 'inline', title: 'Core instructions', body: instructions },
+                },
+            ],
+        };
+    }
+    return { schemaVersion: 1, entries: [] };
+}
+function nextInstanceId(kind = 'inline') {
+    return `${kind}_${(0, node_crypto_1.randomUUID)()}`;
+}
+function entryByInstance(composition, instanceId) {
+    const entry = composition.entries.find((candidate) => candidate.instanceId === instanceId);
+    if (!entry) {
+        throw new Error(`No instruction block instance "${instanceId}". Run \`skrr agents instructions show\` to list this Agent's instances.`);
+    }
+    return entry;
+}
+function replaceEntry(composition, instanceId, replacement) {
+    entryByInstance(composition, instanceId);
+    return {
+        schemaVersion: 1,
+        entries: composition.entries.map((entry) => entry.instanceId === instanceId ? replacement : entry),
+    };
+}
+function removeEntry(composition, instanceId) {
+    entryByInstance(composition, instanceId);
+    return {
+        schemaVersion: 1,
+        entries: composition.entries.filter((entry) => entry.instanceId !== instanceId),
+    };
+}
+/** Move one instance immediately before or after a different existing instance. */
+function moveEntry(composition, instanceId, anchorId, placement) {
+    if (instanceId === anchorId)
+        throw new Error('A block cannot be moved relative to itself.');
+    const entry = entryByInstance(composition, instanceId);
+    entryByInstance(composition, anchorId);
+    const remaining = composition.entries.filter((candidate) => candidate.instanceId !== instanceId);
+    const anchor = remaining.findIndex((candidate) => candidate.instanceId === anchorId);
+    const insertAt = placement === 'before' ? anchor : anchor + 1;
+    return {
+        schemaVersion: 1,
+        entries: [...remaining.slice(0, insertAt), entry, ...remaining.slice(insertAt)],
+    };
+}
+function findBlock(catalog, reference) {
+    return [...catalog.official, ...catalog.library].find((block) => block.id === reference);
+}
+function renderInstructionBlockDetail(block) {
+    const current = block.versions.find((version) => version.version === block.currentVersion);
+    const lines = [
+        `${block.name}  (${block.id})`,
+        `Source:     ${block.source}`,
+        `Visibility: ${block.visibility}`,
+        `Status:     ${block.status}`,
+        `Version:    v${block.currentVersion}`,
+    ];
+    if (block.summary)
+        lines.push(`Summary:    ${block.summary}`);
+    if (block.tags.length)
+        lines.push(`Tags:       ${block.tags.join(', ')}`);
+    if (current) {
+        if (current.requirements.length) {
+            lines.push(`Needs:      ${current.requirements
+                .map((requirement) => `${requirement.kind}:${requirement.key}${requirement.access ? ` (${requirement.access})` : ''}`)
+                .join(', ')} — declarative only; this does not grant access`);
+        }
+        if (current.parameterSchema.length) {
+            lines.push(`Parameters: ${current.parameterSchema
+                .map((parameter) => `${parameter.key}${parameter.required ? ' (required)' : ''}`)
+                .join(', ')}`);
+        }
+        lines.push('', 'Instructions:', ...current.bodyTemplate.split('\n').map((line) => `  ${line}`));
+    }
+    return lines;
+}

package/dist/lib/runtime-start-verification.d.ts

@@ -0,0 +1,49 @@
+/** Matches the runtime's EX_CONFIG result for a permanent local configuration failure. */
+export declare const DAEMON_START_REAUTH_EXIT = 78;
+/** Matches the runtime's EX_TEMPFAIL result when a service cannot remain running. */
+export declare const DAEMON_START_UNVERIFIED_EXIT = 75;
+export type RuntimeStartStatus = {
+    profile: string;
+    serverUrl: string | null;
+    cwd: string | null;
+    reauth: {
+        needed: boolean;
+        reason: string | null;
+    };
+    running: boolean;
+    runtimeStatus: string | null;
+};
+export type RuntimeStartVerification = {
+    status: 'running';
+} | {
+    status: 'reauth_required';
+    profile: string;
+    reason: string | null;
+    recoveryCommand: string;
+} | {
+    status: 'not_running';
+    profile: string;
+    runtimeStatus: string | null;
+} | {
+    status: 'unreadable_status';
+    profile: string;
+};
+/**
+ * The status probe must observe the same profile as the start request. A
+ * runtime's `--profile` flag is global, so it is deliberately returned after
+ * `status` here and normalized by execRuntimeBinary before spawning.
+ */
+export declare function statusArgsForStart(argv: readonly string[]): string[];
+export declare function parseRuntimeStartStatus(value: unknown, fallbackProfile: string): RuntimeStartStatus | null;
+/**
+ * `skrr daemon login` is the public wrapper for daemon-scope login. Explicit
+ * server, profile, and cwd make this remedy target the stopped daemon rather
+ * than whichever CLI profile or working directory happens to be current.
+ */
+export declare function daemonLoginRecoveryCommand(status: RuntimeStartStatus): string;
+/**
+ * A runtime binary may predate a CLI update. Treat its successful process exit
+ * as an unverified supervisor request until `status --json` proves it either
+ * stayed alive or named the permanent re-auth latch it wrote.
+ */
+export declare function verifyRuntimeStart(statusOutput: string, statusExitCode: number, argv: readonly string[]): RuntimeStartVerification;

package/dist/lib/runtime-start-verification.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_START_UNVERIFIED_EXIT = exports.DAEMON_START_REAUTH_EXIT = void 0;
+exports.statusArgsForStart = statusArgsForStart;
+exports.parseRuntimeStartStatus = parseRuntimeStartStatus;
+exports.daemonLoginRecoveryCommand = daemonLoginRecoveryCommand;
+exports.verifyRuntimeStart = verifyRuntimeStart;
+const keychain_1 = require("./keychain");
+/** Matches the runtime's EX_CONFIG result for a permanent local configuration failure. */
+exports.DAEMON_START_REAUTH_EXIT = 78;
+/** Matches the runtime's EX_TEMPFAIL result when a service cannot remain running. */
+exports.DAEMON_START_UNVERIFIED_EXIT = 75;
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function asString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function profileFromArgv(argv) {
+    return ((0, keychain_1.resolveProfileFromArgv)(argv) ??
+        process.env.OVERSKY_PROFILE ??
+        (0, keychain_1.getActiveProfile)() ??
+        keychain_1.DEFAULT_PROFILE);
+}
+function quoteShellArg(value) {
+    return /^[A-Za-z0-9_./:@+=-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
+/**
+ * The status probe must observe the same profile as the start request. A
+ * runtime's `--profile` flag is global, so it is deliberately returned after
+ * `status` here and normalized by execRuntimeBinary before spawning.
+ */
+function statusArgsForStart(argv) {
+    const requested = (0, keychain_1.resolveProfileFromArgv)(argv);
+    return requested ? ['status', '--json', '--profile', requested] : ['status', '--json'];
+}
+function parseRuntimeStartStatus(value, fallbackProfile) {
+    const root = asRecord(value);
+    if (!root)
+        return null;
+    const auth = asRecord(root.auth);
+    const reauth = asRecord(auth?.reauth);
+    const profile = asRecord(root.profile);
+    const liveDaemon = asRecord(root.liveDaemon);
+    const service = asRecord(root.service);
+    const runtime = asRecord(service?.runtime);
+    return {
+        profile: asString(profile?.name) ?? fallbackProfile,
+        serverUrl: asString(root.serverUrl),
+        cwd: asString(root.cwd),
+        reauth: {
+            needed: reauth?.needed === true,
+            reason: asString(reauth?.reason),
+        },
+        running: liveDaemon?.detected === true || runtime?.status === 'running',
+        runtimeStatus: asString(runtime?.status),
+    };
+}
+/**
+ * `skrr daemon login` is the public wrapper for daemon-scope login. Explicit
+ * server, profile, and cwd make this remedy target the stopped daemon rather
+ * than whichever CLI profile or working directory happens to be current.
+ */
+function daemonLoginRecoveryCommand(status) {
+    const args = ['skrr', 'daemon', 'login', '--profile', quoteShellArg(status.profile)];
+    if (status.serverUrl)
+        args.push('--server', quoteShellArg(status.serverUrl));
+    if (status.cwd)
+        args.push('--cwd', quoteShellArg(status.cwd));
+    return args.join(' ');
+}
+/**
+ * A runtime binary may predate a CLI update. Treat its successful process exit
+ * as an unverified supervisor request until `status --json` proves it either
+ * stayed alive or named the permanent re-auth latch it wrote.
+ */
+function verifyRuntimeStart(statusOutput, statusExitCode, argv) {
+    const fallbackProfile = profileFromArgv(argv);
+    if (statusExitCode !== 0)
+        return { status: 'unreadable_status', profile: fallbackProfile };
+    let parsed;
+    try {
+        parsed = JSON.parse(statusOutput);
+    }
+    catch {
+        return { status: 'unreadable_status', profile: fallbackProfile };
+    }
+    const status = parseRuntimeStartStatus(parsed, fallbackProfile);
+    if (!status)
+        return { status: 'unreadable_status', profile: fallbackProfile };
+    if (status.reauth.needed) {
+        return {
+            status: 'reauth_required',
+            profile: status.profile,
+            reason: status.reauth.reason,
+            recoveryCommand: daemonLoginRecoveryCommand(status),
+        };
+    }
+    if (status.running)
+        return { status: 'running' };
+    return {
+        status: 'not_running',
+        profile: status.profile,
+        runtimeStatus: status.runtimeStatus,
+    };
+}

package/dist/lib/task-execution.d.ts

@@ -46,12 +46,28 @@ export type TaskSnapshot = {
 export type SpaceCapacity = {
     object: 'space_task_capacity';
     space: TaskRecord;
-    maxActiveTasks: number;
+    /**
+     * `null` means UNLIMITED, matching the orchestration payload. Declaring
+     * these `number` was not merely a type lie — it broke the CLI build, and
+     * before that it reached users as `Capacity: 0/null active`, because
+     * `autoExecuteMaxActiveTasks` defaults to `0` (= unlimited) and so the
+     * unlimited case is the COMMON path, not an edge case (OSK-7087).
+     */
+    maxActiveTasks: number | null;
     activeCount: number;
-    availableSlots: number;
+    availableSlots: number | null;
+    /** Live start-budget consumption, or `null` when no round is open. */
+    budget: SpaceCapacityBudget | null;
     activeTasks: TaskRecord[];
     sampledTaskCount: number;
 };
+export type SpaceCapacityBudget = {
+    generation: number;
+    maxStarts: number;
+    consumedStarts: number;
+    remaining: number | null;
+    unlimited: boolean;
+};
 export declare function statusOf(task: TaskRecord | null | undefined): string;
 export declare function isTerminalTask(task: TaskRecord): boolean;
 /**

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.