discoclaw 0.1.0

package/dist/runtime/strategies/template-strategy.js

@@ -0,0 +1,85 @@
+// Template strategy for adding a new CLI-based runtime adapter.
+//
+// To add a new model:
+// 1. Copy this file and rename (e.g. gemini-strategy.ts).
+// 2. Implement the required hooks below.
+// 3. Create a thin wrapper in src/runtime/<model>-cli.ts:
+//
+//    import { createCliRuntime } from './cli-adapter.js';
+//    import { myStrategy } from './strategies/my-strategy.js';
+//
+//    export function createMyCliRuntime(opts: MyOpts): RuntimeAdapter {
+//      return createCliRuntime(myStrategy, { binary: opts.bin, ... });
+//    }
+//
+// 4. Register in src/runtime/registry.ts and src/index.ts.
+//
+// The universal adapter (cli-adapter.ts) provides:
+// - Subprocess tracking + kill-all shutdown
+// - Process pool (multi-turn, process-pool mode)
+// - Session resume map (session-resume mode)
+// - Stream stall detection
+// - Session file scanning (Claude-specific, opt-in via opts)
+// - JSONL line parsing + image dedup
+// - Error handling with strategy delegation
+// - Event queue (push/wait/wake async generator pattern)
+export const templateStrategy = {
+    // --- Required: identity ---
+    id: 'template', // Replace with your RuntimeId (add to types.ts first).
+    binaryDefault: 'my-cli', // Default binary name (overridden by opts.binary).
+    defaultModel: 'my-model', // Used when params.model is empty.
+    capabilities: [
+        'streaming_text',
+        // Add capabilities your model supports:
+        // 'sessions', 'workspace_instructions', 'tools_exec', 'tools_fs', 'tools_web', 'mcp'
+    ],
+    // --- Required: output mode ---
+    getOutputMode(_ctx, _opts) {
+        // Return 'text' for plain stdout, 'jsonl' for line-delimited JSON.
+        // Can vary per invocation (e.g. Codex switches based on session state).
+        return 'text';
+    },
+    // --- Required: arg building ---
+    buildArgs(ctx, _opts) {
+        // Build the CLI argument array. The universal adapter calls:
+        //   execa(binary, args, { cwd, timeout, ... })
+        //
+        // ctx.params contains: model, prompt, cwd, sessionKey, addDirs, tools, images, etc.
+        // ctx.useStdin is true when the prompt is too large for a positional arg.
+        // ctx.hasImages is true when image content blocks are present.
+        // ctx.sessionMap is available for session-resume mode strategies.
+        const args = ['--model', ctx.params.model];
+        if (!ctx.useStdin) {
+            args.push('--', ctx.params.prompt);
+        }
+        return args;
+    },
+    // --- Optional: stdin payload ---
+    buildStdinPayload(ctx) {
+        if (!ctx.useStdin)
+            return null;
+        // Return raw text or JSON-formatted stdin payload.
+        // The universal adapter writes this to subprocess.stdin and closes it.
+        return ctx.params.prompt;
+    },
+    // --- Optional: JSONL line parsing ---
+    // Only needed if getOutputMode returns 'jsonl'.
+    // Return null to fall through to the default Claude-compatible parser.
+    // parseLine(evt: unknown, ctx: CliInvokeContext): ParsedLineResult | null {
+    //   const anyEvt = evt as Record<string, unknown>;
+    //   if (anyEvt.type === 'message' && typeof anyEvt.text === 'string') {
+    //     return { text: anyEvt.text };
+    //   }
+    //   return null;
+    // },
+    // --- Optional: multi-turn mode ---
+    // 'process-pool': keeps long-running subprocesses alive (like Claude).
+    // 'session-resume': resumes sessions by ID (like Codex).
+    // 'none' or omit: one-shot only.
+    // multiTurnMode: 'none',
+    // --- Optional: error handling ---
+    // Return a user-facing message, or null to use default handling.
+    // sanitizeError(raw: string, binary: string): string { return raw; },
+    // handleSpawnError(err: any, binary: string): string | null { return null; },
+    // handleExitError(exitCode: number, stderr: string, stdout: string): string | null { return null; },
+};

package/dist/runtime/tool-capabilities.js

