@phyzess/pappra 0.1.0-beta.13 → 0.1.0-beta.18

package/dist/app/shell-readiness.js

@@ -0,0 +1,368 @@
+export const SHELL_READINESS_BUDGET_MS = 10_000;
+export const SHELL_READINESS_INTERVAL_MS = 100;
+export const SHELL_READINESS_MAX_SAMPLES = 100;
+const MAX_CAPTURED_PROCESSES = 8;
+const SHELL_NAMES = new Set([
+    'sh',
+    'bash',
+    'dash',
+    'zsh',
+    'fish',
+    'ksh',
+    'mksh',
+    'csh',
+    'tcsh',
+    'elvish',
+    'xonsh',
+    'nu',
+    'pwsh',
+    'powershell',
+    'cmd',
+]);
+const AGENT_NAMES = new Set([
+    'pi',
+    'codex',
+    'claude',
+    'gemini',
+    'cursor',
+    'devin',
+    'agy',
+    'cline',
+    'omp',
+    'opencode',
+    'copilot',
+    'kimi',
+    'kiro',
+    'droid',
+    'amp',
+    'grok',
+    'hermes',
+    'kilo',
+    'qodercli',
+    'qwen',
+    'letta',
+    'maki',
+    'muse',
+]);
+function normalizedName(value) {
+    const tail = value.split(/[\\/]/).at(-1) ?? value;
+    return tail
+        .replace(/^-+/, '')
+        .replace(/\.exe$/i, '')
+        .toLowerCase();
+}
+function validNumber(value) {
+    return value !== null && Number.isSafeInteger(value) && value > 0;
+}
+function identityCode(pane, expected) {
+    if (pane.paneId !== expected.paneId)
+        return 'pane_id_mismatch';
+    if (pane.workspaceId !== expected.workspaceId)
+        return 'workspace_id_mismatch';
+    if (pane.terminalId !== expected.terminalId)
+        return 'terminal_id_mismatch';
+    if (pane.cwd === null)
+        return 'pane_cwd_missing';
+    return pane.cwd === expected.cwd ? null : 'pane_cwd_mismatch';
+}
+function sampleProcessFacts(processInfo) {
+    if (!Array.isArray(processInfo.foregroundProcesses))
+        return {
+            processes: [],
+            truncated: 0,
+            error: 'foreground_processes_malformed',
+        };
+    const processes = [];
+    for (const process of processInfo.foregroundProcesses) {
+        if (!validNumber(process.pid) ||
+            typeof process.name !== 'string' ||
+            process.name.length === 0)
+            return {
+                processes: [],
+                truncated: 0,
+                error: 'foreground_process_fact_malformed',
+            };
+        processes.push({ pid: process.pid, name: normalizedName(process.name) });
+    }
+    return {
+        processes: processes.slice(0, MAX_CAPTURED_PROCESSES),
+        truncated: Math.max(0, processes.length - MAX_CAPTURED_PROCESSES),
+        error: null,
+    };
+}
+function classifyProcessInfo(processInfo) {
+    const shellPid = processInfo.shellPid;
+    const group = processInfo.foregroundProcessGroupId;
+    const facts = sampleProcessFacts(processInfo);
+    const stateBase = {
+        shellPid: validNumber(shellPid) ? shellPid : null,
+        group: validNumber(group) ? group : null,
+        shellName: null,
+        processes: facts.processes,
+        processesTruncated: facts.truncated,
+    };
+    if (shellPid !== null && !validNumber(shellPid))
+        return { ...stateBase, state: 'failed', code: 'shell_pid_malformed' };
+    if (group !== null && !validNumber(group))
+        return {
+            ...stateBase,
+            state: 'failed',
+            code: 'foreground_group_malformed',
+        };
+    if (facts.error !== null)
+        return { ...stateBase, state: 'failed', code: facts.error };
+    if (shellPid === null)
+        return { ...stateBase, state: 'unknown', code: 'shell_pid_missing' };
+    if (group === null)
+        return { ...stateBase, state: 'unknown', code: 'foreground_group_missing' };
+    if (group !== shellPid)
+        return {
+            ...stateBase,
+            state: 'not_ready',
+            code: 'foreground_group_not_shell',
+        };
+    if (processInfo.foregroundProcesses.length === 0)
+        return {
+            ...stateBase,
+            state: 'unknown',
+            code: 'foreground_processes_empty',
+        };
+    if (processInfo.foregroundProcesses.some((process) => process.pid !== shellPid)) {
+        const agent = facts.processes.find((process) => AGENT_NAMES.has(process.name));
+        return agent === undefined
+            ? { ...stateBase, state: 'not_ready', code: 'extra_foreground_process' }
+            : { ...stateBase, state: 'failed', code: `existing_agent:${agent.name}` };
+    }
+    const shellName = facts.processes[0]?.name ?? null;
+    if (shellName === null || !SHELL_NAMES.has(shellName))
+        return {
+            ...stateBase,
+            state: 'not_ready',
+            code: 'unrecognized_shell',
+            shellName,
+        };
+    return {
+        ...stateBase,
+        state: 'ready',
+        code: null,
+        shellName,
+    };
+}
+/**
+ * Verifies the installed Herdr available-shell predicate for one already owned pane.
+ * Process readiness is bounded local polling in the caller's single apply operation;
+ * it is not an event signal, a model wakeup, or an agent-completion wait.
+ */
+export async function verifyAvailableShell(ops, identity, options = {}) {
+    const clock = options.clock ?? Date.now;
+    const sleeper = options.sleeper ??
+        ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+    const shouldAbort = options.shouldAbort ?? (() => false);
+    const budgetMs = options.budgetMs ?? SHELL_READINESS_BUDGET_MS;
+    const intervalMs = options.intervalMs ?? SHELL_READINESS_INTERVAL_MS;
+    const maxSamples = options.maxSamples ?? SHELL_READINESS_MAX_SAMPLES;
+    if (!Number.isSafeInteger(budgetMs) ||
+        budgetMs < 1 ||
+        budgetMs > SHELL_READINESS_BUDGET_MS)
+        return immediateFailure(identity, 'budget_invalid');
+    if (!Number.isSafeInteger(intervalMs) ||
+        intervalMs < 1 ||
+        intervalMs > SHELL_READINESS_INTERVAL_MS)
+        return immediateFailure(identity, 'interval_invalid');
+    if (!Number.isSafeInteger(maxSamples) ||
+        maxSamples < 1 ||
+        maxSamples > SHELL_READINESS_MAX_SAMPLES)
+        return immediateFailure(identity, 'sample_limit_invalid');
+    const started = clock();
+    const deadline = started + budgetMs;
+    let attempts = 0;
+    let pinnedShellPid = null;
+    let latest = null;
+    const samples = [];
+    const result = (state, code, pane) => ({
+        status: state,
+        code,
+        evidence: {
+            state,
+            code,
+            attempts,
+            elapsed_ms: Math.max(0, clock() - started),
+            pane_id: pane.paneId,
+            workspace_id: pane.workspaceId,
+            terminal_id: pane.terminalId,
+            cwd: pane.cwd,
+            shell_pid: pinnedShellPid ?? latest?.shell_pid ?? null,
+            foreground_process_group_id: latest?.foreground_process_group_id ?? null,
+            shell_name: latest?.shell_name ?? null,
+            last_state: latest?.state ?? 'not_observed',
+            last_code: latest?.code ?? null,
+            limits: {
+                budget_ms: budgetMs,
+                interval_ms: intervalMs,
+                max_samples: maxSamples,
+                samples_truncated: Math.max(0, attempts - samples.length),
+            },
+            samples: [...samples],
+        },
+    });
+    const recordSample = (sample) => {
+        latest = sample;
+        if (samples.length < maxSamples)
+            samples.push(sample);
+    };
+    const terminal = (state, code) => result(state, code, identity);
+    const checkAbort = () => shouldAbort() ? terminal('aborted', 'abort_requested') : null;
+    const checkDeadline = (code) => clock() >= deadline ? terminal('timeout', code) : null;
+    const initialAbort = checkAbort();
+    if (initialAbort !== null)
+        return initialAbort;
+    const beforeDeadline = checkDeadline('deadline_before_identity');
+    if (beforeDeadline !== null)
+        return beforeDeadline;
+    const initial = await ops.paneGet(identity.paneId, Math.max(1, deadline - clock()));
+    const afterInitialAbort = checkAbort();
+    if (afterInitialAbort !== null)
+        return afterInitialAbort;
+    const afterInitialDeadline = checkDeadline('deadline_after_initial_identity');
+    if (afterInitialDeadline !== null)
+        return afterInitialDeadline;
+    if (!initial.ok)
+        return terminal(initial.status === 'unknown' ? 'unknown' : 'failed', `initial_identity:${initial.code}`);
+    const initialIdentity = identityCode(initial.value, identity);
+    if (initialIdentity !== null)
+        return terminal('failed', initialIdentity);
+    if (initial.value.agent !== null)
+        return terminal('failed', 'existing_agent');
+    for (;;) {
+        const beforeAbort = checkAbort();
+        if (beforeAbort !== null)
+            return beforeAbort;
+        const beforeSampleDeadline = checkDeadline('deadline_before_process_info');
+        if (beforeSampleDeadline !== null)
+            return beforeSampleDeadline;
+        if (attempts >= maxSamples)
+            return terminal('timeout', 'sample_limit_reached');
+        attempts += 1;
+        const sampleStart = clock();
+        const snapshot = await ops.paneProcessInfo(identity.paneId, Math.max(1, deadline - clock()));
+        const afterSampleAbort = checkAbort();
+        if (afterSampleAbort !== null)
+            return afterSampleAbort;
+        const afterSampleDeadline = checkDeadline('deadline_after_process_info');
+        if (afterSampleDeadline !== null)
+            return afterSampleDeadline;
+        if (!snapshot.ok) {
+            const status = snapshot.status === 'unknown' ? 'unknown' : 'failed';
+            recordSample({
+                elapsed_ms: Math.max(0, sampleStart - started),
+                state: status === 'unknown' ? 'unknown' : 'failed',
+                code: snapshot.code,
+                shell_pid: pinnedShellPid,
+                foreground_process_group_id: null,
+                shell_name: null,
+                foreground_processes: [],
+                processes_truncated: 0,
+            });
+            return terminal(status, `process_info:${snapshot.code}`);
+        }
+        const processInfo = snapshot.value;
+        if (processInfo.paneId !== identity.paneId)
+            return terminal('failed', 'pane_id_mismatch');
+        const classified = classifyProcessInfo(processInfo);
+        if (classified.shellPid !== null) {
+            if (pinnedShellPid === null)
+                pinnedShellPid = classified.shellPid;
+            else if (pinnedShellPid !== classified.shellPid) {
+                recordSample({
+                    elapsed_ms: Math.max(0, sampleStart - started),
+                    state: 'failed',
+                    code: 'shell_incarnation_drift',
+                    shell_pid: classified.shellPid,
+                    foreground_process_group_id: classified.group,
+                    shell_name: classified.shellName,
+                    foreground_processes: classified.processes,
+                    processes_truncated: classified.processesTruncated,
+                });
+                return terminal('failed', 'shell_incarnation_drift');
+            }
+        }
+        const sample = {
+            elapsed_ms: Math.max(0, sampleStart - started),
+            state: classified.state,
+            code: classified.code,
+            shell_pid: classified.shellPid,
+            foreground_process_group_id: classified.group,
+            shell_name: classified.shellName,
+            foreground_processes: classified.processes,
+            processes_truncated: classified.processesTruncated,
+        };
+        recordSample(sample);
+        if (classified.state === 'failed')
+            return terminal('failed', classified.code ?? 'process_facts_invalid');
+        if (classified.state === 'ready') {
+            const beforeFinalAbort = checkAbort();
+            if (beforeFinalAbort !== null)
+                return beforeFinalAbort;
+            const beforeFinalDeadline = checkDeadline('deadline_before_final_identity');
+            if (beforeFinalDeadline !== null)
+                return beforeFinalDeadline;
+            const finalIdentity = await ops.paneGet(identity.paneId, Math.max(1, deadline - clock()));
+            const afterFinalAbort = checkAbort();
+            if (afterFinalAbort !== null)
+                return afterFinalAbort;
+            const afterFinalDeadline = checkDeadline('deadline_after_final_identity');
+            if (afterFinalDeadline !== null)
+                return afterFinalDeadline;
+            if (!finalIdentity.ok)
+                return terminal(finalIdentity.status === 'unknown' ? 'unknown' : 'failed', `final_identity:${finalIdentity.code}`);
+            const finalCode = identityCode(finalIdentity.value, identity);
+            if (finalCode !== null)
+                return terminal('failed', finalCode);
+            if (finalIdentity.value.agent !== null)
+                return terminal('failed', 'agent_appeared_before_start');
+            return result('ready', null, identity);
+        }
+        if (attempts >= maxSamples)
+            return terminal('timeout', 'sample_limit_reached');
+        const remaining = deadline - clock();
+        if (remaining <= 0)
+            return terminal('timeout', classified.state === 'unknown'
+                ? 'deadline_unknown'
+                : 'deadline_not_ready');
+        await sleeper(Math.min(intervalMs, remaining));
+        const afterSleepAbort = checkAbort();
+        if (afterSleepAbort !== null)
+            return afterSleepAbort;
+        const afterSleepDeadline = checkDeadline('deadline_after_wait');
+        if (afterSleepDeadline !== null)
+            return afterSleepDeadline;
+    }
+}
+function immediateFailure(identity, code) {
+    return {
+        status: 'failed',
+        code,
+        evidence: {
+            state: 'failed',
+            code,
+            attempts: 0,
+            elapsed_ms: 0,
+            pane_id: identity.paneId,
+            workspace_id: identity.workspaceId,
+            terminal_id: identity.terminalId,
+            cwd: identity.cwd,
+            shell_pid: null,
+            foreground_process_group_id: null,
+            shell_name: null,
+            last_state: 'not_observed',
+            last_code: null,
+            limits: {
+                budget_ms: 0,
+                interval_ms: 0,
+                max_samples: 0,
+                samples_truncated: 0,
+            },
+            samples: [],
+        },
+    };
+}

