brainclaw 1.5.4 → 1.6.0

package/dist/commands/bootstrap-loop.js

@@ -0,0 +1,206 @@
+import readline from 'node:readline';
+import { memoryExists } from '../core/io.js';
+import { acquireBootstrapLoop, BootstrapCoordinationInProgressError, closeLoop, computeNextExpected, findExistingBootstrapLoop, } from '../core/loops/index.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+function fail(message, exitCode, opts) {
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+    }
+    else {
+        console.error(`Error: ${message}`);
+    }
+    process.exit(exitCode);
+}
+function parseQuestionBody(artifact) {
+    if (artifact.type !== 'operator_question' || !artifact.body)
+        return undefined;
+    try {
+        return JSON.parse(artifact.body);
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatNextExpected(hint) {
+    if (!hint)
+        return '  (loop has no further expected action)';
+    const bits = [`  next: ${hint.action} (${hint.intent})`];
+    if (hint.phase)
+        bits.push(`  phase: ${hint.phase}`);
+    if (hint.slot_id)
+        bits.push(`  slot: ${hint.slot_id}${hint.role ? ` [${hint.role}]` : ''}`);
+    if (hint.from_phase && hint.to_phase)
+        bits.push(`  ${hint.from_phase} → ${hint.to_phase}`);
+    if (hint.blocking_on.length)
+        bits.push(`  blocking_on: ${hint.blocking_on.join(', ')}`);
+    if (hint.reason)
+        bits.push(`  reason: ${hint.reason}`);
+    return bits.join('\n');
+}
+function buildResult(action, loop) {
+    const hint = action === 'cancelled' ? null : computeNextExpected(loop);
+    const openQuestions = loop.open_questions;
+    const result = {
+        ok: true,
+        action,
+        loop_id: loop.id,
+        current_phase: loop.current_phase,
+        status: loop.status,
+        open_questions: openQuestions,
+        next_expected: hint,
+    };
+    if (loop.pause_reason) {
+        result.pause_reason = loop.pause_reason;
+    }
+    if (loop.pending_file_apply) {
+        result.pending_file_apply = {
+            target_path: loop.pending_file_apply.target_path,
+            artifact_id: loop.pending_file_apply.artifact_id,
+            diff_artifact_id: loop.pending_file_apply.diff_artifact_id,
+        };
+    }
+    if (action === 'joined') {
+        result.joined_existing = true;
+    }
+    return result;
+}
+function printHuman(result, loop) {
+    const prefix = result.action === 'opened'
+        ? '✔ Opened bootstrap loop'
+        : result.action === 'joined'
+            ? '↺ Joined existing bootstrap loop'
+            : result.action === 'cancelled'
+                ? '✔ Cancelled bootstrap loop'
+                : '• Bootstrap loop status';
+    console.log(`${prefix} ${loop.id}`);
+    console.log(`  phase: ${loop.current_phase}`);
+    console.log(`  status: ${loop.status}`);
+    if (result.pause_reason) {
+        console.log(`  pause_reason: ${result.pause_reason}`);
+    }
+    if (loop.open_questions.length > 0) {
+        console.log(`  open_questions: ${loop.open_questions.length} (${loop.open_questions.join(', ')})`);
+        for (const q of loop.artifacts) {
+            const body = parseQuestionBody(q);
+            if (body && loop.open_questions.includes(body.question_id)) {
+                console.log(`    - ${body.question_id}: ${body.question_text}`);
+            }
+        }
+    }
+    if (result.pending_file_apply) {
+        console.log(`  pending_file_apply: ${result.pending_file_apply.target_path}`);
+    }
+    if (loop.slots.length > 0) {
+        const slotDesc = loop.slots
+            .map((s) => `${s.role}${s.agent ? `=${s.agent}` : ''} [${s.status}]`)
+            .join(', ');
+        console.log(`  slots: ${slotDesc}`);
+    }
+    if (result.action !== 'cancelled') {
+        console.log(formatNextExpected(result.next_expected ?? null));
+    }
+}
+async function confirmCancel(loopId) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const answer = await new Promise((resolve) => {
+            rl.question(`Cancel bootstrap loop ${loopId}? This sets status='cancelled'. [y/N] `, (a) => resolve(a));
+        });
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * `brainclaw bootstrap-loop` — open, join, query, or cancel the bootstrap
+ * loop on the current project. The open/join path delegates to
+ * `acquireBootstrapLoop` (src/core/loops/bootstrap-acquire.ts) which
+ * implements the same coordination-lock singleton acquire used by the MCP
+ * bclaw_coordinate facade. Two concurrent CLI invocations will now converge
+ * on the same loop rather than opening duplicates (pln#518 step 1).
+ */
+export async function runBootstrapLoopCommand(options = {}, cwd) {
+    if (!memoryExists(cwd)) {
+        fail('.brainclaw/ not found. Run `brainclaw init` first.', 1, options);
+    }
+    const modes = [];
+    if (options.status)
+        modes.push('--status');
+    if (options.cancel)
+        modes.push('--cancel');
+    if (modes.length > 1) {
+        fail(`--status and --cancel are mutually exclusive (got: ${modes.join(', ')})`, 1, options);
+    }
+    if (options.status) {
+        const existing = findExistingBootstrapLoop(cwd);
+        if (!existing) {
+            fail('no active bootstrap loop on this project. Run `brainclaw bootstrap-loop` to open one.', 1, options);
+        }
+        const result = buildResult('status', existing);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        printHuman(result, existing);
+        return;
+    }
+    if (options.cancel) {
+        const existing = findExistingBootstrapLoop(cwd);
+        if (!existing) {
+            fail('no active bootstrap loop to cancel on this project.', 1, options);
+        }
+        if (!options.yes) {
+            const confirmed = await confirmCancel(existing.id);
+            if (!confirmed) {
+                fail('cancellation aborted by operator.', 1, options);
+            }
+        }
+        const actor = resolveCurrentAgentName(cwd);
+        let closed;
+        try {
+            closed = closeLoop({
+                id: existing.id,
+                final_status: 'cancelled',
+                reason: 'operator_cancelled',
+                actor,
+            }, cwd);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            fail(`closeLoop verb rejected the call: ${msg}`, 2, options);
+        }
+        const result = buildResult('cancelled', closed);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        printHuman(result, closed);
+        return;
+    }
+    // No-args: delegate to the singleton acquire path (pln#518 step 1).
+    // acquireBootstrapLoop handles find-existing + coordination-lock + openLoop,
+    // preventing two concurrent CLI invocations from both calling openLoop.
+    const actor = resolveCurrentAgentName(cwd);
+    let loop;
+    let action;
+    try {
+        const acquired = acquireBootstrapLoop({ actor }, cwd);
+        loop = acquired.loop;
+        action = acquired.action;
+    }
+    catch (err) {
+        if (err instanceof BootstrapCoordinationInProgressError) {
+            fail(err.message, 2, options);
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        fail(`bootstrap-loop acquire failed: ${msg}`, 2, options);
+    }
+    const result = buildResult(action, loop);
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    printHuman(result, loop);
+}
+//# sourceMappingURL=bootstrap-loop.js.map

package/dist/commands/init.js

@@ -4,7 +4,7 @@ import readline from 'node:readline/promises';
 import { registerAgentIdentity, resolveDefaultAgentName, resolveExistingCurrentAgent } from '../core/agent-registry.js';
 import { MEMORY_DIR, memoryExists, ensureMemoryDir, memoryPath, writeFileAtomic } from '../core/io.js';
 import { emptyState, loadState, saveState } from '../core/state.js';
-import { defaultConfig, saveConfig } from '../core/config.js';
+import { defaultConfig, loadConfig, saveConfig } from '../core/config.js';
 import { generateMarkdown } from '../core/markdown.js';
 import { initMemoryRepo } from '../core/memory-git.js';
 import { buildProjectIdentity, resolveExistingProjectIdentity, saveProjectIdentity } from '../core/project-registry.js';
@@ -18,6 +18,7 @@ import { buildAiSurfaceInventory, renderAiSurfaceUsageHints } from '../core/ai-s
 import { ensureUserStore, hasCompletedSetup } from '../core/setup-state.js';
 import { writeDetectedAgentExport } from './export.js';
 import { writeDetectedAgentHooks } from './hooks.js';
+import { ConfigSchema } from '../core/schema.js';
 export async function runInit(options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const containingMemoryStore = resolveContainingMemoryStore(cwd);
@@ -58,22 +59,20 @@ export async function runInit(options = {}) {
     const existingIdentity = resolveExistingProjectIdentity(cwd);
     const existingCurrentAgent = resolveExistingCurrentAgent(cwd);
     const storageDir = resolveStorageDir(options.storageDir);
-    const topology = resolveTopology(options.topology);
-    const ignoreStrategy = topology === 'embedded' ? 'none' : 'project-gitignore';
+    const projectMemoryExists = memoryExists(cwd);
+    const existingConfig = projectMemoryExists ? loadExistingConfig(cwd, storageDir) : undefined;
+    const topology = resolveTopology(options.topology, existingConfig?.topology);
+    const ignoreStrategy = resolveIgnoreStrategy(topology, existingConfig?.ignore_strategy);
     const skipAgentBootstrap = options.skipAgentBootstrap === true || process.env.BRAINCLAW_SKIP_AGENT_BOOTSTRAP === '1';
     const testMode = process.env.BRAINCLAW_TEST_MODE === '1';
     const skipAiSurfaceScan = testMode || options.noAiScan === true || options.aiScan === false;
-    if (memoryExists(cwd) && !options.force) {
-        console.error('Error: project memory already exists. Use --force to overwrite.');
-        process.exit(1);
-    }
     // Derive project name from directory
     const projectName = path.basename(cwd);
     const shouldAnalyzeRepo = options.analyzeRepo !== false
         && process.env.BRAINCLAW_SKIP_REPO_ANALYSIS !== '1';
     const analysis = shouldAnalyzeRepo ? analyzeRepository(cwd) : undefined;
-    const projectMode = await resolveProjectMode(options, analysis);
-    const projectStrategy = await resolveProjectStrategy(options, projectMode);
+    const projectMode = await resolveProjectMode(options, analysis, existingConfig?.project_mode);
+    const projectStrategy = await resolveProjectStrategy(options, projectMode, existingConfig?.projects?.strategy);
     ensureMemoryDir(cwd, storageDir);
     const currentAgent = registerAgentIdentity({
         agentName: existingCurrentAgent?.agent_name ?? resolveDefaultAgentName(),
@@ -112,19 +111,21 @@ export async function runInit(options = {}) {
         storageDir,
         topology,
     });
-    const config = defaultConfig(projectName, {
-        projectId: projectIdentity.project_id,
-        currentAgent: currentAgent.agent_name,
-        currentAgentId: currentAgent.agent_id,
+    const config = buildInitConfig({
+        projectName,
+        projectIdentity,
+        currentAgent: {
+            name: currentAgent.agent_name,
+            id: currentAgent.agent_id,
+        },
         projectMode,
         projectStrategy,
         storageDir,
         topology,
         ignoreStrategy,
+        existingConfig: options.force ? undefined : existingConfig,
+        compact: options.compact === true,
     });
-    if (options.compact) {
-        config.markdown = { max_items_per_section: 20, compact_mode: true };
-    }
     if (detectedAi && isAgentIntegrationName(detectedAi.name)) {
         upsertAgentIntegrationDeclaration(config, detectedAi.name, 'detected');
     }
@@ -173,8 +174,19 @@ export async function runInit(options = {}) {
             .filter((item) => !item.startsWith('.codeium/'));
         ensureGitignoreEntries(cwd, ['AGENTS.md', '.github/copilot-instructions.md', ...generatedWorkspacePaths, ...BRAINCLAW_EXCLUSIVE_DIRECTORIES]);
     }
-    console.log(`✔ Initialized project memory in ${storageDir}/`);
-    console.log('✔ Created project.md, config.yaml, and split state directories');
+    if (projectMemoryExists) {
+        console.log(`✔ Refreshed existing project memory in ${storageDir}/`);
+        if (options.force) {
+            console.log('✔ Existing memory preserved; rebuilt managed configuration and agent integration files from defaults');
+        }
+        else {
+            console.log('✔ Existing memory preserved; refreshed managed configuration and agent integration files');
+        }
+    }
+    else {
+        console.log(`✔ Initialized project memory in ${storageDir}/`);
+        console.log('✔ Created project.md, config.yaml, and split state directories');
+    }
     console.log(`✔ Project ID: ${projectIdentity.project_id}`);
     console.log(`✔ Current agent: ${currentAgent.agent_name} (${currentAgent.agent_id})`);
     if (registeredAiAgent) {
@@ -275,6 +287,12 @@ export async function runInit(options = {}) {
         }
     }
     console.log('');
+    if (projectMemoryExists) {
+        console.log(`Tip: run 'brainclaw enable-agent <agent-name>' when you want to explicitly add another agent to this existing project.`);
+    }
+    else {
+        console.log(`Tip: run 'brainclaw init' again later to refresh the detected agent's integration files on this project.`);
+    }
     console.log(`Tip: run 'brainclaw context --json' to load the shared memory into your agent session.`);
 }
 function installPostMergeHookIfMissing(cwd) {
@@ -342,8 +360,19 @@ function looksLikeBrainclawStore(storePath) {
         || fs.existsSync(path.join(storePath, 'project.identity.json'))
         || fs.existsSync(path.join(storePath, '.git'));
 }
-function resolveTopology(topology) {
-    return topology ?? 'embedded';
+function resolveTopology(topology, existingTopology) {
+    return topology ?? existingTopology ?? 'embedded';
+}
+function resolveIgnoreStrategy(topology, existingIgnoreStrategy) {
+    return existingIgnoreStrategy ?? (topology === 'embedded' ? 'none' : 'project-gitignore');
+}
+function loadExistingConfig(cwd, storageDir) {
+    try {
+        return loadConfig(cwd, storageDir);
+    }
+    catch {
+        return undefined;
+    }
 }
 function ensureProjectGitignore(cwd, storageDir) {
     const gitignorePath = path.join(cwd, '.gitignore');
@@ -358,10 +387,13 @@ function ensureProjectGitignore(cwd, storageDir) {
         : `${current.replace(/\s*$/, '')}\n${ignoreLine}\n`;
     fs.writeFileSync(gitignorePath, next, 'utf-8');
 }
-async function resolveProjectMode(options, analysis) {
+async function resolveProjectMode(options, analysis, existingProjectMode) {
     if (options.projectMode) {
         return options.projectMode;
     }
+    if (existingProjectMode) {
+        return existingProjectMode;
+    }
     if (options.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
         return 'auto';
     }
@@ -384,13 +416,16 @@ async function resolveProjectMode(options, analysis) {
         rl.close();
     }
 }
-async function resolveProjectStrategy(options, projectMode) {
+async function resolveProjectStrategy(options, projectMode, existingProjectStrategy) {
     if (options.projectStrategy) {
         return options.projectStrategy;
     }
     if (projectMode !== 'multi-project') {
         return 'manual';
     }
+    if (existingProjectStrategy) {
+        return existingProjectStrategy;
+    }
     if (options.yes || !process.stdin.isTTY || !process.stdout.isTTY) {
         return 'manual';
     }
@@ -438,4 +473,105 @@ function parseProjectStrategy(value) {
             return undefined;
     }
 }
+function buildInitConfig(input) {
+    const fallbackConfig = defaultConfig(input.projectName, {
+        projectId: input.projectIdentity.project_id,
+        currentAgent: input.currentAgent.name,
+        currentAgentId: input.currentAgent.id,
+        projectMode: input.projectMode,
+        projectStrategy: input.projectStrategy,
+        storageDir: input.storageDir,
+        topology: input.topology,
+        ignoreStrategy: input.ignoreStrategy,
+    });
+    const config = input.existingConfig
+        ? mergeConfigWithDefaults(input.existingConfig, fallbackConfig)
+        : fallbackConfig;
+    const projects = config.projects ?? fallbackConfig.projects;
+    config.project_name = input.projectName;
+    config.project_id = input.projectIdentity.project_id;
+    config.current_agent = input.currentAgent.name;
+    config.current_agent_id = input.currentAgent.id;
+    config.storage_dir = input.storageDir;
+    config.topology = input.topology;
+    config.ignore_strategy = input.ignoreStrategy;
+    config.project_mode = input.projectMode;
+    config.projects = {
+        ...projects,
+        strategy: input.projectStrategy,
+        known: projects.known ?? fallbackConfig.projects.known,
+    };
+    if (input.compact) {
+        const markdown = config.markdown ?? fallbackConfig.markdown ?? {
+            max_items_per_section: 20,
+            compact_mode: false,
+        };
+        config.markdown = {
+            ...markdown,
+            compact_mode: true,
+            max_items_per_section: Math.min(markdown.max_items_per_section, 20),
+        };
+    }
+    return config;
+}
+function mergeConfigWithDefaults(existingConfig, fallbackConfig) {
+    return ConfigSchema.parse({
+        ...fallbackConfig,
+        ...existingConfig,
+        projects: {
+            ...fallbackConfig.projects,
+            ...(existingConfig.projects ?? {}),
+            known: existingConfig.projects?.known ?? fallbackConfig.projects.known,
+        },
+        redaction: {
+            ...fallbackConfig.redaction,
+            ...(existingConfig.redaction ?? {}),
+            patterns: existingConfig.redaction?.patterns ?? fallbackConfig.redaction.patterns,
+        },
+        security: existingConfig.security
+            ? {
+                ...fallbackConfig.security,
+                ...existingConfig.security,
+            }
+            : fallbackConfig.security,
+        markdown: existingConfig.markdown
+            ? {
+                ...fallbackConfig.markdown,
+                ...existingConfig.markdown,
+            }
+            : fallbackConfig.markdown,
+        reflective_memory: existingConfig.reflective_memory
+            ? {
+                ...fallbackConfig.reflective_memory,
+                ...existingConfig.reflective_memory,
+            }
+            : fallbackConfig.reflective_memory,
+        governance: fallbackConfig.governance
+            ? {
+                ...fallbackConfig.governance,
+                ...existingConfig.governance,
+                curators: existingConfig.governance?.curators ?? fallbackConfig.governance.curators,
+            }
+            : existingConfig.governance,
+        reputation: existingConfig.reputation
+            ? {
+                ...fallbackConfig.reputation,
+                ...existingConfig.reputation,
+            }
+            : fallbackConfig.reputation,
+        agent_integrations: {
+            ...fallbackConfig.agent_integrations,
+            ...(existingConfig.agent_integrations ?? {}),
+            declarations: existingConfig.agent_integrations?.declarations ?? fallbackConfig.agent_integrations.declarations,
+        },
+        claims: existingConfig.claims
+            ? {
+                ...fallbackConfig.claims,
+                ...existingConfig.claims,
+            }
+            : fallbackConfig.claims,
+        sensitive_paths: existingConfig.sensitive_paths ?? fallbackConfig.sensitive_paths,
+        cross_project_links: existingConfig.cross_project_links ?? fallbackConfig.cross_project_links,
+    });
+}
 //# sourceMappingURL=init.js.map

package/dist/commands/loop.js

@@ -0,0 +1,156 @@
+import { memoryExists } from '../core/io.js';
+import { handleBclawLoop } from './loops-handlers.js';
+function fail(message, exitCode, opts) {
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+    }
+    else {
+        console.error(`Error: ${message}`);
+    }
+    process.exit(exitCode);
+}
+function requireLoopId(args, opts) {
+    const loopId = args.loop_id;
+    if (!loopId || !/^lop_[0-9a-z]+$/.test(loopId)) {
+        fail(`invalid loop_id "${loopId ?? ''}" — expected format lop_<hex>`, 1, opts);
+    }
+    return loopId;
+}
+function requireOption(value, flag, opts) {
+    if (value === undefined || value === '') {
+        fail(`${flag} is required`, 1, opts);
+    }
+    return value;
+}
+function parseJsonObject(raw, flag, opts) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        fail(`${flag} must be valid JSON object syntax: ${message}`, 1, opts);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        fail(`${flag} must be a JSON object`, 1, opts);
+    }
+    return parsed;
+}
+function parseOptionalRef(raw, opts) {
+    if (raw === undefined)
+        return undefined;
+    const parsed = parseJsonObject(raw, '--ref', opts);
+    if (typeof parsed.kind !== 'string' || typeof parsed.id !== 'string') {
+        fail('--ref must be a JSON object with string fields { "kind", "id" }', 1, opts);
+    }
+    return { kind: parsed.kind, id: parsed.id };
+}
+function parseBody(raw) {
+    try {
+        return JSON.stringify(JSON.parse(raw));
+    }
+    catch {
+        return raw;
+    }
+}
+function parseOutcome(opts) {
+    const outcome = opts.outcome;
+    if (outcome !== 'done' && outcome !== 'failed' && outcome !== 'cancelled') {
+        fail(`--outcome must be one of done|failed|cancelled (got "${outcome ?? ''}")`, 1, opts);
+    }
+    return outcome;
+}
+function formatNextExpected(hint) {
+    if (!hint)
+        return '  (loop has no further expected action)';
+    const bits = [`  next: ${hint.action} (${hint.intent})`];
+    if (hint.phase)
+        bits.push(`  phase: ${hint.phase}`);
+    if (hint.slot_id)
+        bits.push(`  slot: ${hint.slot_id}${hint.role ? ` [${hint.role}]` : ''}`);
+    if (hint.from_phase && hint.to_phase)
+        bits.push(`  ${hint.from_phase} -> ${hint.to_phase}`);
+    if (hint.blocking_on.length)
+        bits.push(`  blocking_on: ${hint.blocking_on.join(', ')}`);
+    if (hint.reason)
+        bits.push(`  reason: ${hint.reason}`);
+    return bits.join('\n');
+}
+function buildRequest(subcommand, loopId, opts) {
+    switch (subcommand) {
+        case 'turn':
+            return {
+                intent: 'turn',
+                loop_id: loopId,
+                slot_id: requireOption(opts.slot, '--slot <slot_id>', opts),
+                input: requireOption(opts.input, '--input <text>', opts),
+                role: opts.role,
+                assignment_id: opts.assignmentId,
+            };
+        case 'complete-turn': {
+            const artifact = opts.artifact
+                ? parseJsonObject(opts.artifact, '--artifact', opts)
+                : undefined;
+            return {
+                intent: 'complete_turn',
+                loop_id: loopId,
+                slot_id: requireOption(opts.slot, '--slot <slot_id>', opts),
+                outcome: parseOutcome(opts),
+                failure_reason: opts.failureReason,
+                artifact,
+            };
+        }
+        case 'advance':
+            return {
+                intent: 'advance',
+                loop_id: loopId,
+                to_phase: opts.toPhase,
+                force: opts.force,
+                reason: opts.reason,
+            };
+        case 'add-artifact':
+            return {
+                intent: 'add_artifact',
+                loop_id: loopId,
+                artifact: {
+                    phase: requireOption(opts.phase, '--phase <phase>', opts),
+                    type: requireOption(opts.type, '--type <type>', opts),
+                    body: parseBody(requireOption(opts.body, '--body <json-or-text>', opts)),
+                    produced_by: opts.producedBy,
+                    ref: parseOptionalRef(opts.ref, opts),
+                },
+            };
+    }
+}
+export function runLoopCommand(subcommand, args, options = {}, cwd) {
+    if (!memoryExists(cwd)) {
+        console.error('Error: .brainclaw/ not found. Run `brainclaw init` first.');
+        process.exit(1);
+    }
+    const loopId = requireLoopId(args, options);
+    const request = buildRequest(subcommand, loopId, options);
+    const handled = handleBclawLoop({ args: request, cwd });
+    if (handled.response.status !== 'ok') {
+        const message = handled.response.error ?? handled.summary;
+        fail(`bclaw_loop.${String(request.intent)} rejected the call: ${message}`, 2, options);
+    }
+    const result = handled.response.result;
+    const loop = result.loop;
+    const out = {
+        ok: true,
+        action: subcommand,
+        loop_id: loop?.id ?? loopId,
+        current_phase: loop?.current_phase,
+        status: loop?.status,
+        next_expected: result.next_expected ?? null,
+        auto_closed: result.auto_closed || undefined,
+    };
+    if (options.json) {
+        console.log(JSON.stringify(out, null, 2));
+        return out;
+    }
+    console.log(`OK loop ${subcommand} ${out.loop_id}${out.current_phase ? ` phase=${out.current_phase}` : ''}${out.status ? ` status=${out.status}` : ''}`);
+    console.log(formatNextExpected(out.next_expected));
+    return out;
+}
+//# sourceMappingURL=loop.js.map