@@ -0,0 +1,27 @@
+const TOOL_CAPABILITIES = {
+    Bash: 'tools_exec',
+    Read: 'tools_fs',
+    Write: 'tools_fs',
+    Edit: 'tools_fs',
+    Glob: 'tools_fs',
+    Grep: 'tools_fs',
+    WebSearch: 'tools_web',
+    WebFetch: 'tools_web',
+};
+export function requiredCapabilityForTool(tool) {
+    return TOOL_CAPABILITIES[tool];
+}
+export function filterToolsByCapabilities(tools, capabilities) {
+    const kept = [];
+    const dropped = [];
+    for (const tool of tools) {
+        const required = requiredCapabilityForTool(tool);
+        if (!required || capabilities.has(required)) {
+            kept.push(tool);
+        }
+        else {
+            dropped.push(tool);
+        }
+    }
+    return { tools: kept, dropped };
+}

package/dist/runtime/tool-capabilities.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { filterToolsByCapabilities, requiredCapabilityForTool } from './tool-capabilities.js';
+describe('requiredCapabilityForTool', () => {
+    it('returns expected capability for known tools', () => {
+        expect(requiredCapabilityForTool('Read')).toBe('tools_fs');
+        expect(requiredCapabilityForTool('Bash')).toBe('tools_exec');
+        expect(requiredCapabilityForTool('WebSearch')).toBe('tools_web');
+    });
+    it('returns undefined for unknown tools', () => {
+        expect(requiredCapabilityForTool('CustomTool')).toBeUndefined();
+    });
+});
+describe('filterToolsByCapabilities', () => {
+    it('keeps only tool-compatible entries and reports dropped tools', () => {
+        const result = filterToolsByCapabilities(['Read', 'Bash', 'WebSearch', 'CustomTool'], new Set(['tools_fs']));
+        expect(result.tools).toEqual(['Read', 'CustomTool']);
+        expect(result.dropped).toEqual(['Bash', 'WebSearch']);
+    });
+    it('keeps all tools when all required capabilities are present', () => {
+        const result = filterToolsByCapabilities(['Read', 'Bash', 'WebSearch'], new Set(['tools_fs', 'tools_exec', 'tools_web']));
+        expect(result.tools).toEqual(['Read', 'Bash', 'WebSearch']);
+        expect(result.dropped).toEqual([]);
+    });
+});

package/dist/runtime/tool-labels.js

@@ -0,0 +1,48 @@
+/**
+ * Human-readable labels for tool activity display in Discord.
+ */
+function shortPath(p) {
+    const segments = p.replace(/\\/g, '/').split('/').filter(Boolean);
+    if (segments.length <= 2)
+        return segments.join('/');
+    return '.../' + segments.slice(-2).join('/');
+}
+function extractPath(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const obj = input;
+    for (const key of ['file_path', 'path', 'pattern']) {
+        if (typeof obj[key] === 'string' && obj[key])
+            return obj[key];
+    }
+    return null;
+}
+export function toolActivityLabel(name, input) {
+    const p = extractPath(input);
+    const short = p ? shortPath(p) : null;
+    switch (name) {
+        case 'Read':
+            return short ? `Reading ${short}` : 'Reading file...';
+        case 'Write':
+            return short ? `Writing ${short}` : 'Writing file...';
+        case 'Edit':
+            return short ? `Editing ${short}` : 'Editing file...';
+        case 'Bash':
+            return 'Running command...';
+        case 'Grep':
+            return 'Searching content...';
+        case 'Glob':
+            return 'Finding files...';
+        case 'WebSearch':
+            return 'Searching web...';
+        case 'WebFetch':
+            return 'Fetching URL...';
+        case 'Task':
+            return 'Running subtask...';
+        case 'TodoRead':
+        case 'TodoWrite':
+            return 'Managing tasks...';
+        default:
+            return `Running ${name}...`;
+    }
+}

package/dist/runtime/types.js

@@ -0,0 +1,2 @@
+/** Max images per invocation to prevent runaway accumulation. */
+export const MAX_IMAGES_PER_INVOCATION = 10;

