brainclaw 1.14.0 → 1.16.0

package/dist/commands/mcp-write-memory.js

@@ -0,0 +1,451 @@
+/**
+ * MCP memory write-tool handlers.
+ *
+ * Extracted from mcp.ts (pln#622 PR4) — mechanical move of the note /
+ * quick-capture / compaction / memory-item mutation / candidate-harvest write
+ * handlers. Behavior is unchanged; each handler receives the tool-call payload
+ * plus a {@link McpWriteMemoryContext} carrying the model resolved once per
+ * write call plus the two mcp.ts-local helpers these handlers reference
+ * (session-id-from-env and the cross-project arg reader), passed by reference
+ * so this module never imports ./mcp.js (dependency-direction guard, PR1).
+ *
+ * @module
+ */
+import { writeCrossProjectSignal, resolveCrossProjectWritableTarget } from '../core/cross-project.js';
+import { appendAuditEntry } from '../core/audit.js';
+import { nowISO, generateId } from '../core/ids.js';
+import { buildOperationalIdentity } from '../core/identity.js';
+import { validateMcpInput, validateMcpField } from '../core/input-validation.js';
+import { deleteMemoryItem, updateMemoryItem } from '../core/operations/memory-mutation.js';
+import { assessMemoryPressure, buildCompactionTemplate, applyCompaction } from '../core/gc-semantic.js';
+import { createRuntimeNote } from './runtime-note.js';
+import { createCandidateFromInput } from './reflect.js';
+import { harvestCandidates } from './harvest.js';
+import { ensureTrust, scanMcpWriteText, appendSecurityWarnings } from './mcp-write-support.js';
+import { toolResponse, createToolErrorResponse, } from './mcp-contract.js';
+function scoreKeywordMatches(text, patterns) {
+    return patterns.reduce((score, pattern) => score + (pattern.test(text) ? 1 : 0), 0);
+}
+function classifyQuickCapture(text) {
+    const normalized = text.trim().toLowerCase();
+    const decisionPatterns = [
+        /\b(decide|decision|decided|prefer|preferred|policy|convention|standard|standardize|adopt|chosen|choose|settled on)\b/,
+        /\b(use|default to|go with|route through|switch to|migrate to|move to)\b/,
+        /^(use|prefer|adopt|standardize|route|switch|migrate)\b/,
+    ];
+    const trapPatterns = [
+        /\b(trap|warning|beware|avoid|never|don't|do not|risk|risky|gotcha|workaround)\b/,
+        /\b(bug|broken|breaks|failure|fails|failing|flaky|blocked|missing|crash|regression|timeout|deadlock|race condition|leak)\b/,
+        /\b(error|incident|problem|issue|hang|stuck|retry)\b/,
+    ];
+    const decisionScore = scoreKeywordMatches(normalized, decisionPatterns);
+    const trapScore = scoreKeywordMatches(normalized, trapPatterns);
+    if (decisionScore > 0 && trapScore > 0 && Math.abs(decisionScore - trapScore) <= 1) {
+        return {
+            target: 'note',
+            reason: 'ambiguous_keywords',
+            decisionScore,
+            trapScore,
+        };
+    }
+    if (trapScore >= 2 && trapScore >= decisionScore + 1) {
+        return {
+            target: 'trap',
+            reason: 'trap_keywords',
+            decisionScore,
+            trapScore,
+        };
+    }
+    if (decisionScore >= 2 && decisionScore >= trapScore + 1) {
+        return {
+            target: 'decision',
+            reason: 'decision_keywords',
+            decisionScore,
+            trapScore,
+        };
+    }
+    return {
+        target: 'note',
+        reason: decisionScore === trapScore && decisionScore > 0 ? 'ambiguous_keywords' : 'low_confidence',
+        decisionScore,
+        trapScore,
+    };
+}
+function formatQuickCaptureNoteText(text, context) {
+    if (!context) {
+        return text;
+    }
+    return `${text}\n\nContext: ${context}`;
+}
+// ── Handlers ─────────────────────────────────────────────────────────────
+export function handleBclawWriteNote(payload, ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const text = String(args.text ?? '');
+    const tags = args.tags ?? [];
+    const inputValidation = validateMcpInput(text, tags);
+    if (!inputValidation.ok) {
+        return { response: createToolErrorResponse('validation_error', inputValidation.errors[0]?.message ?? 'Invalid input', inputValidation.errors) };
+    }
+    const identity = resolved.identity;
+    // S2 (pln#623): scan write text on the MCP path, same control point as the
+    // CLI adapters. A strict-mode block refuses the write; warn-mode matches are
+    // surfaced on the response.
+    const scan = scanMcpWriteText(text, cwd);
+    if (scan.blockResponse)
+        return { response: scan.blockResponse };
+    // Cross-project push
+    const crossProjectTarget = ctx.getCrossProjectArg(args, 'crossProject', 'cross_project');
+    if (crossProjectTarget) {
+        try {
+            const opIdentity = buildOperationalIdentity(identity.agent_name, cwd, {
+                agentId: identity.agent_id,
+                sessionId: connectionSessionId,
+            });
+            const signal = writeCrossProjectSignal(resolveCrossProjectWritableTarget(crossProjectTarget, 'runtime_note', cwd), 'runtime_note', {
+                schema_version: 2,
+                id: generateId('runtime_note'),
+                agent: opIdentity.agent,
+                agent_id: opIdentity.agent_id,
+                project_id: opIdentity.project_id ?? '',
+                session_id: opIdentity.session_id,
+                text,
+                created_at: nowISO(),
+                tags,
+                visibility: 'shared',
+                host_id: opIdentity.host_id ?? '',
+                note_type: 'observation',
+            }, cwd);
+            return {
+                response: appendSecurityWarnings(toolResponse({
+                    content: [{ type: 'text', text: `✔ Cross-project runtime note signaled to '${signal.target_project.name}' [${signal.id}]` }],
+                    signal_id: signal.id,
+                    entity_type: signal.entity_type,
+                    note_id: signal.payload.id,
+                    target_project: signal.target_project.name,
+                    target_path: signal.target_project.path,
+                }), scan.warnings),
+            };
+        }
+        catch (e) {
+            return { response: createToolErrorResponse('validation_error', e instanceof Error ? e.message : String(e)) };
+        }
+    }
+    const result = createRuntimeNote(text, {
+        agent: identity.agent_name,
+        agentId: identity.agent_id,
+        tag: tags,
+        visibility: args.visibility ?? 'shared',
+        ttl: args.ttl,
+        autoReflect: args.autoReflect,
+        cwd,
+        sessionId: connectionSessionId,
+        model: ctx.currentModel,
+    }, false);
+    return {
+        response: appendSecurityWarnings(toolResponse({
+            content: [{ type: 'text', text: `✔ Note created [${result.noteId}]` }],
+            note_id: result.noteId,
+            session_id: result.sessionId,
+            auto_reflect_attempted: result.autoReflectAttempted,
+            detected_type: result.detectedType,
+            candidate_id: result.candidateId,
+            promoted_item_id: result.promotedItemId,
+            skip_reason: result.skipReason,
+        }), scan.warnings),
+        nextConnectionSessionId: ctx.explicitSessionIdFromEnv() ? undefined : result.sessionId,
+    };
+}
+export function handleBclawQuickCapture(payload, ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const text = String(args.text ?? '');
+    const inputValidation = validateMcpInput(text);
+    if (!inputValidation.ok) {
+        return { response: createToolErrorResponse('validation_error', inputValidation.errors[0]?.message ?? 'Invalid input', inputValidation.errors) };
+    }
+    // S2 (pln#623): scan the captured text (same control point as the CLI).
+    const scan = scanMcpWriteText(text, cwd);
+    if (scan.blockResponse)
+        return { response: scan.blockResponse };
+    const context = typeof args.context === 'string' ? args.context.trim() : undefined;
+    if (context) {
+        const contextCheck = validateMcpField(context, 'context');
+        if (!contextCheck.ok) {
+            return { response: createToolErrorResponse('validation_error', contextCheck.message) };
+        }
+    }
+    const identity = resolved.identity;
+    // Caller-asserted classification wins (pln#542): the calling agent
+    // declares decision/trap/constraint/note; keyword heuristics are the
+    // fallback when no type is given.
+    const assertedType = typeof args.type === 'string' ? args.type.trim().toLowerCase() : undefined;
+    let classification;
+    if (assertedType === 'decision' || assertedType === 'trap' || assertedType === 'constraint' || assertedType === 'note') {
+        classification = { target: assertedType, reason: 'caller_asserted', decisionScore: 0, trapScore: 0 };
+    }
+    else if (assertedType !== undefined) {
+        return { response: createToolErrorResponse('validation_error', `type must be one of: decision, trap, constraint, note (got '${assertedType}')`) };
+    }
+    else {
+        classification = classifyQuickCapture(text);
+    }
+    if (classification.target === 'note') {
+        const result = createRuntimeNote(formatQuickCaptureNoteText(text, context), {
+            agent: identity.agent_name,
+            agentId: identity.agent_id,
+            tag: ['quick-capture'],
+            visibility: 'shared',
+            cwd,
+            sessionId: connectionSessionId,
+            model: ctx.currentModel,
+        }, false);
+        return {
+            response: appendSecurityWarnings(toolResponse({
+                content: [{ type: 'text', text: `✔ Quick capture saved as runtime note [${result.noteId}]` }],
+                structuredContent: {
+                    classification: classification.target,
+                    classification_reason: classification.reason,
+                    decision_score: classification.decisionScore,
+                    trap_score: classification.trapScore,
+                    note_id: result.noteId,
+                    session_id: result.sessionId,
+                    context,
+                    next_actions: [
+                        { tool: 'bclaw_quick_capture', args: { text: '<same text>', type: 'decision' }, when: 'this was actually a durable decision/trap/constraint — re-capture with an asserted type' },
+                    ],
+                },
+            }), scan.warnings),
+            nextConnectionSessionId: ctx.explicitSessionIdFromEnv() ? undefined : result.sessionId,
+        };
+    }
+    const capture = createCandidateFromInput(text, classification.target, {
+        tag: ['quick-capture'],
+        author: identity.agent_name,
+        authorId: identity.agent_id,
+        sessionId: connectionSessionId,
+        source: 'mcp:quick-capture',
+        path: context,
+        cwd,
+    }, false, false, true);
+    const statusText = capture.writeThrough
+        ? `✔ Quick capture promoted as ${classification.target} [${capture.promotedItemId}]`
+        : `✔ Quick capture saved as ${classification.target} candidate [${capture.candidateId}]`;
+    const captureNextActions = capture.writeThrough
+        ? [
+            { tool: 'bclaw_get', args: { entity: classification.target, id: capture.promotedItemId }, when: 'to verify the promoted item' },
+        ]
+        : [
+            { tool: 'bclaw_get', args: { entity: 'candidate', id: capture.candidateId }, when: 'to review the pending candidate (contradiction metadata is advisory)' },
+        ];
+    return {
+        response: appendSecurityWarnings(toolResponse({
+            content: [{ type: 'text', text: statusText }],
+            structuredContent: {
+                classification: classification.target,
+                classification_reason: classification.reason,
+                decision_score: classification.decisionScore,
+                trap_score: classification.trapScore,
+                candidate_id: capture.candidateId,
+                promoted_item_id: capture.promotedItemId,
+                write_through: capture.writeThrough,
+                // Advisory only (cnd_abe61d68): contradictions are metadata on
+                // the candidate, never a promotion blocker.
+                contradiction_summary: capture.contradictionSummary,
+                contradictions_detected: capture.contradictionsDetected?.map((item) => ({
+                    severity: item.severity,
+                    reason: item.reason,
+                    conflicts_with: item.conflicts_with,
+                })),
+                context,
+                next_actions: captureNextActions,
+            },
+        }), scan.warnings),
+    };
+}
+export function handleBclawCompact(payload, _ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const archiveIds = args.archiveIds;
+    const isPhase2 = archiveIds && archiveIds.length > 0;
+    if (isPhase2) {
+        // Phase 2: apply compaction — archive specified items and create new memories
+        const result = applyCompaction({
+            archiveIds,
+            newItems: args.newItems,
+            author: resolved.identity?.agent_name,
+            authorId: resolved.identity?.agent_id,
+            cwd,
+        });
+        const lines = [];
+        lines.push(`✔ Compacted ${result.archived_count} item(s).`);
+        if (result.created_count > 0) {
+            lines.push(`Created ${result.created_count} new memory item(s): ${result.created_ids.join(', ')}`);
+        }
+        lines.push(`Backup: ${result.backup_path}`);
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: lines.join('\n') }],
+                ...result,
+            }),
+        };
+    }
+    // Phase 1: assess pressure and return compaction template
+    const assessment = assessMemoryPressure(cwd);
+    const maxItems = args.maxItems ?? 20;
+    const selected = assessment.eligible_items.slice(0, maxItems);
+    const template = selected.length > 0 ? buildCompactionTemplate(selected) : undefined;
+    const lines = [];
+    lines.push(`Memory pressure: ${assessment.pressure ? 'YES' : 'no'} (${assessment.done_plans} done plans, ${assessment.closed_handoffs} closed handoffs)`);
+    lines.push(`Thresholds: plans >= ${assessment.thresholds.plans}, handoffs >= ${assessment.thresholds.handoffs}`);
+    lines.push(`Eligible items: ${assessment.eligible_items.length}`);
+    if (template) {
+        lines.push('');
+        lines.push(template);
+    }
+    else {
+        lines.push('No items eligible for compaction.');
+    }
+    return {
+        response: toolResponse({
+            content: [{ type: 'text', text: lines.join('\n') }],
+            pressure: assessment.pressure,
+            done_plans: assessment.done_plans,
+            closed_handoffs: assessment.closed_handoffs,
+            eligible_count: assessment.eligible_items.length,
+            eligible_ids: selected.map(i => i.id),
+        }),
+    };
+}
+export function handleBclawDeleteMemory(payload, _ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const itemId = String(args.id ?? '').trim();
+    const itemType = String(args.type ?? '').trim();
+    if (!itemId)
+        return { response: createToolErrorResponse('validation_error', 'Missing required argument: id') };
+    if (!itemType)
+        return { response: createToolErrorResponse('validation_error', 'Missing required argument: type') };
+    if (!['constraint', 'decision', 'trap'].includes(itemType)) {
+        return { response: createToolErrorResponse('validation_error', `Invalid type: ${itemType}`) };
+    }
+    try {
+        const result = deleteMemoryItem(itemId, itemType, cwd);
+        appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'delete', item_id: itemId, item_type: itemType }, cwd);
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: `✔ Deleted [${itemId}] (${itemType})` }],
+                deleted_id: result.deletedId,
+                item_type: result.itemType,
+                store_level: result.storeRole,
+            }),
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('not found')) {
+            return { response: createToolErrorResponse('not_found', msg) };
+        }
+        return { response: createToolErrorResponse('operation_error', msg) };
+    }
+}
+export function handleBclawUpdateMemory(payload, _ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const itemId = String(args.id ?? '').trim();
+    const itemType = String(args.type ?? '').trim();
+    const newText = args.text ? String(args.text).trim() : undefined;
+    const newTags = Array.isArray(args.tags) ? args.tags.map((t) => String(t).trim()) : undefined;
+    const newStatus = args.status ? String(args.status).trim() : undefined;
+    const moveToStore = args.moveToStore ? String(args.moveToStore).trim() : undefined;
+    if (!itemId)
+        return { response: createToolErrorResponse('validation_error', 'Missing required argument: id') };
+    if (!itemType)
+        return { response: createToolErrorResponse('validation_error', 'Missing required argument: type') };
+    if (!['constraint', 'decision', 'trap'].includes(itemType)) {
+        return { response: createToolErrorResponse('validation_error', `Invalid type for update: ${itemType}`) };
+    }
+    if (!newText && !newTags && !newStatus && !moveToStore) {
+        return { response: createToolErrorResponse('validation_error', 'At least one of text, tags, status, or moveToStore must be provided') };
+    }
+    if (moveToStore && !['local', 'repo', 'workspace', 'user'].includes(moveToStore)) {
+        return { response: createToolErrorResponse('validation_error', `Invalid moveToStore target: ${moveToStore}`) };
+    }
+    if (newStatus && itemType !== 'trap') {
+        return { response: createToolErrorResponse('validation_error', 'status updates are only supported for traps') };
+    }
+    if (newStatus && !['active', 'resolved', 'expired'].includes(newStatus)) {
+        return { response: createToolErrorResponse('validation_error', `Invalid trap status: ${newStatus}`) };
+    }
+    try {
+        const result = updateMemoryItem({
+            id: itemId,
+            type: itemType,
+            text: newText,
+            tags: newTags,
+            status: newStatus,
+            moveToStore: moveToStore,
+        }, cwd);
+        appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'update', item_id: itemId, item_type: itemType }, cwd);
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: `✔ Updated [${itemId}] (${itemType})` }],
+                updated_id: result.updatedId,
+                item_type: result.itemType,
+                previous_store: result.previousStore,
+                new_store: result.newStore,
+            }),
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('not found')) {
+            return { response: createToolErrorResponse('not_found', msg) };
+        }
+        return { response: createToolErrorResponse('operation_error', msg) };
+    }
+}
+export function handleBclawHarvestCandidates(payload, _ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const resolvedIdentity = resolved.identity;
+    const worktreePaths = Array.isArray(args.worktreePaths) ? args.worktreePaths : undefined;
+    const dryRun = args.dryRun === true;
+    const harvestResult = harvestCandidates({
+        worktreePaths,
+        dryRun,
+        cwd,
+        agent: resolvedIdentity.agent_name,
+    });
+    const dryTag = dryRun ? ' (dry-run)' : '';
+    const summary = `✔ Harvest complete${dryTag}: ${harvestResult.harvested.length} imported, ${harvestResult.skipped.length} skipped, ${harvestResult.errors.length} error(s).`;
+    return {
+        response: toolResponse({
+            content: [{ type: 'text', text: summary }],
+            harvested: harvestResult.harvested.length,
+            skipped: harvestResult.skipped.length,
+            errors: harvestResult.errors,
+            candidates: harvestResult.harvested.map((c) => ({ id: c.id, type: c.type })),
+            dry_run: dryRun,
+        }),
+    };
+}
+//# sourceMappingURL=mcp-write-memory.js.map

