@skrr-ai/cli 0.1.13 → 0.1.15

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/sky-code.d.ts

@@ -1,7 +1,7 @@
 /**
  * WL-2.2 — locate and forward to the local `sky-code` engine.
  *
- * The same `gh → git` shape `exec-oversky.ts` uses, for the same reason: the
+ * The same `gh → git` shape `exec-runtime-binary.ts` uses, for the same reason: the
  * Sky CLI is a REST client, the engine is a separately-built, separately-
  * released binary with its own lifetime and failure model. Unifying them at
  * the command surface (`skrr code`) gives users one thing to type without

package/dist/lib/sky-code.js

@@ -2,7 +2,7 @@
 /**
  * WL-2.2 — locate and forward to the local `sky-code` engine.
  *
- * The same `gh → git` shape `exec-oversky.ts` uses, for the same reason: the
+ * The same `gh → git` shape `exec-runtime-binary.ts` uses, for the same reason: the
  * Sky CLI is a REST client, the engine is a separately-built, separately-
  * released binary with its own lifetime and failure model. Unifying them at
  * the command surface (`skrr code`) gives users one thing to type without

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.

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,

package/dist/lib/usage-discovery.js

@@ -108,7 +108,7 @@ function renderUsageReference(reference, bin = 'skrr') {
     ];
     for (const command of reference.data) {
         const flags = command.keyFlags.length > 0 ? ` Flags: ${command.keyFlags.join(', ')}.` : '';
-        lines.push(`sky ${command.command} — ${command.description}.${flags} Example: ${command.example}`);
+        lines.push(`${bin} ${command.command} — ${command.description}.${flags} Example: ${command.example}`);
     }
     if (reference.nextPage)
         lines.push(`Next: ${bin} usage ${reference.domain} --page ${reference.nextPage}`);

package/dist/lib/web-url.d.ts

@@ -69,6 +69,10 @@ export type WebUrlRef = {
 } | {
     kind: 'groupChat';
     groupChatId: string;
+} | {
+    kind: 'wikiPage';
+    spaceId: string;
+    pageId: string;
 };
 /**
  * Site-relative canonical path for an entity, or `null` when the required id is
@@ -146,6 +150,18 @@ export declare function projectUrlFrom(baseURL: string, project: EntityRecord):
 export declare function withProjectUrl<T extends EntityRecord>(baseURL: string, project: T): T & {
     url: string | null;
 };
+/**
+ * Build a wiki-page URL from a raw server page record.
+ *
+ * The server returns `pageId`, never `id`; the fallback reads exist so a
+ * caller that has already normalized the record still gets a link back
+ * instead of null.
+ */
+export declare function wikiPageUrlFrom(baseURL: string, page: EntityRecord): string | null;
+/** Return a shallow copy of a wiki-page record with a `url` field attached. */
+export declare function withWikiPageUrl<T extends EntityRecord>(baseURL: string, page: T): T & {
+    url: string | null;
+};
 /** Return a shallow copy of a commitment record with a `url` field attached. */
 export declare function withCommitmentUrl<T extends EntityRecord>(baseURL: string, commitment: T): T & {
     url: string | null;

package/dist/lib/web-url.js

@@ -35,6 +35,8 @@ exports.withSpaceUrl = withSpaceUrl;
 exports.withGoalUrl = withGoalUrl;
 exports.projectUrlFrom = projectUrlFrom;
 exports.withProjectUrl = withProjectUrl;
+exports.wikiPageUrlFrom = wikiPageUrlFrom;
+exports.withWikiPageUrl = withWikiPageUrl;
 exports.withCommitmentUrl = withCommitmentUrl;
 exports.withNorthstarUrl = withNorthstarUrl;
 exports.withAgentUrl = withAgentUrl;
@@ -103,6 +105,11 @@ function webPath(ref) {
             const projectId = encodeId(ref.projectId);
             return projectId ? `/spaces/${spaceId}/projects/${projectId}` : `/spaces/${spaceId}/projects`;
         }
+        case 'wikiPage': {
+            const spaceId = encodeId(ref.spaceId);
+            const pageId = encodeId(ref.pageId);
+            return spaceId && pageId ? `/spaces/${spaceId}/wiki?page=${pageId}` : null;
+        }
         case 'workflow': {
             const spaceId = encodeId(ref.spaceId);
             if (!spaceId)
@@ -282,6 +289,24 @@ function projectUrlFrom(baseURL, project) {
 function withProjectUrl(baseURL, project) {
     return { ...project, url: projectUrlFrom(baseURL, project) };
 }
+/**
+ * Build a wiki-page URL from a raw server page record.
+ *
+ * The server returns `pageId`, never `id`; the fallback reads exist so a
+ * caller that has already normalized the record still gets a link back
+ * instead of null.
+ */
+function wikiPageUrlFrom(baseURL, page) {
+    const pageId = idOf(page, 'pageId', 'id', '_id');
+    const spaceId = idOf(page, 'spaceId');
+    if (!pageId || !spaceId)
+        return null;
+    return webUrl(baseURL, { kind: 'wikiPage', spaceId, pageId });
+}
+/** Return a shallow copy of a wiki-page record with a `url` field attached. */
+function withWikiPageUrl(baseURL, page) {
+    return { ...page, url: wikiPageUrlFrom(baseURL, page) };
+}
 /** Return a shallow copy of a commitment record with a `url` field attached. */
 function withCommitmentUrl(baseURL, commitment) {
     return { ...commitment, url: commitmentUrlFrom(baseURL, commitment) };