@skrr-ai/cli 0.1.14 → 0.1.15

package/dist/lib/exec-runtime-binary.js

@@ -10,6 +10,7 @@ exports.isCurrentRuntimeBinary = isCurrentRuntimeBinary;
 exports.normalizeRuntimeGlobalArgs = normalizeRuntimeGlobalArgs;
 exports.notInstalledMessage = notInstalledMessage;
 exports.execRuntimeBinary = execRuntimeBinary;
+exports.execRuntimeBinaryCapture = execRuntimeBinaryCapture;
 exports.runtimeBinarySupportsSubcommand = runtimeBinarySupportsSubcommand;
 /**
  * exec-runtime-binary.ts — locate and forward to the local runtime binary.
@@ -242,6 +243,50 @@ function execRuntimeBinary(args) {
         });
     });
 }
+/**
+ * Invoke the installed runtime without inheriting its streams. The regular
+ * lifecycle command still owns the terminal; this is only for the wrapper's
+ * post-condition probes, where output is evidence rather than user-facing
+ * command output.
+ */
+function execRuntimeBinaryCapture(args) {
+    return new Promise((resolve, reject) => {
+        const bin = findRuntimeBinary();
+        if (!bin) {
+            reject(new Error('runtime-binary-not-installed'));
+            return;
+        }
+        const isWinShim = process.platform === 'win32' && /\.(cmd|bat)$/i.test(bin);
+        const child = (0, node_child_process_1.spawn)(bin, normalizeRuntimeGlobalArgs(args), {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            ...(isWinShim ? { shell: true } : {}),
+        });
+        let stdout = '';
+        let stderr = '';
+        // A status response is tiny. Keep a broken runtime from making its wrapper
+        // retain an unbounded stream merely to decide whether `start` worked.
+        const append = (current, chunk) => {
+            const limit = 256 * 1024;
+            if (current.length >= limit)
+                return current;
+            return (current + chunk.toString()).slice(0, limit);
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdout = append(stdout, chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr = append(stderr, chunk);
+        });
+        child.on('error', reject);
+        child.on('exit', (code, signal) => {
+            resolve({
+                code: signal ? 128 + signalNumber(signal) : (code ?? 0),
+                stdout,
+                stderr,
+            });
+        });
+    });
+}
 /**
  * Check an installed daemon's top-level help before forwarding a command that
  * was added after older daemon releases shipped. A false result is useful to

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

@@ -2,6 +2,42 @@ export type GitTaskBranch = {
     branch: string;
     taskRef: string;
 };
+export type TaskDeliveryReceipt = {
+    kind: 'commit';
+    state: 'branch_ready' | 'integrated';
+    commitShas: string[];
+    headSha: string;
+    branch?: string;
+    integrationBranch?: string;
+    mergeCommit?: string;
+} | {
+    kind: 'pull_request';
+    state: 'pr_open' | 'integrated';
+    prUrl: string;
+    branch?: string;
+    headSha?: string;
+    integrationBranch?: string;
+    mergeCommit?: string;
+};
+type CommandResult = {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+type CommandRunner = (command: string, args: string[], cwd: string) => CommandResult;
+export declare function commitArtifacts(deliverables: string): string[];
+/**
+ * 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`.
+ */
+export declare function inspectTaskDeliveryArtifacts(opts: {
+    deliverables: string;
+    taskRef: string;
+    cwd?: string;
+    runner?: CommandRunner;
+}): TaskDeliveryReceipt | null;
 export declare class GitTaskError extends Error {
     readonly code: 'GIT_REPOSITORY_REQUIRED' | 'TASK_BRANCH_CONTEXT_MISSING' | 'GIT_BRANCH_SWITCH_FAILED';
     constructor(message: string, code: 'GIT_REPOSITORY_REQUIRED' | 'TASK_BRANCH_CONTEXT_MISSING' | 'GIT_BRANCH_SWITCH_FAILED');
@@ -23,3 +59,4 @@ export declare function checkoutTaskBranch(taskRef: string, cwd?: string): {
     branch: string;
     created: boolean;
 };
+export {};

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;
 /**