package/dist/commands/mcp-write-sequences.js

@@ -0,0 +1,116 @@
+/**
+ * MCP sequence write-tool handlers.
+ *
+ * Extracted from mcp.ts (pln#622 PR4) — mechanical move of the
+ * create / update / delete sequence write handlers. Behavior is unchanged;
+ * each handler receives the tool-call payload plus a
+ * {@link McpWriteSequencesContext} carrying the model resolved once per write
+ * call at the assembly point.
+ *
+ * This module must never import ./mcp.js (dependency-direction guard,
+ * pln#622 PR1).
+ *
+ * @module
+ */
+import { appendAuditEntry } from '../core/audit.js';
+import { createSequence, updateSequence, deleteSequence } from '../core/sequence.js';
+import { ensureTrust } from './mcp-write-support.js';
+import { toolResponse, createToolErrorResponse, } from './mcp-contract.js';
+export function handleBclawCreateSequence(payload, ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const sequenceName = String(args.name ?? '').trim();
+    if (!sequenceName) {
+        return { response: createToolErrorResponse('validation_error', 'Missing required argument: name') };
+    }
+    try {
+        const result = createSequence({
+            name: sequenceName,
+            description: args.description,
+            status: args.status,
+            owner: args.owner,
+            items: Array.isArray(args.items) ? args.items : [],
+            tags: Array.isArray(args.tags) ? args.tags : [],
+            author: resolved.identity.agent_name,
+            authorId: resolved.identity.agent_id,
+            model: ctx.currentModel,
+        }, cwd);
+        appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'create', item_id: result.id, item_type: 'sequence' }, cwd);
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: `✔ Sequence added: [${result.id}] ${sequenceName}` }],
+                sequence_id: result.id,
+            }),
+        };
+    }
+    catch (err) {
+        return { response: createToolErrorResponse('operation_error', err instanceof Error ? err.message : String(err)) };
+    }
+}
+export function handleBclawUpdateSequence(payload, _ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'contributor', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const sequenceId = String(args.id ?? '').trim();
+    if (!sequenceId) {
+        return { response: createToolErrorResponse('validation_error', 'Missing required argument: id') };
+    }
+    try {
+        const result = updateSequence({
+            id: sequenceId,
+            name: args.name,
+            description: args.description,
+            status: args.status,
+            owner: args.owner,
+            items: Array.isArray(args.items) ? args.items : undefined,
+            tags: Array.isArray(args.tags) ? args.tags : undefined,
+        }, cwd);
+        appendAuditEntry({ actor: resolved.identity.agent_name, actor_id: resolved.identity.agent_id, action: 'update', item_id: result.id, item_type: 'sequence' }, cwd);
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: `✔ Sequence updated: [${result.id}] ${result.name}` }],
+                sequence_id: result.id,
+                status: result.status,
+            }),
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('not found')) {
+            return { response: createToolErrorResponse('not_found', msg) };
+        }
+        return { response: createToolErrorResponse('operation_error', msg) };
+    }
+}
+export function handleBclawDeleteSequence(payload, _ctx) {
+    const { args, cwd, connectionSessionId } = payload;
+    const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
+    if (resolved.error) {
+        return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };
+    }
+    const dsqId = String(args.id ?? '').trim();
+    if (!dsqId)
+        return { response: createToolErrorResponse('validation_error', 'Missing required argument: id') };
+    try {
+        const result = deleteSequence(dsqId, cwd);
+        return {
+            response: toolResponse({
+                content: [{ type: 'text', text: `✔ Sequence deleted: [${result.id}] ${result.name}` }],
+                sequence_id: result.id,
+            }),
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('not found')) {
+            return { response: createToolErrorResponse('not_found', msg) };
+        }
+        return { response: createToolErrorResponse('operation_error', msg) };
+    }
+}
+//# sourceMappingURL=mcp-write-sequences.js.map