@skrr-ai/cli 0.1.14 → 0.1.15

package/dist/commands/tasks/expectations.js

@@ -0,0 +1,92 @@
+"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");
+/**
+ * `skrr tasks expectations <task>` — what this task owes, and how far each got.
+ *
+ * Reads the SERVER's verdict rather than recomputing one. The judge and the
+ * completion gate are the same module, so a CLI that decided "met" for itself
+ * could disagree with the gate that refuses the task — and the reader would
+ * have no way to tell which was lying.
+ */
+const STATE_LABEL = {
+    met: 'done',
+    waived: 'dropped',
+    blocked: 'stuck',
+    underway: 'on its way',
+    owed: 'not yet',
+    unjudged: 'needs a person',
+};
+function line(expectation) {
+    const label = STATE_LABEL[expectation.state] || expectation.state;
+    // A judged expectation is stated as NOT a gate. A list that reads like a
+    // contract while enforcing nothing is worse than no list, because it is
+    // trusted.
+    const gate = expectation.gating ? '' : '  (does not block completion)';
+    const from = expectation.source === 'space' ? '  [space default]' : '';
+    return `  ${expectation.id.padEnd(18)} ${label.padEnd(14)} ${expectation.sentence}${gate}${from}`;
+}
+class TasksExpectations extends base_command_1.BaseCommand {
+    static description = 'Show what a task must produce and how far each expectation got ("Done when")';
+    static examples = [
+        '<%= config.bin %> tasks expectations <task-id>',
+        '<%= config.bin %> tasks expectations <task-id> --json',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksExpectations);
+        let acceptance;
+        try {
+            acceptance = await data_provider_1.dataService.getTaskAcceptance(args.task);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(acceptance, null, 2));
+            return;
+        }
+        if (acceptance.expectations.length === 0) {
+            // An empty contract is a real answer, not an unfilled field. Say so
+            // plainly rather than prompting for something most tasks do not owe.
+            this.log('Nothing durable is expected of this task.');
+            return;
+        }
+        // The evidence read fails OPEN by design, so "produced nothing" and "we
+        // could not look" are indistinguishable downstream unless the server says
+        // which happened. Never print the first when it might be the second.
+        if (!acceptance.evidenceRead) {
+            this.warn('Could not read what this task produced — the states below may understate it. ' +
+                'This is not a claim that nothing was produced.');
+        }
+        this.log('Done when:');
+        for (const expectation of acceptance.expectations) {
+            this.log(line(expectation));
+        }
+        const gating = acceptance.expectations.filter((e) => e.gating);
+        const met = gating.filter((e) => e.met).length;
+        this.log('');
+        this.log(`${met} of ${gating.length} met  ·  overall: ${acceptance.state}`);
+        // Only the ones actually stored on the task can be judged. A space default
+        // is synthesised per read, so pointing at `tasks judge` for one would send
+        // the reader at a command that can only refuse it.
+        const settleable = acceptance.expectations.filter((e) => e.state === 'unjudged' && e.source !== 'space').length;
+        if (settleable > 0) {
+            this.log(`${settleable} awaiting a person — settle with \`${this.config.bin} tasks judge\`.`);
+        }
+        const inherited = acceptance.unjudged - settleable;
+        if (inherited > 0) {
+            this.log(`${inherited} inherited from the space default — declare them on the task to settle them.`);
+        }
+    }
+}
+exports.default = TasksExpectations;

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

