@skrr-ai/cli 0.1.14 → 0.1.17

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 expectations`)',
+            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/commitments.d.ts

@@ -16,7 +16,7 @@
  * Two `kind`s: `achieve` (bounded, deadline-bearing) and `maintain` (perpetual
  * "hold this state", derived from a Compass invariant — not authored here).
  */
-import { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES } from '@skrr-ai/data-provider';
+import { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, COMMITMENT_AUTONOMY_MODES, COMMITMENT_EXECUTION_ISOLATION_MODES } from '@skrr-ai/data-provider';
 import type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentListResponse, CommitmentPlanResponse, CommitmentStatusResponse, CommitmentWorkLink } from '@skrr-ai/data-provider';
 import { withQuery } from './triggers';
 export { COMMITMENT_WATCHED_SOURCES, COMMITMENT_TEMPLATE_IDS, COMMITMENT_CADENCE_MODES, COMMITMENT_CADENCE_TIME_PATTERN, COMMITMENT_CADENCE_MAX_TIMES, };
@@ -28,8 +28,20 @@ export type { CommitmentCheck, CommitmentChecksResponse, Commitment, CommitmentL
  * `_Exhaustive*` guards fail to resolve if a canonical value is missing.
  */
 export declare const COMMITMENT_STATUSES: readonly ["draft", "active", "paused", "completed", "cancelled", "archived"];
-/** Autonomy ladder — how much the commitment may act without asking. */
-export declare const COMMITMENT_AUTONOMY_MODES: readonly ["off", "suggestions_only", "ask_first", "auto_run_limited", "auto_run"];
+/**
+ * Autonomy ladder — how much the commitment may act without asking.
+ *
+ * Re-exported, not restated: `@skrr-ai/data-provider` owns the vocabulary, and
+ * a second literal here is how the CLI would silently drift from the server
+ * that rejects its values.
+ */
+export { COMMITMENT_AUTONOMY_MODES };
+/**
+ * Where a Commitment's autonomous runs do their work. Re-exported for the same
+ * reason as the ladder above: the vocabulary is the server's, and a picker that
+ * offers a value the API rejects is a silent drift.
+ */
+export { COMMITMENT_EXECUTION_ISOLATION_MODES };
 /**
  * Interval bounds for `cadence.intervalMs`.
  *
@@ -210,6 +222,7 @@ export declare const commitmentApi: {
     get: (id: string) => Promise<CommitmentStatusResponse>;
     create: (body: Record<string, unknown>) => Promise<Commitment>;
     update: (id: string, body: Record<string, unknown>) => Promise<Commitment>;
+    draftPreflight: (body: Record<string, unknown>) => Promise<CommitmentPreflightReport>;
     workLinks: (id: string, includeInactive?: boolean) => Promise<{
         object: "commitment_work_link_list";
         data: CommitmentWorkLink[];
@@ -347,6 +360,18 @@ export declare const COMMITMENT_FEEDBACK_KINDS: readonly ["useful", "noisy", "wr
 export declare const COMMITMENT_REMEDIATION_ACTIONS: readonly ["pause_commitment", "mute_user_nudges", "reduce_nudge_frequency", "tighten_policy", "mark_noop"];
 /** The only keys `createBodySchema` (a `z.strictObject`) accepts. */
 export declare const COMMITMENT_CREATE_KEYS: readonly ["agentId", "kind", "compassId", "compassOrigin", "goalId", "title", "description", "agentDirective", "status", "target", "watchedSources", "policy", "cadence", "subject", "sensors", "grants", "reports", "createdVia"];
+/**
+ * Read the per-Commitment domain policy from an inline flag or a text file.
+ *
+ * This deliberately uses a separate pair of names from Agent-level instruction
+ * commands: the result configures one Commitment run, not the Agent's global
+ * prompt. The explicit error also keeps shell users from accidentally masking
+ * a reviewed file with a short inline experiment.
+ */
+export declare function readCommitmentAgentDirective({ directive, file, }: {
+    directive?: string;
+    file?: string;
+}): Promise<string | undefined>;
 /**
  * Normalize a `--from-json` body into something the create endpoint accepts.
  *

package/dist/lib/commitments.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMITMENT_CLI_EVALUATORS = exports.COMMITMENT_CREATE_KEYS = exports.COMMITMENT_REMEDIATION_ACTIONS = exports.COMMITMENT_FEEDBACK_KINDS = exports.commitmentApi = exports.commitmentPackApi = exports.MAX_COMMITMENT_INTERVAL_MS = exports.MIN_COMMITMENT_INTERVAL_MS = exports.COMMITMENT_AUTONOMY_MODES = exports.COMMITMENT_STATUSES = exports.COMMITMENT_CADENCE_MAX_TIMES = exports.COMMITMENT_CADENCE_TIME_PATTERN = exports.COMMITMENT_CADENCE_MODES = exports.COMMITMENT_TEMPLATE_IDS = exports.COMMITMENT_WATCHED_SOURCES = void 0;
+exports.COMMITMENT_CLI_EVALUATORS = exports.COMMITMENT_CREATE_KEYS = exports.COMMITMENT_REMEDIATION_ACTIONS = exports.COMMITMENT_FEEDBACK_KINDS = exports.commitmentApi = exports.commitmentPackApi = exports.MAX_COMMITMENT_INTERVAL_MS = exports.MIN_COMMITMENT_INTERVAL_MS = exports.COMMITMENT_EXECUTION_ISOLATION_MODES = exports.COMMITMENT_AUTONOMY_MODES = exports.COMMITMENT_STATUSES = exports.COMMITMENT_CADENCE_MAX_TIMES = exports.COMMITMENT_CADENCE_TIME_PATTERN = exports.COMMITMENT_CADENCE_MODES = exports.COMMITMENT_TEMPLATE_IDS = exports.COMMITMENT_WATCHED_SOURCES = void 0;
+exports.readCommitmentAgentDirective = readCommitmentAgentDirective;
 exports.normalizeCreateBody = normalizeCreateBody;
 exports.parseIntervalToMs = parseIntervalToMs;
 exports.buildWatchedSources = buildWatchedSources;
@@ -45,6 +46,9 @@ Object.defineProperty(exports, "COMMITMENT_TEMPLATE_IDS", { enumerable: true, ge
 Object.defineProperty(exports, "COMMITMENT_CADENCE_MODES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_CADENCE_MODES; } });
 Object.defineProperty(exports, "COMMITMENT_CADENCE_TIME_PATTERN", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_CADENCE_TIME_PATTERN; } });
 Object.defineProperty(exports, "COMMITMENT_CADENCE_MAX_TIMES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_CADENCE_MAX_TIMES; } });
+Object.defineProperty(exports, "COMMITMENT_AUTONOMY_MODES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_AUTONOMY_MODES; } });
+Object.defineProperty(exports, "COMMITMENT_EXECUTION_ISOLATION_MODES", { enumerable: true, get: function () { return data_provider_1.COMMITMENT_EXECUTION_ISOLATION_MODES; } });
+const instruction_input_1 = require("./instruction-input");
 const format_1 = require("./format");
 const triggers_1 = require("./triggers");
 /**
@@ -63,16 +67,6 @@ exports.COMMITMENT_STATUSES = [
 ];
 const _statusDriftGuard = true;
 void _statusDriftGuard;
-/** Autonomy ladder — how much the commitment may act without asking. */
-exports.COMMITMENT_AUTONOMY_MODES = [
-    'off',
-    'suggestions_only',
-    'ask_first',
-    'auto_run_limited',
-    'auto_run',
-];
-const _autonomyDriftGuard = true;
-void _autonomyDriftGuard;
 /**
  * Interval bounds for `cadence.intervalMs`.
  *
@@ -116,6 +110,7 @@ exports.commitmentApi = {
     get: (id) => data_provider_1.request.get(base(id)),
     create: (body) => data_provider_1.request.post('/api/commitments', body),
     update: (id, body) => data_provider_1.request.patch(base(id), body),
+    draftPreflight: (body) => data_provider_1.request.post('/api/commitments/preflight', body),
     workLinks: (id, includeInactive = false) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/links`, { ...(includeInactive ? { includeInactive: true } : {}) })),
     createWorkLink: (id, body) => data_provider_1.request.post(`${base(id)}/links`, body),
     updateWorkLink: (id, linkId, body) => data_provider_1.request.patch(`${base(id)}/links/${encodeURIComponent(linkId)}`, body),
@@ -238,6 +233,20 @@ exports.COMMITMENT_CREATE_KEYS = [
     'reports',
     'createdVia',
 ];
+/**
+ * Read the per-Commitment domain policy from an inline flag or a text file.
+ *
+ * This deliberately uses a separate pair of names from Agent-level instruction
+ * commands: the result configures one Commitment run, not the Agent's global
+ * prompt. The explicit error also keeps shell users from accidentally masking
+ * a reviewed file with a short inline experiment.
+ */
+async function readCommitmentAgentDirective({ directive, file, }) {
+    if (directive !== undefined && file !== undefined) {
+        throw new Error('Use either --agent-directive or --agent-directive-file, not both.');
+    }
+    return (0, instruction_input_1.readInstructionBody)({ body: directive, file });
+}
 /**
  * Normalize a `--from-json` body into something the create endpoint accepts.
  *

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

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 {};