brainfile 0.18.0

package/dist/commands/contract.js

@@ -0,0 +1,715 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACT_GRAPH_HELP = exports.CONTRACT_ACTIVATE_HELP = exports.CONTRACT_ATTACH_HELP = exports.CONTRACT_VALIDATE_HELP = exports.CONTRACT_DELIVER_HELP = exports.CONTRACT_PICKUP_HELP = exports.CONTRACT_COMMAND_HELP = void 0;
+exports.parseContractGraphArgs = parseContractGraphArgs;
+exports.contractGraphCommand = contractGraphCommand;
+exports.contractPickupCommand = contractPickupCommand;
+exports.contractDeliverCommand = contractDeliverCommand;
+exports.contractValidateCommand = contractValidateCommand;
+exports.contractAttachCommand = contractAttachCommand;
+exports.contractActivateCommand = contractActivateCommand;
+const contractRunner_1 = require("../lib/contractRunner");
+const logger_1 = require("../utils/logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("@brainfile/core");
+const cli_error_1 = require("../utils/cli-error");
+const contractSpec_1 = require("../utils/contractSpec");
+const brainfile_path_1 = require("../utils/brainfile-path");
+const v2_detect_1 = require("../utils/v2-detect");
+const command_lint_1 = require("../validation/command-lint");
+exports.CONTRACT_COMMAND_HELP = `
+Workflow (PM → Agent → PM):
+  1) PM creates a task with a contract:
+     brainfile add -c todo -t "Feature" --assignee codex --with-contract --deliverable "file:src/feature.ts:Impl"
+
+  2) Agent picks it up (status → in_progress):
+     brainfile contract pickup -t task-123
+
+  3) Agent delivers (status → delivered):
+     brainfile contract deliver -t task-123
+
+  4) PM validates (status → done | failed):
+     brainfile contract validate -t task-123
+
+Contract metrics are tracked on the task file under contract.metrics.
+
+Find available contracts:
+  brainfile list --contract ready
+`.trimEnd();
+exports.CONTRACT_PICKUP_HELP = `
+Examples:
+  brainfile contract pickup -t task-123
+  brainfile contract pickup -t task-123 -f .brainfile/brainfile.md
+`.trimEnd();
+exports.CONTRACT_DELIVER_HELP = `
+Examples:
+  brainfile contract deliver -t task-123
+`.trimEnd();
+exports.CONTRACT_VALIDATE_HELP = `
+Examples:
+  brainfile contract validate -t task-123
+`.trimEnd();
+exports.CONTRACT_ATTACH_HELP = `
+Examples:
+  brainfile contract attach -t task-123 \\
+    --deliverable "file:src/feature.ts:Implementation" \\
+    --validation "npm test" \\
+    --constraint "Make minimal changes"
+`.trimEnd();
+exports.CONTRACT_ACTIVATE_HELP = `
+Examples:
+  # Activate a single contract (draft → ready)
+  brainfile contract activate -t task-123
+
+  # Activate all draft contracts whose parent is epic-1
+  brainfile contract activate --parent epic-1
+`.trimEnd();
+exports.CONTRACT_GRAPH_HELP = `
+Examples:
+  brainfile contract graph \\
+    --task research-1 --deliverable "file:docs/findings.md" \\
+    --task impl-1 --deliverable "file:src/bridge.ts" --depends-on research-1 \\
+    --task test-1 --deliverable "test:src/tests/bridge.test.ts" --depends-on impl-1 \\
+    --ready
+
+  brainfile contract graph --show
+`.trimEnd();
+class MissingDependencyError extends Error {
+    constructor(taskId, dependencyId) {
+        super(`Task ${taskId} depends on missing task ${dependencyId}`);
+        this.name = 'MissingDependencyError';
+        this.taskId = taskId;
+        this.dependencyId = dependencyId;
+    }
+}
+class DependencyCycleError extends Error {
+    constructor(cycle) {
+        super(`Dependency cycle detected: ${cycle.join(' -> ')}`);
+        this.name = 'DependencyCycleError';
+        this.cycle = cycle;
+    }
+}
+function isUnsafeTaskId(taskId) {
+    const trimmed = taskId.trim();
+    if (!trimmed || trimmed !== taskId) {
+        return true;
+    }
+    if (taskId === '.' || taskId === '..') {
+        return true;
+    }
+    return /[\\/]/.test(taskId);
+}
+function normalizeDependencyIds(dependsOn) {
+    if (!Array.isArray(dependsOn)) {
+        return undefined;
+    }
+    const normalized = [...new Set(dependsOn.map((value) => value.trim()).filter(Boolean))];
+    return normalized.length > 0 ? normalized : undefined;
+}
+function taskDependsOn(task) {
+    const rawDependsOn = task?.dependsOn;
+    if (!Array.isArray(rawDependsOn)) {
+        return undefined;
+    }
+    return rawDependsOn.filter((value) => typeof value === 'string');
+}
+function topologicalSort(nodes) {
+    const dependenciesById = new Map();
+    for (const node of nodes) {
+        if (dependenciesById.has(node.id)) {
+            throw new Error(`Duplicate graph node: ${node.id}`);
+        }
+        dependenciesById.set(node.id, normalizeDependencyIds(node.dependsOn ? [...node.dependsOn] : undefined) ?? []);
+    }
+    const state = new Map();
+    const stack = [];
+    const order = [];
+    const visit = (taskId) => {
+        const currentState = state.get(taskId);
+        if (currentState === 'done') {
+            return;
+        }
+        if (currentState === 'visiting') {
+            const cycleStart = stack.indexOf(taskId);
+            const cycle = cycleStart >= 0
+                ? [...stack.slice(cycleStart), taskId]
+                : [taskId, taskId];
+            throw new DependencyCycleError(cycle);
+        }
+        state.set(taskId, 'visiting');
+        stack.push(taskId);
+        for (const dependencyId of dependenciesById.get(taskId) ?? []) {
+            if (!dependenciesById.has(dependencyId)) {
+                throw new MissingDependencyError(taskId, dependencyId);
+            }
+            visit(dependencyId);
+        }
+        stack.pop();
+        state.set(taskId, 'done');
+        order.push(taskId);
+    };
+    for (const taskId of dependenciesById.keys()) {
+        visit(taskId);
+    }
+    return order;
+}
+function boardTasks(board) {
+    return board.columns.flatMap((column) => column.tasks);
+}
+function validateTaskDependencyGraph(tasks) {
+    try {
+        return topologicalSort(tasks.map((task) => ({
+            id: task.id,
+            dependsOn: taskDependsOn(task),
+        })));
+    }
+    catch (error) {
+        if (error instanceof DependencyCycleError || error instanceof MissingDependencyError) {
+            throw (0, cli_error_1.validationError)(error.message);
+        }
+        throw error;
+    }
+}
+function renderTaskDependencyGraph(tasks) {
+    if (tasks.length === 0) {
+        return '(no active tasks)';
+    }
+    const order = validateTaskDependencyGraph(tasks);
+    const taskById = new Map(tasks.map((task) => [task.id, task]));
+    return order
+        .map((taskId) => {
+        const dependsOn = normalizeDependencyIds(taskDependsOn(taskById.get(taskId)));
+        return dependsOn && dependsOn.length > 0
+            ? `${dependsOn.join(', ')} -> ${taskId}`
+            : taskId;
+    })
+        .join('\n');
+}
+function updateBoardTask(board, taskId, updater) {
+    let found = false;
+    const columns = board.columns.map((column) => ({
+        ...column,
+        tasks: column.tasks.map((task) => {
+            if (task.id !== taskId) {
+                return task;
+            }
+            found = true;
+            return updater(task);
+        }),
+    }));
+    if (!found) {
+        throw (0, cli_error_1.operationFailed)(`Task not found: ${taskId}`);
+    }
+    return { ...board, columns };
+}
+function applyGraphTaskUpdate(task, spec, ready, now) {
+    let contract;
+    try {
+        contract = (0, contractSpec_1.buildContract)({
+            deliverableSpecs: spec.deliverable,
+            validationCommands: spec.validation,
+            constraints: spec.constraint,
+            status: ready ? 'ready' : 'draft',
+        });
+    }
+    catch (error) {
+        throw (0, cli_error_1.validationError)(error.message);
+    }
+    const nextTask = {
+        ...task,
+        contract,
+        updatedAt: now,
+    };
+    if (spec.dependsOn !== undefined) {
+        const normalized = normalizeDependencyIds(spec.dependsOn);
+        if (normalized) {
+            nextTask.dependsOn = normalized;
+        }
+        else {
+            delete nextTask.dependsOn;
+        }
+    }
+    return nextTask;
+}
+function ensureUniqueGraphTasks(specs) {
+    const seen = new Set();
+    for (const spec of specs) {
+        if (seen.has(spec.task)) {
+            throw (0, cli_error_1.validationError)(`Duplicate task in graph input: ${spec.task}`);
+        }
+        seen.add(spec.task);
+    }
+}
+function loadActiveTasks(filePath) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        return (0, core_1.readTasksDir)(dirs.boardDir).map((doc) => doc.task);
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = core_1.Brainfile.parseWithErrors(content);
+    if (!parsed.board) {
+        throw (0, cli_error_1.operationFailed)(parsed.error || 'Failed to parse brainfile');
+    }
+    return boardTasks(parsed.board);
+}
+function parseContractGraphArgs(args) {
+    const options = {
+        file: 'brainfile.md',
+        tasks: [],
+    };
+    let currentTask;
+    const readValue = (index, flag) => {
+        const value = args[index + 1];
+        if (value === undefined) {
+            throw (0, cli_error_1.validationError)(`Missing value for ${flag}`);
+        }
+        return value;
+    };
+    const pushValue = (spec, key, value, flag) => {
+        if (!spec) {
+            throw (0, cli_error_1.validationError)(`${flag} must follow a --task declaration`);
+        }
+        const existing = spec[key];
+        if (!existing) {
+            spec[key] = [value];
+            return;
+        }
+        spec[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        switch (token) {
+            case '-f':
+            case '--file':
+                options.file = readValue(index, token);
+                index += 1;
+                break;
+            case '--ready':
+                options.ready = true;
+                break;
+            case '--show':
+                options.show = true;
+                break;
+            case '-t':
+            case '--task': {
+                const task = readValue(index, token);
+                currentTask = { task };
+                options.tasks.push(currentTask);
+                index += 1;
+                break;
+            }
+            case '--deliverable':
+                pushValue(currentTask, 'deliverable', readValue(index, token), token);
+                index += 1;
+                break;
+            case '--validation':
+                pushValue(currentTask, 'validation', readValue(index, token), token);
+                index += 1;
+                break;
+            case '--constraint':
+                pushValue(currentTask, 'constraint', readValue(index, token), token);
+                index += 1;
+                break;
+            case '--depends-on':
+                if (!currentTask) {
+                    throw (0, cli_error_1.validationError)('--depends-on must follow a --task declaration');
+                }
+                currentTask.dependsOn = [...(currentTask.dependsOn ?? []), readValue(index, token)];
+                index += 1;
+                break;
+            default:
+                throw (0, cli_error_1.validationError)(`Unknown contract graph flag: ${token}`);
+        }
+    }
+    if (options.show && options.tasks.length > 0) {
+        throw (0, cli_error_1.validationError)('--show cannot be combined with task graph mutations');
+    }
+    if (!options.show && options.tasks.length === 0) {
+        throw (0, cli_error_1.missingRequired)('--task', 'brainfile contract graph --task <task-id> [graph options]');
+    }
+    return options;
+}
+function contractGraphCommand(options, logger = logger_1.defaultLogger) {
+    const filePath = (0, brainfile_path_1.resolveCliBrainfilePath)(options.file);
+    if (!fs.existsSync(filePath)) {
+        throw (0, cli_error_1.operationFailed)(`File not found: ${filePath}`);
+    }
+    if (options.show) {
+        const activeTasks = loadActiveTasks(filePath);
+        const graph = renderTaskDependencyGraph(activeTasks);
+        logger.log(graph);
+        return { success: true, attached: [], order: validateTaskDependencyGraph(activeTasks), graph };
+    }
+    const specs = options.tasks ?? [];
+    ensureUniqueGraphTasks(specs);
+    const now = new Date().toISOString();
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        const docs = (0, core_1.readTasksDir)(dirs.boardDir);
+        const docById = new Map(docs.map((doc) => [doc.task.id, doc]));
+        for (const spec of specs) {
+            if (isUnsafeTaskId(spec.task)) {
+                throw (0, cli_error_1.operationFailed)(`Invalid task ID: ${spec.task}`);
+            }
+            if (!docById.has(spec.task)) {
+                throw (0, cli_error_1.operationFailed)(`Task not found: ${spec.task}`);
+            }
+        }
+        const nextTasks = new Map(docs.map((doc) => [doc.task.id, { ...doc.task }]));
+        for (const spec of specs) {
+            nextTasks.set(spec.task, applyGraphTaskUpdate(nextTasks.get(spec.task), spec, Boolean(options.ready), now));
+        }
+        const order = validateTaskDependencyGraph([...nextTasks.values()]);
+        const graph = renderTaskDependencyGraph([...nextTasks.values()]);
+        for (const taskId of order) {
+            if (!specs.some((spec) => spec.task === taskId)) {
+                continue;
+            }
+            const doc = docById.get(taskId);
+            (0, core_1.writeTaskFile)(doc.filePath, nextTasks.get(taskId), doc.body);
+        }
+        logger.log(`Contract graph attached (${options.ready ? 'ready' : 'draft'}): ${specs.map((spec) => spec.task).join(', ')}`);
+        return {
+            success: true,
+            attached: specs.map((spec) => spec.task),
+            order,
+            graph,
+        };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = core_1.Brainfile.parseWithErrors(content);
+    if (!parsed.board) {
+        throw (0, cli_error_1.operationFailed)(parsed.error || 'Failed to parse brainfile');
+    }
+    let board = parsed.board;
+    for (const spec of specs) {
+        if (!(0, core_1.findTaskById)(board, spec.task)) {
+            throw (0, cli_error_1.operationFailed)(`Task not found: ${spec.task}`);
+        }
+        board = updateBoardTask(board, spec.task, (task) => applyGraphTaskUpdate(task, spec, Boolean(options.ready), now));
+    }
+    const order = validateTaskDependencyGraph(boardTasks(board));
+    const graph = renderTaskDependencyGraph(boardTasks(board));
+    fs.writeFileSync(filePath, core_1.Brainfile.serialize(board), 'utf-8');
+    logger.log(`Contract graph attached (${options.ready ? 'ready' : 'draft'}): ${specs.map((spec) => spec.task).join(', ')}`);
+    return {
+        success: true,
+        attached: specs.map((spec) => spec.task),
+        order,
+        graph,
+    };
+}
+function contractPickupCommand(options, logger = logger_1.defaultLogger) {
+    if (!options.task) {
+        throw (0, cli_error_1.missingRequired)('--task', 'brainfile contract pickup --task <task-id> [--file <path>]');
+    }
+    const filePath = (0, brainfile_path_1.resolveCliBrainfilePath)(options.file);
+    const result = (0, contractRunner_1.pickupContract)({ filePath, taskId: options.task });
+    if ('error' in result) {
+        throw (0, cli_error_1.operationFailed)(result.error);
+    }
+    logger.log(result.markdown);
+    return { success: true, markdown: result.markdown };
+}
+function contractDeliverCommand(options, logger = logger_1.defaultLogger) {
+    if (!options.task) {
+        throw (0, cli_error_1.missingRequired)('--task', 'brainfile contract deliver --task <task-id> [--file <path>]');
+    }
+    const filePath = (0, brainfile_path_1.resolveCliBrainfilePath)(options.file);
+    const result = (0, contractRunner_1.deliverContract)({ filePath, taskId: options.task });
+    if ('error' in result) {
+        throw (0, cli_error_1.operationFailed)(result.error);
+    }
+    logger.log(`Contract delivered: ${options.task}`);
+    return { success: true };
+}
+function contractValidateCommand(options, logger = logger_1.defaultLogger) {
+    if (!options.task) {
+        throw (0, cli_error_1.missingRequired)('--task', 'brainfile contract validate --task <task-id> [--file <path>]');
+    }
+    const filePath = (0, brainfile_path_1.resolveCliBrainfilePath)(options.file);
+    const result = (0, contractRunner_1.validateContract)({ filePath, taskId: options.task });
+    if ('error' in result) {
+        throw (0, cli_error_1.operationFailed)(result.error);
+    }
+    const deliverablesOk = result.deliverableChecks.every((c) => c.ok);
+    const commandsOk = result.commandResults.every((c) => c.exitCode === 0);
+    const ok = result.ok;
+    // Show warnings first (before success/fail status)
+    if (result.warnings.length > 0) {
+        logger.log('');
+        logger.log('⚠️  Warnings:');
+        for (const warning of result.warnings) {
+            logger.log(`  Command: ${warning.command}`);
+            logger.log(`  ${warning.message}`);
+            logger.log('');
+        }
+    }
+    logger.log(`Contract validation ${ok ? 'passed' : 'failed'}: ${options.task}`);
+    if (!deliverablesOk) {
+        logger.log('');
+        logger.log('Deliverables:');
+        for (const check of result.deliverableChecks) {
+            if (check.deliverable.type !== 'file')
+                continue;
+            const status = check.ok ? 'OK' : 'MISSING';
+            logger.log(`- [${status}] ${check.deliverable.path}${check.resolvedPath ? ` (${check.resolvedPath})` : ''}`);
+        }
+    }
+    if (!commandsOk && result.commandResults.length > 0) {
+        logger.log('');
+        logger.log('Validation commands:');
+        for (const cmd of result.commandResults) {
+            logger.log(`- [${cmd.exitCode === 0 ? 'OK' : `FAIL(${cmd.exitCode})`}] ${cmd.command}`);
+        }
+    }
+    return { success: ok };
+}
+/**
+ * Attach a new contract to an existing task (default status=draft).
+ * This is for programmatic contract creation (no manual YAML editing).
+ * Pass ready:true via options to make the contract immediately dispatchable.
+ */
+function contractAttachCommand(options, logger = logger_1.defaultLogger) {
+    if (!options.task) {
+        throw (0, cli_error_1.missingRequired)('--task', 'brainfile contract attach --task <task-id> [--file <path>] [--deliverable ...]');
+    }
+    const filePath = (0, brainfile_path_1.resolveCliBrainfilePath)(options.file);
+    if (!fs.existsSync(filePath)) {
+        throw (0, cli_error_1.operationFailed)(`File not found: ${filePath}`);
+    }
+    const validationCommands = Array.isArray(options.validation)
+        ? options.validation
+        : options.validation
+            ? [options.validation]
+            : [];
+    for (const warning of (0, command_lint_1.lintValidationCommands)(validationCommands, filePath)) {
+        logger.warn(`Warning: ${warning.message}`);
+    }
+    let contract;
+    try {
+        contract = (0, contractSpec_1.buildContract)({
+            deliverableSpecs: options.deliverable,
+            validationCommands: options.validation,
+            constraints: options.constraint,
+            status: options.ready ? 'ready' : 'draft',
+        });
+    }
+    catch (e) {
+        throw (0, cli_error_1.validationError)(e.message);
+    }
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        if (isUnsafeTaskId(options.task)) {
+            throw (0, cli_error_1.operationFailed)(`Invalid task ID: ${options.task}`);
+        }
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        const found = (0, v2_detect_1.findV2Task)(dirs, options.task, false);
+        if (!found || found.isLog) {
+            throw (0, cli_error_1.operationFailed)(`Task not found: ${options.task}`);
+        }
+        found.doc.task.contract = contract;
+        (0, core_1.writeTaskFile)(found.filePath, found.doc.task, found.doc.body);
+        logger.log(`Contract attached: ${options.task}`);
+        return { success: true };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = core_1.Brainfile.parseWithErrors(content);
+    if (!parsed.board) {
+        throw (0, cli_error_1.operationFailed)(parsed.error || 'Failed to parse brainfile');
+    }
+    const taskInfo = (0, core_1.findTaskById)(parsed.board, options.task);
+    if (!taskInfo) {
+        throw (0, cli_error_1.operationFailed)(`Task not found: ${options.task}`);
+    }
+    const result = (0, core_1.setTaskContract)(parsed.board, options.task, contract);
+    if (!result.success || !result.board) {
+        throw (0, cli_error_1.operationFailed)(result.error || 'Failed to attach contract');
+    }
+    fs.writeFileSync(filePath, core_1.Brainfile.serialize(result.board), 'utf-8');
+    logger.log(`Contract attached: ${options.task}`);
+    return { success: true };
+}
+/**
+ * Activate one or more draft contracts (draft → ready).
+ *
+ * - Single task: `--task <id>`
+ * - Bulk by parent: `--parent <epic-id>` (activates all draft children)
+ */
+function contractActivateCommand(options, logger = logger_1.defaultLogger) {
+    if (!options.task && !options.parent) {
+        throw (0, cli_error_1.missingRequired)('--task or --parent', 'brainfile contract activate -t <task-id> | --parent <epic-id>');
+    }
+    const filePath = (0, brainfile_path_1.resolveCliBrainfilePath)(options.file);
+    if (!fs.existsSync(filePath)) {
+        throw (0, cli_error_1.operationFailed)(`File not found: ${filePath}`);
+    }
+    const activated = [];
+    // ── V2 per-task file architecture ──────────────────────────────────────────
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        if (options.task) {
+            // Single task activation
+            if (isUnsafeTaskId(options.task)) {
+                throw (0, cli_error_1.operationFailed)(`Invalid task ID: ${options.task}`);
+            }
+            const found = (0, v2_detect_1.findV2Task)(dirs, options.task, false);
+            if (!found || found.isLog) {
+                throw (0, cli_error_1.operationFailed)(`Task not found: ${options.task}`);
+            }
+            if (!found.doc.task.contract) {
+                throw (0, cli_error_1.operationFailed)(`Task ${options.task} has no contract`);
+            }
+            if (found.doc.task.contract.status !== 'draft') {
+                throw (0, cli_error_1.operationFailed)(`Contract is not in draft status (current: ${found.doc.task.contract.status})`);
+            }
+            const readyAt = new Date().toISOString();
+            found.doc.task.contract = {
+                ...found.doc.task.contract,
+                status: 'ready',
+                metrics: {
+                    ...(found.doc.task.contract.metrics ?? {}),
+                    readyAt,
+                },
+            };
+            found.doc.task.updatedAt = readyAt;
+            (0, core_1.writeTaskFile)(found.filePath, found.doc.task, found.doc.body);
+            activated.push(options.task);
+            logger.log(`Contract activated: ${options.task}`);
+        }
+        else {
+            // Bulk activation by parentId
+            const parentId = options.parent;
+            const allTasks = (0, core_1.readTasksDir)(dirs.boardDir);
+            for (const doc of allTasks) {
+                const task = doc.task;
+                if (task.parentId !== parentId)
+                    continue;
+                if (!task.contract || task.contract.status !== 'draft')
+                    continue;
+                const readyAt = new Date().toISOString();
+                task.contract = {
+                    ...task.contract,
+                    status: 'ready',
+                    metrics: {
+                        ...(task.contract.metrics ?? {}),
+                        readyAt,
+                    },
+                };
+                task.updatedAt = readyAt;
+                const taskPath = path.join(dirs.boardDir, (0, core_1.taskFileName)(task.id));
+                (0, core_1.writeTaskFile)(taskPath, task, doc.body);
+                activated.push(task.id);
+                logger.log(`Contract activated: ${task.id}`);
+            }
+            if (activated.length === 0) {
+                logger.log(`No draft contracts found with parent: ${parentId}`);
+            }
+        }
+        return { success: true, activated };
+    }
+    // ── V1 board ──────────────────────────────────────────────────────────────
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const parsed = core_1.Brainfile.parseWithErrors(content);
+    if (!parsed.board) {
+        throw (0, cli_error_1.operationFailed)(parsed.error || 'Failed to parse brainfile');
+    }
+    let board = parsed.board;
+    if (options.task) {
+        // Single task
+        const taskInfo = (0, core_1.findTaskById)(board, options.task);
+        if (!taskInfo) {
+            throw (0, cli_error_1.operationFailed)(`Task not found: ${options.task}`);
+        }
+        if (!taskInfo.task.contract) {
+            throw (0, cli_error_1.operationFailed)(`Task ${options.task} has no contract`);
+        }
+        if (taskInfo.task.contract.status !== 'draft') {
+            throw (0, cli_error_1.operationFailed)(`Contract is not in draft status (current: ${taskInfo.task.contract.status})`);
+        }
+        // Mutate via setTaskContract (re-attach with status=ready)
+        const readyAt = new Date().toISOString();
+        const updatedContract = {
+            ...taskInfo.task.contract,
+            status: 'ready',
+            metrics: {
+                ...(taskInfo.task.contract.metrics ?? {}),
+                readyAt,
+            },
+        };
+        const result = (0, core_1.setTaskContract)(board, options.task, updatedContract);
+        if (!result.success || !result.board) {
+            throw (0, cli_error_1.operationFailed)(result.error || 'Failed to activate contract');
+        }
+        board = result.board;
+        activated.push(options.task);
+        logger.log(`Contract activated: ${options.task}`);
+    }
+    else {
+        // Bulk by parentId (V1 boards store parentId on task)
+        const parentId = options.parent;
+        for (const col of board.columns) {
+            for (const task of col.tasks) {
+                const t = task;
+                if (t.parentId !== parentId)
+                    continue;
+                if (!task.contract || task.contract.status !== 'draft')
+                    continue;
+                const readyAt = new Date().toISOString();
+                const updatedContract = {
+                    ...task.contract,
+                    status: 'ready',
+                    metrics: {
+                        ...(task.contract.metrics ?? {}),
+                        readyAt,
+                    },
+                };
+                const result = (0, core_1.setTaskContract)(board, task.id, updatedContract);
+                if (result.success && result.board) {
+                    board = result.board;
+                    activated.push(task.id);
+                    logger.log(`Contract activated: ${task.id}`);
+                }
+            }
+        }
+        if (activated.length === 0) {
+            logger.log(`No draft contracts found with parent: ${parentId}`);
+        }
+    }
+    fs.writeFileSync(filePath, core_1.Brainfile.serialize(board), 'utf-8');
+    return { success: true, activated };
+}
+//# sourceMappingURL=contract.js.map