@@ -0,0 +1,29 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks judge <task> <expectation-id> --verdict met --reason "<why>"`
+ *
+ * Settle a `judged` expectation — one whose text nothing here can evaluate.
+ *
+ * Only a judged one. A checkable expectation is settled by recording what was
+ * produced, and letting a person mark it met by hand would make the deliverables
+ * ledger optional, which is the same as not having one. The server refuses that
+ * case with an error naming the command to use instead.
+ *
+ * The reason is REQUIRED, for the same purpose a waiver's is: a verdict with no
+ * reason is indistinguishable from a click, and the entire value of a judged
+ * expectation is that somebody actually looked.
+ */
+export default class TasksJudge extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        expectation: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        verdict: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        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>;
+}

package/dist/commands/tasks/judge.js

@@ -0,0 +1,68 @@
+"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");
+/**
+ * `skrr tasks judge <task> <expectation-id> --verdict met --reason "<why>"`
+ *
+ * Settle a `judged` expectation — one whose text nothing here can evaluate.
+ *
+ * Only a judged one. A checkable expectation is settled by recording what was
+ * produced, and letting a person mark it met by hand would make the deliverables
+ * ledger optional, which is the same as not having one. The server refuses that
+ * case with an error naming the command to use instead.
+ *
+ * The reason is REQUIRED, for the same purpose a waiver's is: a verdict with no
+ * reason is indistinguishable from a click, and the entire value of a judged
+ * expectation is that somebody actually looked.
+ */
+class TasksJudge extends base_command_1.BaseCommand {
+    static description = 'Settle a judged expectation with a verdict and a stated reason';
+    static examples = [
+        '<%= config.bin %> tasks judge <task-id> e2 --verdict met --reason "Read it end to end; a non-engineer follows it."',
+        '<%= config.bin %> tasks judge <task-id> e2 --verdict unmet --reason "Still assumes the reader knows the schema."',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+        expectation: core_1.Args.string({
+            description: 'Expectation id (see `tasks expectations`)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        verdict: core_1.Flags.string({
+            options: ['met', 'unmet'],
+            required: true,
+            description: 'Whether the expectation was met.',
+        }),
+        reason: core_1.Flags.string({
+            required: true,
+            description: 'What you looked at. A verdict without one is not a judgement.',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksJudge);
+        let result;
+        try {
+            result = await data_provider_1.dataService.judgeTaskExpectation(args.task, {
+                expectationId: args.expectation,
+                verdict: flags.verdict,
+                reason: flags.reason,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Recorded ${args.expectation} as ${flags.verdict}: ${flags.reason}`);
+    }
+}
+exports.default = TasksJudge;

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