package/dist/sessionManager.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+async function readJsonIfExists(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object')
+            return parsed;
+        return {};
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return {};
+        throw err;
+    }
+}
+async function atomicWriteJson(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp.${process.pid}`;
+    await fs.writeFile(tmp, JSON.stringify(value, null, 2) + '\n', 'utf8');
+    await fs.rename(tmp, filePath);
+}
+export class SessionManager {
+    storePath;
+    store = null;
+    constructor(storePath) {
+        this.storePath = storePath;
+    }
+    async load() {
+        if (this.store)
+            return this.store;
+        this.store = await readJsonIfExists(this.storePath);
+        return this.store;
+    }
+    async getOrCreate(sessionKey) {
+        const store = await this.load();
+        const existing = store[sessionKey];
+        if (existing)
+            return existing;
+        const id = crypto.randomUUID();
+        store[sessionKey] = id;
+        await atomicWriteJson(this.storePath, store);
+        return id;
+    }
+}

package/dist/sessions.js

@@ -0,0 +1,18 @@
+import crypto from 'node:crypto';
+/**
+ * Generates a fresh session UUID for each invocation.
+ *
+ * Claude CLI >= 2.1.38 rejects `--session-id` if a JSONL transcript file
+ * already exists for that UUID ("Session ID already in use").  Since `-p`
+ * mode does not load previous conversation history from the JSONL anyway,
+ * reusing UUIDs provides no benefit.  Discoclaw maintains conversation
+ * continuity through its own rolling-summary and durable-memory systems.
+ */
+export class SessionManager {
+    constructor(_storePath) {
+        // storePath kept for backwards-compatible constructor signature.
+    }
+    async getOrCreate(_sessionKey) {
+        return crypto.randomUUID();
+    }
+}

package/dist/tasks/architecture-contract.js

@@ -0,0 +1,33 @@
+import { TASK_STATUSES } from './types.js';
+import { TASK_DIRECT_THREAD_ACTIONS, TASK_STORE_MUTATION_EVENTS, TASK_SYNC_TRIGGER_EVENTS, } from './sync-contract.js';
+const ALL_TASK_STATUSES = [...TASK_STATUSES];
+/**
+ * Track 1 freezes current runtime behavior:
+ * TaskStore status updates are currently permissive across all statuses.
+ * Future domain-level restrictions should be introduced via TaskService.
+ */
+export const TASK_STORE_ALLOWED_STATUS_TRANSITIONS = {
+    open: ALL_TASK_STATUSES,
+    in_progress: ALL_TASK_STATUSES,
+    blocked: ALL_TASK_STATUSES,
+    closed: ALL_TASK_STATUSES,
+};
+export function isTaskStoreStatusTransitionAllowed(from, to) {
+    return TASK_STORE_ALLOWED_STATUS_TRANSITIONS[from].includes(to);
+}
+export const TASK_STORE_MUTATION_EVENT_RULES = {
+    create: ['created'],
+    update: ['updated'],
+    close: ['closed'],
+    addLabel: ['labeled'],
+    removeLabel: ['updated'],
+    addLabelNoop: [],
+    removeLabelNoop: [],
+};
+export const TASK_ARCHITECTURE_CONTRACT = {
+    storeMutationEvents: TASK_STORE_MUTATION_EVENTS,
+    syncTriggerEvents: TASK_SYNC_TRIGGER_EVENTS,
+    directThreadLifecycleActions: TASK_DIRECT_THREAD_ACTIONS,
+    statusTransitions: TASK_STORE_ALLOWED_STATUS_TRANSITIONS,
+    mutationEventRules: TASK_STORE_MUTATION_EVENT_RULES,
+};

package/dist/tasks/architecture-contract.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TaskStore } from './store.js';
+import { TASK_STATUSES } from './types.js';
+import { TASK_ARCHITECTURE_CONTRACT, TASK_STORE_MUTATION_EVENT_RULES, isTaskStoreStatusTransitionAllowed, } from './architecture-contract.js';
+import { wireTaskStoreSyncTriggers } from './task-sync.js';
+import { withDirectTaskLifecycle } from './task-lifecycle.js';
+function makeStore() {
+    return new TaskStore({ prefix: 'ws' });
+}
+describe('task architecture contract', () => {
+    it('freezes permissive TaskStore status transitions across all statuses', () => {
+        for (const from of TASK_STATUSES) {
+            for (const to of TASK_STATUSES) {
+                expect(isTaskStoreStatusTransitionAllowed(from, to)).toBe(true);
+            }
+        }
+    });
+    it('keeps stable mutation/sync ownership contract sets', () => {
+        expect(TASK_ARCHITECTURE_CONTRACT.storeMutationEvents).toEqual([
+            'created',
+            'updated',
+            'closed',
+            'labeled',
+        ]);
+        expect(TASK_ARCHITECTURE_CONTRACT.syncTriggerEvents).toEqual([
+            'updated',
+            'closed',
+            'labeled',
+        ]);
+        expect(TASK_ARCHITECTURE_CONTRACT.directThreadLifecycleActions).toEqual([
+            'taskCreate',
+            'taskUpdate',
+            'taskClose',
+        ]);
+    });
+});
+describe('TaskStore characterization', () => {
+    it('allows status transitions in both directions via update', () => {
+        const store = makeStore();
+        const task = store.create({ title: 'Refactor tasks subsystem' });
+        const transitions = [];
+        store.on('updated', (next, prev) => {
+            transitions.push([prev.status, next.status]);
+        });
+        store.update(task.id, { status: 'closed' });
+        store.update(task.id, { status: 'blocked' });
+        store.update(task.id, { status: 'open' });
+        expect(transitions).toEqual([
+            ['open', 'closed'],
+            ['closed', 'blocked'],
+            ['blocked', 'open'],
+        ]);
+    });
+    it('emits expected events for label mutations and no-op label operations', () => {
+        const store = makeStore();
+        const task = store.create({ title: 'Tag handling' });
+        const events = [];
+        store.on('labeled', () => events.push('labeled'));
+        store.on('updated', () => events.push('updated'));
+        store.addLabel(task.id, 'plan');
+        store.addLabel(task.id, 'plan');
+        store.removeLabel(task.id, 'missing');
+        store.removeLabel(task.id, 'plan');
+        expect(events).toEqual([
+            ...TASK_STORE_MUTATION_EVENT_RULES.addLabel,
+            ...TASK_STORE_MUTATION_EVENT_RULES.removeLabel,
+        ]);
+    });
+});
+describe('store-event sync trigger characterization', () => {
+    it('triggers sync for updated/closed/labeled only and skips direct-owned lifecycle updates', async () => {
+        const store = makeStore();
+        const syncCoordinator = { sync: vi.fn(async () => null) };
+        const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+        const wired = wireTaskStoreSyncTriggers({ forumId: 'forum-1', tagMap: {}, store }, syncCoordinator, log);
+        const task = store.create({ title: 'Lifecycle owner test' });
+        expect(syncCoordinator.sync).toHaveBeenCalledTimes(0);
+        store.update(task.id, { title: 'Updated' });
+        store.addLabel(task.id, 'autotag');
+        store.close(task.id);
+        expect(syncCoordinator.sync).toHaveBeenCalledTimes(3);
+        await withDirectTaskLifecycle(task.id, async () => {
+            store.update(task.id, { title: 'Owned update' });
+        });
+        expect(syncCoordinator.sync).toHaveBeenCalledTimes(3);
+        wired.stop();
+        store.update(task.id, { title: 'After stop' });
+        expect(syncCoordinator.sync).toHaveBeenCalledTimes(3);
+    });
+});

package/dist/tasks/auto-tag.js

@@ -0,0 +1,50 @@
+/**
+ * Use an AI model to classify a task into 1-3 forum tags from the available
+ * set. Returns an array of valid tag names (silently drops unknown ones).
+ */
+export async function autoTagTask(runtime, title, description, availableTags, opts) {
+    if (availableTags.length === 0)
+        return [];
+    const tagList = availableTags.join(', ');
+    const prompt = `Classify this task into 1-3 tags from the following list. ` +
+        `Reply with ONLY comma-separated tag names, nothing else.\n\n` +
+        `Available tags: ${tagList}\n\n` +
+        `Title: ${title}\n` +
+        (description ? `Description: ${description.slice(0, 500)}\n` : '');
+    let finalText = '';
+    let deltaText = '';
+    const modelResolver = opts?.modelResolver ?? ((model) => model);
+    for await (const evt of runtime.invoke({
+        prompt,
+        model: modelResolver(opts?.model ?? 'fast', runtime.id),
+        cwd: opts?.cwd ?? '.',
+        timeoutMs: opts?.timeoutMs ?? 15_000,
+        tools: [],
+    })) {
+        if (evt.type === 'text_final' && typeof evt.text === 'string') {
+            finalText = evt.text;
+        }
+        else if (evt.type === 'text_delta' && typeof evt.text === 'string') {
+            deltaText += evt.text;
+        }
+        else if (evt.type === 'error') {
+            return [];
+        }
+    }
+    const output = (finalText || deltaText).trim();
+    if (!output)
+        return [];
+    const tagSet = new Set(availableTags.map((tag) => tag.toLowerCase()));
+    const candidates = output.split(/[,\n]+/).map((tag) => tag.trim()).filter(Boolean);
+    const result = [];
+    for (const candidate of candidates) {
+        // Find the original-cased tag name.
+        const match = availableTags.find((tag) => tag.toLowerCase() === candidate.toLowerCase());
+        if (match && tagSet.has(candidate.toLowerCase())) {
+            result.push(match);
+        }
+        if (result.length >= 3)
+            break;
+    }
+    return result;
+}

package/dist/tasks/auto-tag.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+import { autoTagTask } from './auto-tag.js';
+function makeMockRuntime(output) {
+    return {
+        id: 'other',
+        capabilities: new Set(),
+        async *invoke() {
+            yield { type: 'text_final', text: output };
+        },
+    };
+}
+function makeMockErrorRuntime() {
+    return {
+        id: 'other',
+        capabilities: new Set(),
+        async *invoke() {
+            yield { type: 'error', message: 'fail' };
+        },
+    };
+}
+const TAGS = ['feature', 'bug', 'personal', 'work', 'urgent'];
+describe('autoTagTask', () => {
+    it('returns valid tags from AI output', async () => {
+        const runtime = makeMockRuntime('feature, personal');
+        const result = await autoTagTask(runtime, 'Add login', 'New feature', TAGS);
+        expect(result).toEqual(['feature', 'personal']);
+    });
+    it('drops unknown tags silently', async () => {
+        const runtime = makeMockRuntime('feature, nonexistent, bug');
+        const result = await autoTagTask(runtime, 'Fix crash', '', TAGS);
+        expect(result).toEqual(['feature', 'bug']);
+    });
+    it('limits to 3 tags', async () => {
+        const runtime = makeMockRuntime('feature, bug, personal, work, urgent');
+        const result = await autoTagTask(runtime, 'Big task', '', TAGS);
+        expect(result).toHaveLength(3);
+    });
+    it('handles case-insensitive matching', async () => {
+        const runtime = makeMockRuntime('Feature, BUG');
+        const result = await autoTagTask(runtime, 'Test', '', TAGS);
+        expect(result).toEqual(['feature', 'bug']);
+    });
+    it('returns empty on runtime error', async () => {
+        const runtime = makeMockErrorRuntime();
+        const result = await autoTagTask(runtime, 'Test', '', TAGS);
+        expect(result).toEqual([]);
+    });
+    it('returns empty when no available tags', async () => {
+        const runtime = makeMockRuntime('feature');
+        const result = await autoTagTask(runtime, 'Test', '', []);
+        expect(result).toEqual([]);
+    });
+    it('handles empty AI output', async () => {
+        const runtime = makeMockRuntime('');
+        const result = await autoTagTask(runtime, 'Test', '', TAGS);
+        expect(result).toEqual([]);
+    });
+    it('uses injected model resolver when provided', async () => {
+        const runtime = makeMockRuntime('feature');
+        const resolve = vi.fn((model) => `resolved-${model}`);
+        await autoTagTask(runtime, 'Test', '', TAGS, { model: 'fast', modelResolver: resolve });
+        expect(resolve).toHaveBeenCalledWith('fast', runtime.id);
+    });
+});

package/dist/tasks/bd-cli.js

@@ -0,0 +1,164 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { execa } from 'execa';
+export { buildTaskContextSummary } from './context-summary.js';
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const BD_BIN = process.env.BD_BIN || 'bd';
+// ---------------------------------------------------------------------------
+// Legacy status normalization
+// ---------------------------------------------------------------------------
+/** Map removed statuses to their replacement. */
+const LEGACY_STATUS_MAP = {
+    done: 'closed',
+    tombstone: 'closed',
+};
+/** Normalize legacy task statuses (`done`, `tombstone`) → `closed`. */
+export function normalizeTaskData(task) {
+    const mapped = LEGACY_STATUS_MAP[task.status];
+    if (mapped)
+        return { ...task, status: mapped };
+    return task;
+}
+// ---------------------------------------------------------------------------
+// JSON parsing helper
+// ---------------------------------------------------------------------------
+/**
+ * Parse bd CLI JSON output. Handles:
+ *   - Array output (list, show)
+ *   - Single-object output (create)
+ *   - Markdown-fenced JSON (```json ... ```)
+ *   - Empty / error output
+ */
+export function parseBdJson(stdout) {
+    let text = stdout.trim();
+    if (!text)
+        return [];
+    // Strip markdown fences if present.
+    text = text.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '');
+    text = text.trim();
+    if (!text)
+        return [];
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed))
+        return parsed;
+    if (parsed && typeof parsed === 'object') {
+        // bd returns { error: "..." } on failures.
+        if ('error' in parsed && Object.keys(parsed).length === 1) {
+            throw new Error(String(parsed.error));
+        }
+        return [parsed];
+    }
+    return [];
+}
+// ---------------------------------------------------------------------------
+// Pre-flight check
+// ---------------------------------------------------------------------------
+/** Check whether the bd CLI binary is available. */
+export async function checkBdAvailable() {
+    try {
+        const result = await execa(BD_BIN, ['--version'], { reject: false });
+        if (result.exitCode === 0) {
+            return { available: true, version: result.stdout.trim() || undefined };
+        }
+        return { available: false };
+    }
+    catch {
+        return { available: false };
+    }
+}
+/**
+ * Verify the legacy bd database at `cwd` is initialized with an issue_prefix.
+ * Without a prefix, bd silently falls through to the global daemon registry
+ * and may write to a completely different instance's database.
+ *
+ * If the prefix is missing, attempt to auto-set it from the data directory name.
+ * Returns the detected prefix or null if the database cannot be reached.
+ */
+export async function ensureBdDatabaseReady(cwd) {
+    const dbPath = path.resolve(cwd, '.beads', 'beads.db');
+    try {
+        const result = await execa(BD_BIN, ['--db', dbPath, '--no-daemon', 'config', 'get', 'issue_prefix'], {
+            cwd,
+            reject: false,
+        });
+        const output = result.stdout.trim();
+        // bd config get returns "key (not set)" when unset, or just the value when set.
+        if (result.exitCode === 0 && output && !output.includes('(not set)')) {
+            return { ready: true, prefix: output };
+        }
+        // Prefix not set — auto-initialize from directory name.
+        // Resolve symlinks so that e.g. code/discoclaw/workspace → discoclaw-data/workspace
+        // derives "data" from the real target, not "dc" from the symlink parent.
+        const realCwd = await fs.realpath(cwd);
+        const dirName = path.basename(path.resolve(realCwd, '..'));
+        // Derive a short prefix: "discoclaw-personal" → "personal", "discoclaw-data" → "data", fallback to "dc"
+        const prefix = dirName.replace(/^discoclaw-?/, '').replace(/[^a-z0-9]/gi, '') || 'dc';
+        const setResult = await execa(BD_BIN, ['--db', dbPath, '--no-daemon', 'config', 'set', 'issue_prefix', prefix], {
+            cwd,
+            reject: false,
+        });
+        if (setResult.exitCode === 0) {
+            return { ready: true, prefix };
+        }
+        return { ready: false };
+    }
+    catch {
+        return { ready: false };
+    }
+}
+// ---------------------------------------------------------------------------
+// bd CLI wrappers
+// ---------------------------------------------------------------------------
+async function runBd(args, cwd) {
+    // Pin bd to the exact database for this workspace. Without this, bd's
+    // auto-discovery walks up parent directories and may connect to a daemon
+    // belonging to a different discoclaw instance (e.g. dev vs personal).
+    const dbPath = path.resolve(cwd, '.beads', 'beads.db');
+    const pinnedArgs = ['--db', dbPath, '--no-daemon', ...args];
+    const result = await execa(BD_BIN, pinnedArgs, { cwd, reject: false });
+    if (result.exitCode !== 0) {
+        // Try to extract a structured error from JSON output.
+        const out = (result.stdout ?? '').trim();
+        if (out) {
+            try {
+                const parsed = JSON.parse(out);
+                if (parsed?.error)
+                    throw new Error(String(parsed.error));
+            }
+            catch (e) {
+                if (e instanceof SyntaxError) {
+                    // Not JSON — fall through.
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        const errText = (result.stderr ?? '').trim() || out || `bd exited with code ${result.exitCode}`;
+        throw new Error(errText);
+    }
+    return result.stdout;
+}
+/** List task items matching the given filters. */
+export async function bdList(params, cwd) {
+    const args = ['list', '--json'];
+    if (params.status === 'all') {
+        args.push('--all');
+        // The bd CLI applies a default limit of 50.  When fetching *all* tasks
+        // and no explicit limit was provided, pass --limit 0 to disable the cap.
+        if (params.limit == null)
+            args.push('--limit', '0');
+    }
+    else if (params.status) {
+        args.push('--status', params.status);
+    }
+    if (params.label)
+        args.push('--label', params.label);
+    if (params.limit != null)
+        args.push('--limit', String(params.limit));
+    const stdout = await runBd(args, cwd);
+    const items = parseBdJson(stdout);
+    return items.map(normalizeTaskData);
+}