package/dist/app/task-pin.d.ts

@@ -1,23 +1,2 @@
-export declare const TASK_PIN_SCHEMA = "pappra/task-pin/1";
-export interface TaskPin {
-    readonly schema: typeof TASK_PIN_SCHEMA;
-    readonly taskId: string;
-    readonly pinnedAt: string;
-}
-export interface TaskPinFailure {
-    readonly ok: false;
-    readonly message: string;
-}
-export declare function readTaskPin(root: string): Promise<TaskPin | null>;
-export declare function pinTask(root: string, taskId: string): Promise<TaskPin | TaskPinFailure>;
-export declare function unpinTask(root: string): Promise<{
-    ok: true;
-}>;
-/**
- * Toggles the workspace-level auto-resume switch. The hook only injects a resume
- * packet when this switch is on and a task pin exists; neither is inferred.
- */
-export declare function setAutoResume(root: string, enabled: boolean): Promise<{
-    ok: true;
-} | TaskPinFailure>;
-export declare function readAutoResume(root: string): Promise<boolean>;
+/** Workspace task selection is a continuity capability. */
+export * from '../continuity/task-pin.js';

package/dist/app/task-pin.js

@@ -1,113 +1,2 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { readTextFileBounded } from '../infra/fs.js';
-import { workspaceConfigSchema } from '../schemas/workspace.js';
-export const TASK_PIN_SCHEMA = 'pappra/task-pin/1';
-const TASK_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-function pinPath(root) {
-    return join(root, '.pappra', 'local', 'current-task');
-}
-export async function readTaskPin(root) {
-    const read = await readTextFileBounded(pinPath(root), 64 * 1024);
-    if (!read.ok)
-        return null;
-    try {
-        const value = JSON.parse(read.value.text);
-        if (typeof value !== 'object' ||
-            value === null ||
-            !('schema' in value) ||
-            value.schema !== TASK_PIN_SCHEMA ||
-            !('taskId' in value) ||
-            typeof value.taskId !== 'string' ||
-            !TASK_ID.test(value.taskId)) {
-            return null;
-        }
-        return value;
-    }
-    catch {
-        return null;
-    }
-}
-export async function pinTask(root, taskId) {
-    if (!TASK_ID.test(taskId)) {
-        return {
-            ok: false,
-            message: 'task id must be a short identifier (letters, digits, dot, dash, underscore).',
-        };
-    }
-    const pin = {
-        schema: TASK_PIN_SCHEMA,
-        taskId,
-        pinnedAt: new Date().toISOString(),
-    };
-    const target = pinPath(root);
-    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-    const temporary = `${target}.tmp-${randomUUID()}`;
-    await writeFile(temporary, `${JSON.stringify(pin, null, 2)}\n`, {
-        mode: 0o600,
-    });
-    await rename(temporary, target);
-    return pin;
-}
-export async function unpinTask(root) {
-    const target = pinPath(root);
-    const { rm } = await import('node:fs/promises');
-    await rm(target, { force: true });
-    return { ok: true };
-}
-/**
- * Toggles the workspace-level auto-resume switch. The hook only injects a resume
- * packet when this switch is on and a task pin exists; neither is inferred.
- */
-export async function setAutoResume(root, enabled) {
-    const configPath = join(root, '.pappra', 'workspace.json');
-    const read = await readTextFileBounded(configPath, 1024 * 1024);
-    if (!read.ok) {
-        return { ok: false, message: read.message };
-    }
-    let raw;
-    try {
-        raw = JSON.parse(read.value.text);
-    }
-    catch (error) {
-        return {
-            ok: false,
-            message: `workspace.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    const parsed = workspaceConfigSchema.safeParse({
-        ...(typeof raw === 'object' && raw !== null ? raw : {}),
-        continuity: { autoResume: enabled },
-    });
-    if (!parsed.success) {
-        return {
-            ok: false,
-            message: `workspace.json rejected the continuity switch: ${parsed.error.issues[0]?.message ?? 'invalid'}`,
-        };
-    }
-    const backup = join(root, '.pappra', 'local', 'backups', `task-pin-${randomUUID()}`, 'workspace.json');
-    await mkdir(dirname(backup), { recursive: true, mode: 0o700 });
-    await writeFile(backup, read.value.text, { mode: 0o600 });
-    const temporary = `${configPath}.tmp-${randomUUID()}`;
-    await writeFile(temporary, `${JSON.stringify(parsed.data, null, 2)}\n`);
-    await rename(temporary, configPath);
-    return { ok: true };
-}
-export async function readAutoResume(root) {
-    const read = await readFile(join(root, '.pappra', 'workspace.json'), 'utf8');
-    try {
-        const raw = JSON.parse(read);
-        if (typeof raw !== 'object' || raw === null || !('continuity' in raw)) {
-            return false;
-        }
-        const continuity = raw.continuity;
-        return (typeof continuity === 'object' &&
-            continuity !== null &&
-            'autoResume' in continuity &&
-            continuity.autoResume === true);
-    }
-    catch {
-        return false;
-    }
-}
+/** Workspace task selection is a continuity capability. */
+export * from '../continuity/task-pin.js';

package/dist/cli/commands/collaboration-binding.d.ts

@@ -0,0 +1,13 @@
+import type { CliOutput } from '../output.js';
+export declare const collaborationBindingUsage: string;
+export type BindingAction = 'list' | 'resolve' | 'bind' | 'unbind';
+export interface CollaborationBindingOptions {
+    readonly action: BindingAction | null;
+    readonly root: string | null;
+    readonly taskId: string | null;
+    readonly record: string | null;
+    readonly roots: string | null;
+    readonly apply: boolean;
+    readonly json: boolean;
+}
+export declare function runCollaborationBindingCommand(options: CollaborationBindingOptions, output: CliOutput): Promise<number>;

package/dist/cli/commands/collaboration-binding.js

@@ -0,0 +1,118 @@
+import { COLLAB_BINDING_RESULT_SCHEMA, bindAlias, listBindings, resolveBinding, unbindAlias, } from '../../app/collab-bindings.js';
+export const collaborationBindingUsage = 'pappra collab binding list [--root <abs workspace>] [--json]\n' +
+    'pappra collab binding resolve --task-id <alias> [--root <abs>] [--roots <abs roots.json>] [--json]\n' +
+    'pappra collab binding bind --task-id <alias> --record <abs task.json> [--root <abs>] [--apply] [--json]\n' +
+    'pappra collab binding unbind --task-id <alias> [--root <abs>] [--apply] [--json]\n\n' +
+    'Workspace-local alias pointers to authoritative collaboration records. The index\n' +
+    'contains pointer metadata only; it never copies protocol content,\n' +
+    'starts/adopts an execution or treats a target as live. Mutations plan by default.';
+function outputFailure(output, options, value, exitCode) {
+    const body = {
+        schema: COLLAB_BINDING_RESULT_SCHEMA,
+        ok: false,
+        status: exitCode === 2 ? 'invalid' : 'needs_input',
+        action: options.action,
+        code: value.code,
+        message: value.message,
+        nextAction: value.nextAction,
+        ...(value.details === undefined ? {} : { details: value.details }),
+    };
+    if (options.json)
+        output.stdout(`${JSON.stringify(body)}\n`);
+    else {
+        output.stdout(`Binding ${exitCode === 2 ? 'invalid' : 'needs input'}: ${value.message}\n`);
+        if (value.nextAction)
+            output.stdout(`  ${value.nextAction}\n`);
+        for (const detail of value.details ?? [])
+            output.stdout(`  - ${detail}\n`);
+    }
+    return exitCode;
+}
+function invalid(output, options, message) {
+    return outputFailure(output, options, {
+        ok: false,
+        code: 'invalid_options',
+        message,
+        nextAction: `Use ${collaborationBindingUsage.split('\n')[0]}.`,
+    }, 2);
+}
+function emitList(value, output) {
+    const counts = value.counts;
+    output.stdout(`Bindings: ${String(counts.bindings)} binding(s), ${String(counts.unbound)} tombstone(s).\n`);
+    for (const entry of value.bindings) {
+        output.stdout(`  ${String(entry.alias)} -> ${String(entry.record)} [${String(entry.status)}]\n`);
+    }
+    if (value.truncated === true) {
+        const omitted = value.omitted;
+        output.stdout(`  omitted: ${String(omitted.bindings)} binding(s), ${String(omitted.unbound)} tombstone(s)\n`);
+    }
+}
+function emitResolve(value, output) {
+    output.stdout(`Alias ${String(value.alias)}: ${String(value.status)} (usable ${String(value.usable)}).\n`);
+    const target = value.target;
+    if (target) {
+        output.stdout(`  record: ${String(target.record)} revision ${String(target.state_revision)}; coordinator epoch ${String(target.coordinator_epoch)}; frozen ${String(target.dispatch_frozen)}\n`);
+        output.stdout(`  attempts: ${String(target.attempt_count)}; scope: ${String(value.scope)}; live status: ${String(value.liveStatus)}\n`);
+    }
+    for (const candidate of value.candidates)
+        output.stdout(`  candidate: ${candidate}\n`);
+    for (const error of value.errors)
+        output.stdout(`  ! ${error}\n`);
+}
+function emitMutation(value, action, output) {
+    if (value.status === 'planned') {
+        output.stdout(action === 'bind'
+            ? 'Bind plan validates the alias, target and index; nothing was written.\n'
+            : 'Unbind plan validates the alias and index; nothing was written.\n');
+        return;
+    }
+    output.stdout(`${action === 'bind' ? 'Bind' : 'Unbind'} ${String(value.status)}; applied ${String(value.applied)}.\n`);
+    const target = value.target;
+    if (target)
+        output.stdout(`  target: ${String(target.record)}\n`);
+}
+export async function runCollaborationBindingCommand(options, output) {
+    if (options.action === null)
+        return invalid(output, options, 'binding requires list/resolve/bind/unbind.');
+    const serviceOptions = {
+        root: options.root,
+        taskId: options.taskId,
+        record: options.record,
+        roots: options.roots,
+        apply: options.apply,
+    };
+    const result = options.action === 'list'
+        ? await listBindings(serviceOptions)
+        : options.action === 'resolve'
+            ? await resolveBinding(serviceOptions)
+            : options.action === 'bind'
+                ? await bindAlias(serviceOptions)
+                : await unbindAlias(serviceOptions);
+    if (!result.ok) {
+        const exitCode = result.code === 'invalid_options' ||
+            result.code === 'workspace_unavailable' ||
+            result.code === 'bindings_invalid' ||
+            result.code === 'roots_invalid'
+            ? 2
+            : 1;
+        return outputFailure(output, options, result, exitCode);
+    }
+    if (options.json)
+        output.stdout(`${JSON.stringify(result.value)}\n`);
+    else if (options.action === 'list')
+        emitList(result.value, output);
+    else if (options.action === 'resolve')
+        emitResolve(result.value, output);
+    else
+        emitMutation(result.value, options.action, output);
+    if (options.action === 'resolve') {
+        const status = result.value.status;
+        return status === 'binding' ||
+            status === 'discovery-unique' ||
+            status === 'unbound' ||
+            status === 'none'
+            ? 0
+            : 1;
+    }
+    return 0;
+}

package/dist/cli/commands/collaboration-bootstrap.d.ts

@@ -0,0 +1,10 @@
+import { type BootstrapAction, type VisibleBootstrapDependencies } from '../../app/collab-bootstrap.js';
+import type { CliOutput } from '../output.js';
+export declare const collaborationBootstrapUsage: string;
+export interface CollaborationBootstrapOptions {
+    readonly action: BootstrapAction | null;
+    readonly taskRoot: string | null;
+    readonly requestFile: string | null;
+    readonly json: boolean;
+}
+export declare function runCollaborationBootstrapCommand(options: CollaborationBootstrapOptions, output: CliOutput, dependencies?: VisibleBootstrapDependencies): Promise<number>;