@@ -18,7 +18,7 @@ export default class TasksReport extends BaseCommand {
         finding: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         evidence: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         next: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        artifact: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        deliverable: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/tasks/report.js

@@ -18,7 +18,7 @@ class TasksReport extends base_command_1.BaseCommand {
     static description = 'Record a self-contained outcome, findings, evidence, and next actions';
     static examples = [
         '<%= config.bin %> tasks report <task-id> --outcome "Adopt the event ledger" --finding "The task page omits work-event details" --evidence "Task detail reads only legacy activity" --next "Add an Outcome section"',
-        '<%= config.bin %> tasks report <task-id> --kind handoff --outcome "Ready for review" --finding "All acceptance criteria are met" --artifact "src/task.ts" --json',
+        '<%= config.bin %> tasks report <task-id> --kind handoff --outcome "Ready for review" --finding "All acceptance criteria are met" --deliverable "src/task.ts" --json',
     ];
     static args = {
         id: core_1.Args.string({
@@ -48,7 +48,7 @@ class TasksReport extends base_command_1.BaseCommand {
             multiple: true,
         }),
         next: core_1.Flags.string({ description: 'A follow-up or next action (repeatable)', multiple: true }),
-        artifact: core_1.Flags.string({
+        deliverable: core_1.Flags.string({
             description: 'Durable file, commit, PR, or URL (repeatable)',
             multiple: true,
         }),
@@ -92,7 +92,7 @@ class TasksReport extends base_command_1.BaseCommand {
             idempotencyKey: (0, outbox_1.idempotencyKeyFor)('task-report', task.id, JSON.stringify({ report, kind: flags.kind })),
             kind,
             ...(0, task_report_1.taskReportEventFields)(report),
-            artifacts: flags.artifact?.map((ref) => ({ label: 'artifact', ref })),
+            artifacts: flags.deliverable?.map((ref) => ({ label: 'deliverable', ref })),
         };
         const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('event');
         let result;

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

@@ -10,6 +10,7 @@ export default class TasksUpdate extends BaseCommand {
         task: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         title: 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>;
         description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'description-format': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         priority: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/update.js

@@ -5,8 +5,9 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
-const task_resolver_1 = require("../../lib/task-resolver");
 const tasks_1 = require("../../lib/tasks");
+const task_resolver_1 = require("../../lib/task-resolver");
+const tasks_2 = require("../../lib/tasks");
 const create_1 = require("./create");
 class TasksUpdate extends base_command_1.BaseCommand {
     static description = 'Update an existing task (partial patch). Status and PROJECT changes go through ' +
@@ -41,6 +42,11 @@ class TasksUpdate extends base_command_1.BaseCommand {
             description: 'Path to a JSON file (or "-" for stdin) to use as the patch body; may include taskId',
         }),
         title: core_1.Flags.string({ description: 'New title' }),
+        expect: core_1.Flags.string({
+            multiple: true,
+            description: tasks_1.EXPECT_FLAG_HELP +
+                ' Replaces the whole list; pass "clear" to drop it and inherit the space default.',
+        }),
         description: core_1.Flags.string({ description: 'New description' }),
         'description-format': core_1.Flags.string({
             description: 'Input format for --description or from-json description',
@@ -48,7 +54,7 @@ class TasksUpdate extends base_command_1.BaseCommand {
         }),
         priority: core_1.Flags.string({
             description: 'New priority',
-            options: [...tasks_1.TASK_PRIORITIES],
+            options: [...tasks_2.TASK_PRIORITIES],
         }),
         'start-date': core_1.Flags.string({ description: 'New planned start date (ISO string)' }),
         'due-date': core_1.Flags.string({ description: 'New due date (ISO string)' }),
@@ -198,8 +204,32 @@ class TasksUpdate extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        // `--expect clear` is an explicit empty list, which the API turns into $unset —
+        // distinct from omitting the flag, which leaves the declaration untouched.
+        // Without the sentinel there is no way to say "stop requiring an output"
+        // short of hand-writing --from-json.
+        // `--expect clear` empties the list; otherwise the flags REPLACE it, because
+        // a partial patch of a list has no honest meaning — "add one" and "this is
+        // now the whole contract" are different requests and the flag can only be
+        // one of them.
+        let expectationsPatch;
+        if (flags.expect !== undefined && flags.expect.length > 0) {
+            if (flags.expect.length === 1 && flags.expect[0].trim() === 'clear') {
+                expectationsPatch = null;
+            }
+            else {
+                const parsed = (0, tasks_1.parseExpectations)(flags.expect);
+                if (!parsed.ok) {
+                    this.error(parsed.error, { exit: 1 });
+                }
+                else {
+                    expectationsPatch = parsed.value;
+                }
+            }
+        }
         const payload = (0, prompt_1.mergeDefined)((0, task_resolver_1.stripTaskIdentityFields)(body), {
             title: flags.title,
+            expectations: expectationsPatch === null ? [] : (expectationsPatch ?? undefined),
             description: flags.description,
             descriptionFormat: flags['description-format'],
             priority: flags.priority,
@@ -231,7 +261,7 @@ class TasksUpdate extends base_command_1.BaseCommand {
             labelIds: flags['label-id'],
             // Worktree isolation override. --worktree ⇒ 'ephemeral', --no-worktree ⇒
             // 'shared', omitted ⇒ unchanged. (Clear-to-inherit via --from-json.)
-            executionIsolation: (0, tasks_1.executionIsolationFromWorktreeFlag)(flags.worktree),
+            executionIsolation: (0, tasks_2.executionIsolationFromWorktreeFlag)(flags.worktree),
             // A mutation option, not a field — `undefined` unless explicitly asked
             // for, so it never counts toward the "nothing to update" check below.
             repairReleasePins: flags['repair-release-pins'] ? true : undefined,
@@ -253,7 +283,7 @@ class TasksUpdate extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
-        const mutationGuardFailure = (0, tasks_1.taskUpdateMutationGuard)(payload);
+        const mutationGuardFailure = (0, tasks_2.taskUpdateMutationGuard)(payload);
         if (mutationGuardFailure) {
             this.failWithCliError({
                 message: mutationGuardFailure.message,

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

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks waive <task> <expectation-id> --reason "<why>"`
+ *
+ * Drop a requirement, on the record. The expectation is KEPT and marked, never
+ * deleted: deleting it expresses the same decision while destroying the only
+ * evidence that it was ever owed, which is what someone asking "why wasn't this
+ * done?" needs to read.
+ *
+ * The reason is required for the same purpose — a waiver without one is
+ * indistinguishable from having forgotten.
+ */
+export default class TasksWaive extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        task: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        expectation: 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>;
+}

package/dist/commands/tasks/waive.js

@@ -0,0 +1,58 @@
+"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");
+/**
+ * `skrr tasks waive <task> <expectation-id> --reason "<why>"`
+ *
+ * Drop a requirement, on the record. The expectation is KEPT and marked, never
+ * deleted: deleting it expresses the same decision while destroying the only
+ * evidence that it was ever owed, which is what someone asking "why wasn't this
+ * done?" needs to read.
+ *
+ * The reason is required for the same purpose — a waiver without one is
+ * indistinguishable from having forgotten.
+ */
+class TasksWaive extends base_command_1.BaseCommand {
+    static description = 'Waive an expectation, with a stated reason';
+    static examples = [
+        '<%= config.bin %> tasks waive <task-id> c1 --reason "superseded by OSK-7000"',
+    ];
+    static args = {
+        task: core_1.Args.string({ description: 'Task id or ref', required: true, ignoreStdin: true }),
+        expectation: core_1.Args.string({
+            description: 'Expectation id (see `tasks show`)',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        reason: core_1.Flags.string({
+            description: 'Why this is no longer required. Required — it is the record.',
+            required: true,
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksWaive);
+        let result;
+        try {
+            result = await data_provider_1.dataService.waiveTaskExpectation(args.task, {
+                expectationId: args.expectation,
+                reason: flags.reason,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Waived ${args.expectation}: ${flags.reason}`);
+    }
+}
+exports.default = TasksWaive;

package/dist/lib/agent-config.js

@@ -48,5 +48,10 @@ function mergeAgentConfigFlags(body, flags) {
     }
     if (flags['recursion-limit'] !== undefined)
         parsed.recursion_limit = flags['recursion-limit'];
+    // Cross-Space Task execution ceiling. `0` means unlimited, matching the
+    // Space limits' convention so a user learns one spelling of "no cap".
+    if (flags['max-concurrent-task-executions'] !== undefined) {
+        parsed.maxConcurrentTaskExecutions = flags['max-concurrent-task-executions'];
+    }
     return (0, prompt_1.mergeDefined)(body, parsed);
 }

package/dist/lib/agent-instructions.d.ts

@@ -0,0 +1,15 @@
+import { dataService, type AgentPromptComposition } from '@skrr-ai/data-provider';
+/** Positional and --agent forms agree with the existing `agents tone` UX. */
+export declare function resolveInstructionAgentId(argument?: string, flag?: string): Promise<string>;
+/** Fetch the edit-gated Agent projection used by the web composer. */
+export declare function loadAgentInstructions(agentId: string): Promise<{
+    agent: Awaited<ReturnType<typeof dataService.getExpandedAgentById>>;
+    composition: AgentPromptComposition;
+}>;
+/**
+ * The Agent controller is intentionally the only persistence boundary.  It
+ * resolves library versions, verifies bindings and materializes legacy
+ * `instructions` atomically, so a CLI never tries to compile a prompt itself.
+ */
+export declare function saveAgentInstructions(agentId: string, composition: AgentPromptComposition): Promise<import("@skrr-ai/data-provider").Agent>;
+export declare function renderCompositionLines(composition: AgentPromptComposition): string[];

package/dist/lib/agent-instructions.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInstructionAgentId = resolveInstructionAgentId;
+exports.loadAgentInstructions = loadAgentInstructions;
+exports.saveAgentInstructions = saveAgentInstructions;
+exports.renderCompositionLines = renderCompositionLines;
+const data_provider_1 = require("@skrr-ai/data-provider");
+const agent_resolver_1 = require("./agent-resolver");
+const instruction_blocks_1 = require("./instruction-blocks");
+/** Positional and --agent forms agree with the existing `agents tone` UX. */
+async function resolveInstructionAgentId(argument, flag) {
+    return (0, agent_resolver_1.resolveAgentId)((0, agent_resolver_1.mergeExplicitAgentInputs)([
+        { label: 'argument', value: argument },
+        { label: '--agent', value: flag },
+    ]));
+}
+/** Fetch the edit-gated Agent projection used by the web composer. */
+async function loadAgentInstructions(agentId) {
+    const agent = await data_provider_1.dataService.getExpandedAgentById({ agent_id: agentId });
+    return { agent, composition: (0, instruction_blocks_1.compositionForAgent)(agent) };
+}
+/**
+ * The Agent controller is intentionally the only persistence boundary.  It
+ * resolves library versions, verifies bindings and materializes legacy
+ * `instructions` atomically, so a CLI never tries to compile a prompt itself.
+ */
+async function saveAgentInstructions(agentId, composition) {
+    return data_provider_1.dataService.updateAgent({
+        agent_id: agentId,
+        data: { promptComposition: composition },
+    });
+}
+function renderCompositionLines(composition) {
+    if (!composition.entries.length)
+        return ['(No custom instruction blocks.)'];
+    return composition.entries.flatMap((entry, index) => {
+        const state = entry.enabled ? 'on' : 'off';
+        if (entry.source.kind === 'inline') {
+            const preview = entry.source.body.trim().replace(/\s+/g, ' ').slice(0, 140);
+            return [
+                `${index + 1}. ${state.padEnd(3)} inline  ${entry.source.title}  (${entry.instanceId})`,
+                `     ${preview || '(empty)'}`,
+            ];
+        }
+        const label = entry.resolved?.name || entry.source.blockId;
+        const bindings = entry.bindings && Object.keys(entry.bindings).length
+            ? ` · bindings: ${Object.entries(entry.bindings)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(', ')}`
+            : '';
+        return [
+            `${index + 1}. ${state.padEnd(3)} library ${label} · v${entry.source.version}  (${entry.instanceId})${bindings}`,
+        ];
+    });
+}

package/dist/lib/command-hygiene.d.ts

@@ -30,5 +30,10 @@ export type CommandHygieneReport = {
 };
 export declare function auditCommands({ rootDir, manifest, }: {
     rootDir: string;
-    manifest: CommandManifest;
+    /**
+     * The generated oclif catalogue is not present in a source checkout.  Such
+     * callers can still run source-level checks, but cannot make claims about
+     * what a generated manifest contains.
+     */
+    manifest?: CommandManifest;
 }): CommandHygieneReport;

package/dist/lib/command-hygiene.js

@@ -46,13 +46,14 @@ const AGENT_CRITICAL_COMMANDS = [
 ];
 function auditCommands({ rootDir, manifest, }) {
     const issues = [];
-    const commands = manifest.commands ?? {};
+    const commands = manifest?.commands ?? {};
     const commandIds = Object.keys(commands);
+    const manifestForCatalog = manifest ?? {};
     // The command manifest is the only catalogue. The progressive `skrr usage`
     // surfaces are useful precisely because they do not make an agent load that
     // whole catalogue at once, so audit every generated continuation page too.
-    const overview = (0, usage_discovery_1.buildUsageOverview)(manifest);
-    const usageBudgetIssues = (0, usage_discovery_1.auditUsageBudgets)(manifest);
+    const overview = (0, usage_discovery_1.buildUsageOverview)(manifestForCatalog);
+    const usageBudgetIssues = (0, usage_discovery_1.auditUsageBudgets)(manifestForCatalog);
     for (const issue of usageBudgetIssues) {
         issues.push({
             code: 'USAGE_DISCOVERY_TOKEN_BUDGET_EXCEEDED',
@@ -62,14 +63,31 @@ function auditCommands({ rootDir, manifest, }) {
                 `uses ${issue.estimatedTokens} estimated tokens; budget is ${issue.tokenBudget}.`,
         });
     }
-    for (const id of AGENT_CRITICAL_COMMANDS) {
-        if (!commands[id]) {
-            issues.push({
-                code: 'AGENT_CRITICAL_COMMAND_MISSING',
-                severity: 'error',
-                command: id,
-                message: `Agent-critical command is missing from the manifest: ${id}`,
-            });
+    if (!manifest) {
+        // Absence is a distinct answer from "missing", and it should be audible.
+        //
+        // Skipping silently means a source-only run reports a clean bill of health
+        // for a check it never performed. That is the shape that makes an audit
+        // untrustworthy — worse than a noisy one, because a green result stops
+        // meaning anything. A warning keeps the run green while saying which claim
+        // it is NOT making, and names the command that would let it.
+        issues.push({
+            code: 'AGENT_CRITICAL_COMMANDS_UNCHECKED',
+            severity: 'warning',
+            message: 'No command manifest was available, so the agent-critical command check did not run. ' +
+                'Build the CLI (`npx tsc -p tsconfig.build.json && npx oclif manifest` in cli/) to audit it.',
+        });
+    }
+    if (manifest) {
+        for (const id of AGENT_CRITICAL_COMMANDS) {
+            if (!commands[id]) {
+                issues.push({
+                    code: 'AGENT_CRITICAL_COMMAND_MISSING',
+                    severity: 'error',
+                    command: id,
+                    message: `Agent-critical command is missing from the manifest: ${id}`,
+                });
+            }
         }
     }
     let sourceAvailable = false;
@@ -129,23 +147,25 @@ function auditCommands({ rootDir, manifest, }) {
             message: 'Source command files are unavailable; source-level hygiene checks were skipped.',
         });
     }
-    for (const id of commandIds) {
-        const command = commands[id];
-        if (!command?.description?.trim()) {
-            issues.push({
-                code: 'COMMAND_DESCRIPTION_MISSING',
-                severity: 'warning',
-                command: id,
-                message: 'Command is missing a description in the manifest.',
-            });
-        }
-        if (!hasJsonFlag(command?.flags) && isMachineRelevantCommand(id)) {
-            issues.push({
-                code: 'JSON_SUCCESS_OUTPUT_MISSING',
-                severity: 'warning',
-                command: id,
-                message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
-            });
+    if (manifest) {
+        for (const id of commandIds) {
+            const command = commands[id];
+            if (!command?.description?.trim()) {
+                issues.push({
+                    code: 'COMMAND_DESCRIPTION_MISSING',
+                    severity: 'warning',
+                    command: id,
+                    message: 'Command is missing a description in the manifest.',
+                });
+            }
+            if (!hasJsonFlag(command?.flags) && isMachineRelevantCommand(id)) {
+                issues.push({
+                    code: 'JSON_SUCCESS_OUTPUT_MISSING',
+                    severity: 'warning',
+                    command: id,
+                    message: 'Machine-relevant command has no --json success-output flag. Keep human-only commands intentional.',
+                });
+            }
         }
     }
     const errors = issues.filter((issue) => issue.severity === 'error').length;
@@ -167,7 +187,7 @@ function auditCommands({ rootDir, manifest, }) {
         usage: {
             overviewTokenBudget: overview.tokenBudget,
             overviewEstimatedTokens: overview.estimatedTokens,
-            domains: (0, usage_discovery_1.usageDomains)(manifest).length,
+            domains: (0, usage_discovery_1.usageDomains)(manifestForCatalog).length,
             budgetErrors: usageBudgetIssues.length,
         },
         issues,

package/dist/lib/exec-runtime-binary.d.ts

@@ -72,6 +72,19 @@ export declare function notInstalledMessage(): string;
  * may depend on.
  */
 export declare function execRuntimeBinary(args: string[]): Promise<number>;
+/** Output from a short-lived runtime probe such as `skrrd status --json`. */
+export type RuntimeBinaryOutput = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+/**
+ * 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.
+ */
+export declare function execRuntimeBinaryCapture(args: string[]): Promise<RuntimeBinaryOutput>;
 /**
  * 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