agentplane 0.1.6 → 0.1.7

package/dist/commands/workflow.js

@@ -1,4619 +1,8 @@
-import { execFile } from "node:child_process";
-import { chmod, mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-import { extractTaskSuffix, ensureDocSections, getBaseBranch, getStagedFiles, getUnstagedFiles, lintTasksFile, loadConfig, normalizeDocSectionName, parseDocSections, renderTaskReadme, resolveProject, setMarkdownSection, setPinnedBaseBranch, taskReadmePath, validateCommitSubject, validateTaskDocMetadata, } from "@agentplaneorg/core";
-import { formatCommentBodyForCommit } from "../shared/comment-format.js";
-import { mapBackendError, mapCoreError } from "../cli/error-map.js";
-import { fileExists } from "../cli/fs-utils.js";
-import { promptChoice, promptInput, promptYesNo } from "../cli/prompts.js";
-import { backendNotSupportedMessage, infoMessage, invalidValueForFlag, invalidValueMessage, missingValueMessage, successMessage, unknownEntityMessage, usageMessage, warnMessage, workflowModeMessage, } from "../cli/output.js";
-import { CliError } from "../shared/errors.js";
-import { loadTaskBackend } from "../backends/task-backend.js";
-const execFileAsync = promisify(execFile);
-function gitEnv() {
-    const env = { ...process.env };
-    delete env.GIT_DIR;
-    delete env.GIT_WORK_TREE;
-    delete env.GIT_COMMON_DIR;
-    delete env.GIT_INDEX_FILE;
-    delete env.GIT_OBJECT_DIRECTORY;
-    delete env.GIT_ALTERNATE_OBJECT_DIRECTORIES;
-    return env;
-}
-export const TASK_NEW_USAGE = "Usage: agentplane task new --title <text> --description <text> --priority <low|normal|med|high> --owner <id> --tag <tag> [--tag <tag>...]";
-export const TASK_NEW_USAGE_EXAMPLE = 'agentplane task new --title "Refactor CLI" --description "Improve CLI output" --priority med --owner CODER --tag cli';
-export const TASK_ADD_USAGE = "Usage: agentplane task add <task-id> [<task-id> ...] --title <text> --description <text> --priority <low|normal|med|high> --owner <id> --tag <tag> [--tag <tag>...]";
-export const TASK_ADD_USAGE_EXAMPLE = 'agentplane task add 202602030608-F1Q8AB --title "..." --description "..." --priority med --owner CODER --tag cli';
-export const TASK_SCRUB_USAGE = "Usage: agentplane task scrub --find <text> --replace <text> [flags]";
-export const TASK_SCRUB_USAGE_EXAMPLE = 'agentplane task scrub --find "agentctl" --replace "agentplane" --dry-run';
-export const TASK_UPDATE_USAGE = "Usage: agentplane task update <task-id> [flags]";
-export const TASK_UPDATE_USAGE_EXAMPLE = 'agentplane task update 202602030608-F1Q8AB --title "..." --owner CODER';
-export const TASK_SCAFFOLD_USAGE = "Usage: agentplane task scaffold <task-id> [--title <text>] [--overwrite] [--force]";
-export const TASK_SCAFFOLD_USAGE_EXAMPLE = "agentplane task scaffold 202602030608-F1Q8AB";
-export const BRANCH_BASE_USAGE = "Usage: agentplane branch base get|set <name>";
-export const BRANCH_BASE_USAGE_EXAMPLE = "agentplane branch base set main";
-export const BRANCH_STATUS_USAGE = "Usage: agentplane branch status [--branch <name>] [--base <name>]";
-export const BRANCH_STATUS_USAGE_EXAMPLE = "agentplane branch status --base main";
-export const BRANCH_REMOVE_USAGE = "Usage: agentplane branch remove [--branch <name>] [--worktree <path>] [--force] [--quiet]";
-export const BRANCH_REMOVE_USAGE_EXAMPLE = "agentplane branch remove --branch task/20260203-F1Q8AB --worktree .agentplane/worktrees/task";
-function normalizeDependsOnInput(value) {
-    const trimmed = value.trim();
-    if (!trimmed || trimmed === "[]")
-        return [];
-    return [trimmed];
-}
-function parseTaskNewFlags(args) {
-    const out = { tags: [], dependsOn: [], verify: [] };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (!arg.startsWith("--")) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: `Unexpected argument: ${arg}`,
-            });
-        }
-        const next = args[i + 1];
-        if (!next) {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: missingValueMessage(arg) });
-        }
-        switch (arg) {
-            case "--title": {
-                out.title = next;
-                break;
-            }
-            case "--description": {
-                out.description = next;
-                break;
-            }
-            case "--owner": {
-                out.owner = next;
-                break;
-            }
-            case "--priority": {
-                out.priority = next;
-                break;
-            }
-            case "--tag": {
-                out.tags.push(next);
-                break;
-            }
-            case "--depends-on": {
-                out.dependsOn.push(...normalizeDependsOnInput(next));
-                break;
-            }
-            case "--verify": {
-                out.verify.push(next);
-                break;
-            }
-            default: {
-                throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-            }
-        }
-        i++;
-    }
-    return out;
-}
-export async function cmdTaskNew(opts) {
-    const flags = parseTaskNewFlags(opts.args);
-    const priority = flags.priority ?? "med";
-    if (!flags.title || !flags.description || !flags.owner || flags.tags.length === 0) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(TASK_NEW_USAGE, TASK_NEW_USAGE_EXAMPLE),
-        });
-    }
-    try {
-        const { backend, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const suffixLength = config.tasks.id_suffix_length_default;
-        if (!backend.generateTaskId) {
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: backendNotSupportedMessage("generateTaskId()"),
-            });
-        }
-        const taskId = await backend.generateTaskId({ length: suffixLength, attempts: 1000 });
-        const task = {
-            id: taskId,
-            title: flags.title,
-            description: flags.description,
-            status: "TODO",
-            priority,
-            owner: flags.owner,
-            tags: flags.tags,
-            depends_on: flags.dependsOn,
-            verify: flags.verify,
-            comments: [],
-            doc_version: 2,
-            doc_updated_at: nowIso(),
-            doc_updated_by: flags.owner,
-            id_source: "generated",
-        };
-        if (requiresVerify(flags.tags, config.tasks.verify.required_tags) &&
-            flags.verify.length === 0) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "Missing verify commands for tasks with code/backend/frontend tags (use --verify)",
-            });
-        }
-        await backend.writeTask(task);
-        process.stdout.write(`${taskId}\n`);
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task new", root: opts.rootOverride ?? null });
-    }
-}
-function parseTaskAddFlags(args) {
-    const out = {
-        taskIds: [],
-        title: "",
-        description: "",
-        status: "TODO",
-        priority: "",
-        owner: "",
-        tags: [],
-        dependsOn: [],
-        verify: [],
-    };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (!arg.startsWith("--")) {
-            out.taskIds.push(arg);
-            continue;
-        }
-        const next = args[i + 1];
-        if (arg === "--replace-tags" || arg === "--replace-depends-on" || arg === "--replace-verify") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(TASK_ADD_USAGE, TASK_ADD_USAGE_EXAMPLE),
-            });
-        }
-        if (!next) {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: missingValueMessage(arg) });
-        }
-        switch (arg) {
-            case "--title": {
-                out.title = next;
-                break;
-            }
-            case "--description": {
-                out.description = next;
-                break;
-            }
-            case "--status": {
-                out.status = next;
-                break;
-            }
-            case "--priority": {
-                out.priority = next;
-                break;
-            }
-            case "--owner": {
-                out.owner = next;
-                break;
-            }
-            case "--tag": {
-                out.tags.push(next);
-                break;
-            }
-            case "--depends-on": {
-                out.dependsOn.push(...normalizeDependsOnInput(next));
-                break;
-            }
-            case "--verify": {
-                out.verify.push(next);
-                break;
-            }
-            case "--comment-author": {
-                out.commentAuthor = next;
-                break;
-            }
-            case "--comment-body": {
-                out.commentBody = next;
-                break;
-            }
-            default: {
-                throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-            }
-        }
-        i++;
-    }
-    return out;
-}
-export async function cmdTaskAdd(opts) {
-    const flags = parseTaskAddFlags(opts.args);
-    if (flags.taskIds.length === 0 ||
-        !flags.title ||
-        !flags.description ||
-        !flags.priority ||
-        !flags.owner ||
-        flags.tags.length === 0) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(TASK_ADD_USAGE, TASK_ADD_USAGE_EXAMPLE),
-        });
-    }
-    try {
-        const { backend, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const status = normalizeTaskStatus(flags.status);
-        const existing = await backend.listTasks();
-        const existingIds = new Set(existing.map((task) => task.id));
-        for (const taskId of flags.taskIds) {
-            if (existingIds.has(taskId)) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `Task already exists: ${taskId}`,
-                });
-            }
-        }
-        const tags = dedupeStrings(flags.tags);
-        const dependsOn = dedupeStrings(flags.dependsOn);
-        const verify = dedupeStrings(flags.verify);
-        const docUpdatedBy = (flags.commentAuthor ?? "").trim() || flags.owner;
-        if (requiresVerify(tags, config.tasks.verify.required_tags) && verify.length === 0) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "verify commands are required for tasks with code/backend/frontend tags",
-            });
-        }
-        const tasks = flags.taskIds.map((taskId) => ({
-            id: taskId,
-            title: flags.title,
-            description: flags.description,
-            status,
-            priority: flags.priority,
-            owner: flags.owner,
-            tags,
-            depends_on: dependsOn,
-            verify,
-            comments: flags.commentAuthor && flags.commentBody
-                ? [{ author: flags.commentAuthor, body: flags.commentBody }]
-                : [],
-            doc_version: 2,
-            doc_updated_at: nowIso(),
-            doc_updated_by: docUpdatedBy,
-            id_source: "explicit",
-        }));
-        if (backend.writeTasks) {
-            await backend.writeTasks(tasks);
-        }
-        else {
-            for (const task of tasks) {
-                await backend.writeTask(task);
-            }
-        }
-        for (const task of tasks) {
-            process.stdout.write(`${task.id}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task add", root: opts.rootOverride ?? null });
-    }
-}
-function parseTaskUpdateFlags(args) {
-    const [taskId, ...rest] = args;
-    if (!taskId) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(TASK_UPDATE_USAGE, TASK_UPDATE_USAGE_EXAMPLE),
-        });
-    }
-    const out = {
-        taskId,
-        tags: [],
-        replaceTags: false,
-        dependsOn: [],
-        replaceDependsOn: false,
-        verify: [],
-        replaceVerify: false,
-    };
-    for (let i = 0; i < rest.length; i++) {
-        const arg = rest[i];
-        if (!arg)
-            continue;
-        if (arg === "--replace-tags") {
-            out.replaceTags = true;
-            continue;
-        }
-        if (arg === "--replace-depends-on") {
-            out.replaceDependsOn = true;
-            continue;
-        }
-        if (arg === "--replace-verify") {
-            out.replaceVerify = true;
-            continue;
-        }
-        if (!arg.startsWith("--")) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(TASK_UPDATE_USAGE, TASK_UPDATE_USAGE_EXAMPLE),
-            });
-        }
-        const next = rest[i + 1];
-        if (!next) {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: missingValueMessage(arg) });
-        }
-        switch (arg) {
-            case "--title": {
-                out.title = next;
-                break;
-            }
-            case "--description": {
-                out.description = next;
-                break;
-            }
-            case "--priority": {
-                out.priority = next;
-                break;
-            }
-            case "--owner": {
-                out.owner = next;
-                break;
-            }
-            case "--tag": {
-                out.tags.push(next);
-                break;
-            }
-            case "--depends-on": {
-                out.dependsOn.push(...normalizeDependsOnInput(next));
-                break;
-            }
-            case "--verify": {
-                out.verify.push(next);
-                break;
-            }
-            default: {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `Unknown flag: ${arg}`,
-                });
-            }
-        }
-        i++;
-    }
-    return out;
-}
-export async function cmdTaskUpdate(opts) {
-    const flags = parseTaskUpdateFlags(opts.args);
-    try {
-        const { backend, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const task = await backend.getTask(flags.taskId);
-        if (!task) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: unknownEntityMessage("task id", flags.taskId),
-            });
-        }
-        const next = { ...task };
-        if (flags.title !== undefined)
-            next.title = flags.title;
-        if (flags.description !== undefined)
-            next.description = flags.description;
-        if (flags.priority !== undefined)
-            next.priority = flags.priority;
-        if (flags.owner !== undefined)
-            next.owner = flags.owner;
-        const existingTags = flags.replaceTags ? [] : dedupeStrings(toStringArray(next.tags));
-        const mergedTags = dedupeStrings([...existingTags, ...flags.tags]);
-        next.tags = mergedTags;
-        const existingDepends = flags.replaceDependsOn
-            ? []
-            : dedupeStrings(toStringArray(next.depends_on));
-        const mergedDepends = dedupeStrings([...existingDepends, ...flags.dependsOn]);
-        next.depends_on = mergedDepends;
-        const existingVerify = flags.replaceVerify ? [] : dedupeStrings(toStringArray(next.verify));
-        const mergedVerify = dedupeStrings([...existingVerify, ...flags.verify]);
-        next.verify = mergedVerify;
-        if (requiresVerify(mergedTags, config.tasks.verify.required_tags) &&
-            mergedVerify.length === 0) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "verify commands are required for tasks with code/backend/frontend tags",
-            });
-        }
-        await backend.writeTask(next);
-        process.stdout.write(`${successMessage("updated", flags.taskId)}\n`);
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task update", root: opts.rootOverride ?? null });
-    }
-}
-function parseTaskScrubFlags(args) {
-    const out = {
-        find: "",
-        replace: "",
-        dryRun: false,
-        quiet: false,
-    };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (arg === "--dry-run") {
-            out.dryRun = true;
-            continue;
-        }
-        if (arg === "--quiet") {
-            out.quiet = true;
-            continue;
-        }
-        if (!arg.startsWith("--")) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(TASK_SCRUB_USAGE, TASK_SCRUB_USAGE_EXAMPLE),
-            });
-        }
-        const next = args[i + 1];
-        if (!next)
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: missingValueMessage(arg) });
-        if (arg === "--find") {
-            out.find = next;
-        }
-        else if (arg === "--replace") {
-            out.replace = next;
-        }
-        else {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-        }
-        i++;
-    }
-    return out;
-}
-function scrubValue(value, find, replace) {
-    if (typeof value === "string")
-        return value.replaceAll(find, replace);
-    if (Array.isArray(value))
-        return value.map((item) => scrubValue(item, find, replace));
-    if (value && typeof value === "object") {
-        const entries = Object.entries(value);
-        const out = {};
-        for (const [key, val] of entries) {
-            out[key] = scrubValue(val, find, replace);
-        }
-        return out;
-    }
-    return value;
-}
-export async function cmdTaskScrub(opts) {
-    const flags = parseTaskScrubFlags(opts.args);
-    if (!flags.find) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(TASK_SCRUB_USAGE, TASK_SCRUB_USAGE_EXAMPLE),
-        });
-    }
-    try {
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const tasks = await backend.listTasks();
-        const updated = [];
-        const changedIds = new Set();
-        for (const task of tasks) {
-            const before = JSON.stringify(task);
-            const scrubbed = scrubValue(task, flags.find, flags.replace);
-            if (scrubbed && typeof scrubbed === "object") {
-                const next = scrubbed;
-                updated.push(next);
-                const after = JSON.stringify(next);
-                if (before !== after)
-                    changedIds.add(next.id);
-            }
-            else {
-                updated.push(task);
-            }
-        }
-        if (flags.dryRun) {
-            if (!flags.quiet) {
-                process.stdout.write(`${infoMessage(`dry-run: would update ${changedIds.size} task(s)`)}` + "\n");
-                for (const id of [...changedIds].toSorted()) {
-                    process.stdout.write(`${id}\n`);
-                }
-            }
-            return 0;
-        }
-        if (backend.writeTasks) {
-            await backend.writeTasks(updated);
-        }
-        else {
-            for (const task of updated) {
-                await backend.writeTask(task);
-            }
-        }
-        if (!flags.quiet) {
-            process.stdout.write(`${successMessage("updated tasks", undefined, `count=${changedIds.size}`)}` + "\n");
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task scrub", root: opts.rootOverride ?? null });
-    }
-}
-function parseTaskListFilters(args, opts) {
-    const out = { status: [], owner: [], tag: [], quiet: false };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (arg === "--quiet") {
-            out.quiet = true;
-            continue;
-        }
-        if (arg === "--status") {
-            const next = args[i + 1];
-            if (!next)
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: missingValueMessage("--status"),
-                });
-            out.status.push(next);
-            i++;
-            continue;
-        }
-        if (arg === "--owner") {
-            const next = args[i + 1];
-            if (!next)
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: missingValueMessage("--owner"),
-                });
-            out.owner.push(next);
-            i++;
-            continue;
-        }
-        if (arg === "--tag") {
-            const next = args[i + 1];
-            if (!next)
-                throw new CliError({ exitCode: 2, code: "E_USAGE", message: missingValueMessage("--tag") });
-            out.tag.push(next);
-            i++;
-            continue;
-        }
-        if (opts?.allowLimit && arg === "--limit") {
-            const next = args[i + 1];
-            if (!next)
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: missingValueMessage("--limit"),
-                });
-            const parsed = Number.parseInt(next, 10);
-            if (!Number.isFinite(parsed)) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: invalidValueForFlag("--limit", next, "integer"),
-                });
-            }
-            out.limit = parsed;
-            i++;
-            continue;
-        }
-        if (arg.startsWith("--")) {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-        }
-    }
-    return out;
-}
-export async function cmdTaskListWithFilters(opts) {
-    const filters = parseTaskListFilters(opts.args);
-    try {
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const tasks = await backend.listTasks();
-        const depState = buildDependencyState(tasks);
-        let filtered = tasks;
-        if (filters.status.length > 0) {
-            const wanted = new Set(filters.status.map((s) => s.trim().toUpperCase()));
-            filtered = filtered.filter((task) => wanted.has(String(task.status || "TODO").toUpperCase()));
-        }
-        if (filters.owner.length > 0) {
-            const wanted = new Set(filters.owner.map((o) => o.trim().toUpperCase()));
-            filtered = filtered.filter((task) => wanted.has(String(task.owner || "").toUpperCase()));
-        }
-        if (filters.tag.length > 0) {
-            const wanted = new Set(filters.tag.map((t) => t.trim()).filter(Boolean));
-            filtered = filtered.filter((task) => {
-                const tags = dedupeStrings(toStringArray(task.tags));
-                return tags.some((tag) => wanted.has(tag));
-            });
-        }
-        const sorted = filtered.toSorted((a, b) => a.id.localeCompare(b.id));
-        for (const task of sorted) {
-            process.stdout.write(`${formatTaskLine(task, depState.get(task.id))}\n`);
-        }
-        if (!filters.quiet) {
-            const counts = {};
-            for (const task of sorted) {
-                const status = String(task.status || "TODO").toUpperCase();
-                counts[status] = (counts[status] ?? 0) + 1;
-            }
-            const total = sorted.length;
-            const summary = Object.keys(counts)
-                .toSorted()
-                .map((key) => `${key}=${counts[key]}`)
-                .join(", ");
-            process.stdout.write(`Total: ${total}${summary ? ` (${summary})` : ""}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task list", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdTaskNext(opts) {
-    const filters = parseTaskListFilters(opts.args, { allowLimit: true });
-    try {
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const tasks = await backend.listTasks();
-        const depState = buildDependencyState(tasks);
-        const statuses = filters.status.length > 0
-            ? new Set(filters.status.map((s) => s.trim().toUpperCase()))
-            : new Set(["TODO"]);
-        let filtered = tasks.filter((task) => statuses.has(String(task.status || "TODO").toUpperCase()));
-        if (filters.owner.length > 0) {
-            const wanted = new Set(filters.owner.map((o) => o.trim().toUpperCase()));
-            filtered = filtered.filter((task) => wanted.has(String(task.owner || "").toUpperCase()));
-        }
-        if (filters.tag.length > 0) {
-            const wanted = new Set(filters.tag.map((t) => t.trim()).filter(Boolean));
-            filtered = filtered.filter((task) => {
-                const tags = dedupeStrings(toStringArray(task.tags));
-                return tags.some((tag) => wanted.has(tag));
-            });
-        }
-        const sorted = filtered.toSorted((a, b) => a.id.localeCompare(b.id));
-        const ready = sorted.filter((task) => {
-            const dep = depState.get(task.id);
-            return !dep || (dep.missing.length === 0 && dep.incomplete.length === 0);
-        });
-        const limited = filters.limit !== undefined && filters.limit >= 0 ? ready.slice(0, filters.limit) : ready;
-        for (const task of limited) {
-            process.stdout.write(`${formatTaskLine(task, depState.get(task.id))}\n`);
-        }
-        if (!filters.quiet) {
-            process.stdout.write(`Ready: ${limited.length} / ${filtered.length}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task next", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdReady(opts) {
-    try {
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const tasks = await backend.listTasks();
-        const depState = buildDependencyState(tasks);
-        const task = tasks.find((item) => item.id === opts.taskId);
-        const warnings = [];
-        if (task) {
-            const dep = depState.get(task.id);
-            const missing = dep?.missing ?? [];
-            const incomplete = dep?.incomplete ?? [];
-            if (missing.length > 0) {
-                warnings.push(`${task.id}: missing deps: ${missing.join(", ")}`);
-            }
-            if (incomplete.length > 0) {
-                warnings.push(`${task.id}: incomplete deps: ${incomplete.join(", ")}`);
-            }
-        }
-        else {
-            warnings.push(unknownEntityMessage("task id", opts.taskId));
-        }
-        for (const warning of warnings) {
-            process.stdout.write(`${warnMessage(warning)}\n`);
-        }
-        if (task) {
-            const status = String(task.status || "TODO").toUpperCase();
-            const title = task.title?.trim() || "(untitled task)";
-            const owner = task.owner?.trim() || "-";
-            const dep = depState.get(task.id);
-            const dependsOn = dep?.dependsOn ?? [];
-            process.stdout.write(`Task: ${task.id} [${status}] ${title}\n`);
-            process.stdout.write(`Owner: ${owner}\n`);
-            process.stdout.write(`Depends on: ${dependsOn.length > 0 ? dependsOn.join(", ") : "-"}\n`);
-            const missing = dep?.missing ?? [];
-            const incomplete = dep?.incomplete ?? [];
-            if (missing.length > 0) {
-                process.stdout.write(`${warnMessage(`missing deps: ${missing.join(", ")}`)}\n`);
-            }
-            if (incomplete.length > 0) {
-                process.stdout.write(`${warnMessage(`incomplete deps: ${incomplete.join(", ")}`)}\n`);
-            }
-        }
-        const ready = warnings.length === 0;
-        process.stdout.write(`${ready ? successMessage("ready") : warnMessage("not ready")}` + "\n");
-        return ready ? 0 : 2;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "ready", root: opts.rootOverride ?? null });
-    }
-}
-function taskTextBlob(task) {
-    const parts = [];
-    for (const key of ["id", "title", "description", "status", "priority", "owner"]) {
-        const value = task[key];
-        if (typeof value === "string" && value.trim())
-            parts.push(value.trim());
-    }
-    const tags = toStringArray(task.tags);
-    parts.push(...tags.filter(Boolean));
-    const comments = Array.isArray(task.comments) ? task.comments : [];
-    for (const comment of comments) {
-        if (comment && typeof comment.author === "string")
-            parts.push(comment.author);
-        if (comment && typeof comment.body === "string")
-            parts.push(comment.body);
-    }
-    const commit = task.commit ?? null;
-    if (commit && typeof commit.hash === "string")
-        parts.push(commit.hash);
-    if (commit && typeof commit.message === "string")
-        parts.push(commit.message);
-    return parts.join("\n");
-}
-export async function cmdTaskSearch(opts) {
-    const query = opts.query.trim();
-    if (!query) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Missing query (expected non-empty text)",
-        });
-    }
-    let regex = false;
-    const restArgs = [...opts.args];
-    if (restArgs.includes("--regex")) {
-        regex = true;
-        restArgs.splice(restArgs.indexOf("--regex"), 1);
-    }
-    const filters = parseTaskListFilters(restArgs, { allowLimit: true });
-    try {
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const tasks = await backend.listTasks();
-        const depState = buildDependencyState(tasks);
-        let filtered = tasks;
-        if (filters.status.length > 0) {
-            const wanted = new Set(filters.status.map((s) => s.trim().toUpperCase()));
-            filtered = filtered.filter((task) => wanted.has(String(task.status || "TODO").toUpperCase()));
-        }
-        if (filters.owner.length > 0) {
-            const wanted = new Set(filters.owner.map((o) => o.trim().toUpperCase()));
-            filtered = filtered.filter((task) => wanted.has(String(task.owner || "").toUpperCase()));
-        }
-        if (filters.tag.length > 0) {
-            const wanted = new Set(filters.tag.map((t) => t.trim()).filter(Boolean));
-            filtered = filtered.filter((task) => {
-                const tags = dedupeStrings(toStringArray(task.tags));
-                return tags.some((tag) => wanted.has(tag));
-            });
-        }
-        let matches = [];
-        if (regex) {
-            let pattern;
-            try {
-                pattern = new RegExp(query, "i");
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : "Invalid regex";
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: invalidValueMessage("regex", message, "valid pattern"),
-                });
-            }
-            matches = filtered.filter((task) => pattern.test(taskTextBlob(task)));
-        }
-        else {
-            const needle = query.toLowerCase();
-            matches = filtered.filter((task) => taskTextBlob(task).toLowerCase().includes(needle));
-        }
-        if (filters.limit !== undefined && filters.limit >= 0) {
-            matches = matches.slice(0, filters.limit);
-        }
-        const sorted = matches.toSorted((a, b) => a.id.localeCompare(b.id));
-        for (const task of sorted) {
-            process.stdout.write(`${formatTaskLine(task, depState.get(task.id))}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "task search", root: opts.rootOverride ?? null });
-    }
-}
-function parseTaskScaffoldFlags(args) {
-    const [taskId, ...rest] = args;
-    if (!taskId) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(TASK_SCAFFOLD_USAGE, TASK_SCAFFOLD_USAGE_EXAMPLE),
-        });
-    }
-    const out = { taskId, overwrite: false, force: false, quiet: false };
-    for (let i = 0; i < rest.length; i++) {
-        const arg = rest[i];
-        if (!arg)
-            continue;
-        if (arg === "--overwrite") {
-            out.overwrite = true;
-            continue;
-        }
-        if (arg === "--force") {
-            out.force = true;
-            continue;
-        }
-        if (arg === "--quiet") {
-            out.quiet = true;
-            continue;
-        }
-        if (arg === "--title") {
-            const next = rest[i + 1];
-            if (!next)
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: missingValueMessage("--title"),
-                });
-            out.title = next;
-            i++;
-            continue;
-        }
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: `Unknown flag: ${arg}`,
-        });
-    }
-    return out;
-}
-export async function cmdTaskScaffold(opts) {
-    const flags = parseTaskScaffoldFlags(opts.args);
-    try {
-        const { backend, resolved, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const task = await backend.getTask(flags.taskId);
-        if (!task && !flags.force) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: unknownEntityMessage("task id", flags.taskId),
-            });
-        }
-        const readmePath = taskReadmePath(path.join(resolved.gitRoot, config.paths.workflow_dir), flags.taskId);
-        try {
-            await readFile(readmePath, "utf8");
-            if (!flags.overwrite) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `File already exists: ${readmePath}`,
-                });
-            }
-        }
-        catch (err) {
-            const code = err?.code;
-            if (code !== "ENOENT") {
-                if (err instanceof CliError)
-                    throw err;
-                throw err;
-            }
-        }
-        const baseTask = task ??
-            {
-                id: flags.taskId,
-                title: flags.title ?? "",
-                description: "",
-                status: "TODO",
-                priority: "med",
-                owner: "",
-                depends_on: [],
-                tags: [],
-                verify: [],
-                comments: [],
-                doc_version: 2,
-                doc_updated_at: nowIso(),
-                doc_updated_by: "UNKNOWN",
-            };
-        if (flags.title)
-            baseTask.title = flags.title;
-        if (typeof baseTask.doc_updated_by !== "string" ||
-            baseTask.doc_updated_by.trim().length === 0 ||
-            baseTask.doc_updated_by.trim().toLowerCase() === "agentplane") {
-            baseTask.doc_updated_by = baseTask.owner?.trim() ? baseTask.owner : "UNKNOWN";
-        }
-        const frontmatter = taskDataToFrontmatter(baseTask);
-        const body = ensureDocSections("", config.tasks.doc.required_sections);
-        const text = renderTaskReadme(frontmatter, body);
-        await mkdir(path.dirname(readmePath), { recursive: true });
-        await writeFile(readmePath, text.endsWith("\n") ? text : `${text}\n`, "utf8");
-        if (!flags.quiet) {
-            process.stdout.write(`${successMessage("wrote", path.relative(resolved.gitRoot, readmePath))}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "task scaffold", root: opts.rootOverride ?? null });
-    }
-}
-function parseTaskNormalizeFlags(args) {
-    const out = { quiet: false, force: false };
-    for (const arg of args) {
-        if (!arg)
-            continue;
-        if (arg === "--quiet")
-            out.quiet = true;
-        else if (arg === "--force")
-            out.force = true;
-        else if (arg.startsWith("--"))
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-    }
-    return out;
-}
-export async function cmdTaskNormalize(opts) {
-    const flags = parseTaskNormalizeFlags(opts.args);
-    if (flags.force) {
-        // Force is accepted for parity; no additional checks in node CLI.
-    }
-    try {
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const tasks = await backend.listTasks();
-        if (backend.writeTasks) {
-            await backend.writeTasks(tasks);
-        }
-        else {
-            for (const task of tasks)
-                await backend.writeTask(task);
-        }
-        if (!flags.quiet) {
-            process.stdout.write(`${successMessage("normalized tasks", undefined, `count=${tasks.length}`)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task normalize", root: opts.rootOverride ?? null });
-    }
-}
-function parseTaskMigrateFlags(args) {
-    const out = { quiet: false, force: false };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (arg === "--quiet") {
-            out.quiet = true;
-            continue;
-        }
-        if (arg === "--force") {
-            out.force = true;
-            continue;
-        }
-        if (arg === "--source") {
-            const next = args[i + 1];
-            if (!next)
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: missingValueMessage("--source"),
-                });
-            out.source = next;
-            i++;
-            continue;
-        }
-        if (arg.startsWith("--")) {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-        }
-    }
-    return out;
-}
-export async function cmdTaskMigrate(opts) {
-    const flags = parseTaskMigrateFlags(opts.args);
-    if (flags.force) {
-        // Force is accepted for parity; no additional checks in node CLI.
-    }
-    try {
-        const { backend, resolved, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const source = flags.source ?? config.paths.tasks_path;
-        const sourcePath = path.join(resolved.gitRoot, source);
-        const raw = await readFile(sourcePath, "utf8");
-        const parsed = JSON.parse(raw);
-        const tasks = Array.isArray(parsed.tasks) ? parsed.tasks : [];
-        if (backend.writeTasks) {
-            await backend.writeTasks(tasks);
-        }
-        else {
-            for (const task of tasks)
-                await backend.writeTask(task);
-        }
-        if (!flags.quiet) {
-            process.stdout.write(`${successMessage("migrated tasks into backend", undefined, `count=${tasks.length}`)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task migrate", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdTaskComment(opts) {
-    try {
-        const { backend, task } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-            taskId: opts.taskId,
-        });
-        const existing = Array.isArray(task.comments)
-            ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
-            : [];
-        const next = {
-            ...task,
-            comments: [...existing, { author: opts.author, body: opts.body }],
-            doc_version: 2,
-            doc_updated_at: nowIso(),
-            doc_updated_by: opts.author,
-        };
-        await backend.writeTask(next);
-        process.stdout.write(`${successMessage("commented", opts.taskId)}\n`);
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task comment", root: opts.rootOverride ?? null });
-    }
-}
-async function readCommitInfo(cwd, rev) {
-    const { stdout } = await execFileAsync("git", ["log", "-1", "--pretty=%H:%s", rev], { cwd });
-    const trimmed = stdout.trim();
-    const [hash, message] = trimmed.split(":", 2);
-    if (!hash || !message) {
-        throw new Error("Unable to read git commit");
-    }
-    return { hash, message };
-}
-function defaultCommitEmojiForStatus(status) {
-    const normalized = status.trim().toUpperCase();
-    if (normalized === "DOING")
-        return "🚧";
-    if (normalized === "DONE")
-        return "✅";
-    if (normalized === "BLOCKED")
-        return "⛔";
-    return "🧩";
-}
-export async function cmdTaskSetStatus(opts) {
-    const nextStatus = normalizeTaskStatus(opts.status);
-    if (nextStatus === "DONE" && !opts.force) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Use `agentplane finish` to mark DONE (use --force to override)",
-        });
-    }
-    if ((opts.author && !opts.body) || (opts.body && !opts.author)) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "--author and --body must be provided together",
-        });
-    }
-    try {
-        const { backend, task, config, resolved } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-            taskId: opts.taskId,
-        });
-        if (opts.commitFromComment) {
-            enforceStatusCommitPolicy({
-                policy: config.status_commit_policy,
-                action: "task set-status",
-                confirmed: opts.confirmStatusCommit,
-                quiet: opts.quiet,
-            });
-        }
-        const currentStatus = String(task.status || "TODO").toUpperCase();
-        if (!opts.force && !isTransitionAllowed(currentStatus, nextStatus)) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: `Refusing status transition ${currentStatus} -> ${nextStatus} (use --force to override)`,
-            });
-        }
-        if (!opts.force && (nextStatus === "DOING" || nextStatus === "DONE")) {
-            const allTasks = await backend.listTasks();
-            const depState = buildDependencyState(allTasks);
-            const dep = depState.get(task.id);
-            if (dep && (dep.missing.length > 0 || dep.incomplete.length > 0)) {
-                if (!opts.quiet) {
-                    if (dep.missing.length > 0) {
-                        process.stderr.write(`${warnMessage(`missing deps: ${dep.missing.join(", ")}`)}\n`);
-                    }
-                    if (dep.incomplete.length > 0) {
-                        process.stderr.write(`${warnMessage(`incomplete deps: ${dep.incomplete.join(", ")}`)}\n`);
-                    }
-                }
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `Task is not ready: ${task.id} (use --force to override)`,
-                });
-            }
-        }
-        const existingComments = Array.isArray(task.comments)
-            ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
-            : [];
-        let comments = existingComments;
-        if (opts.author && opts.body) {
-            const commentBody = opts.commitFromComment
-                ? formatCommentBodyForCommit(opts.body, config)
-                : opts.body;
-            comments = [...existingComments, { author: opts.author, body: commentBody }];
-        }
-        const next = {
-            ...task,
-            status: nextStatus,
-            comments,
-            doc_version: 2,
-            doc_updated_at: nowIso(),
-            doc_updated_by: resolveDocUpdatedBy(task, opts.author),
-        };
-        if (opts.commit) {
-            const commitInfo = await readCommitInfo(resolved.gitRoot, opts.commit);
-            next.commit = { hash: commitInfo.hash, message: commitInfo.message };
-        }
-        await backend.writeTask(next);
-        if (backend.exportTasksJson) {
-            const outPath = path.join(resolved.gitRoot, config.paths.tasks_path);
-            await backend.exportTasksJson(outPath);
-        }
-        if (opts.commitFromComment) {
-            if (!opts.body) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "--body is required when using --commit-from-comment",
-                });
-            }
-            await commitFromComment({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride,
-                taskId: opts.taskId,
-                commentBody: opts.body,
-                formattedComment: formatCommentBodyForCommit(opts.body, config),
-                emoji: opts.commitEmoji ?? defaultCommitEmojiForStatus(nextStatus),
-                allow: opts.commitAllow,
-                autoAllow: opts.commitAutoAllow || opts.commitAllow.length === 0,
-                allowTasks: opts.commitAllowTasks,
-                requireClean: opts.commitRequireClean,
-                quiet: opts.quiet,
-                config,
-            });
-        }
-        if (!opts.quiet) {
-            process.stdout.write(`${successMessage("status", opts.taskId, `next=${nextStatus}`)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "task set-status", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdTaskShow(opts) {
-    try {
-        const { task, backendId } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const frontmatter = taskDataToFrontmatter(task);
-        if (backendId === "local") {
-            const metadataErrors = validateTaskDocMetadata(frontmatter);
-            if (metadataErrors.length > 0) {
-                throw new CliError({
-                    exitCode: 3,
-                    code: "E_VALIDATION",
-                    message: `Invalid task README metadata: ${metadataErrors.join("; ")}`,
-                });
-            }
-        }
-        process.stdout.write(`${JSON.stringify(frontmatter, null, 2)}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, {
-            command: "task show",
-            root: opts.rootOverride ?? null,
-            taskId: opts.taskId,
-        });
-    }
-}
-export async function cmdTaskList(opts) {
-    return await cmdTaskListWithFilters(opts);
-}
-export async function cmdTaskExport(opts) {
-    try {
-        const { backend, resolved, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const outPath = path.join(resolved.gitRoot, config.paths.tasks_path);
-        if (!backend.exportTasksJson) {
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: backendNotSupportedMessage("exportTasksJson()"),
-            });
-        }
-        await backend.exportTasksJson(outPath);
-        process.stdout.write(`${path.relative(resolved.gitRoot, outPath)}\n`);
-        return 0;
-    }
-    catch (err) {
-        throw mapBackendError(err, { command: "task export", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdTaskLint(opts) {
-    try {
-        const result = await lintTasksFile({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
-        if (result.errors.length > 0) {
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: result.errors.join("\n"),
-            });
-        }
-        process.stdout.write("OK\n");
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "task lint", root: opts.rootOverride ?? null });
-    }
-}
+// Thin public re-export layer: keep CLI imports stable while command implementations live by domain.
 export const IDE_SYNC_USAGE = "Usage: agentplane ide sync";
 export const IDE_SYNC_USAGE_EXAMPLE = "agentplane ide sync";
-export const GUARD_COMMIT_USAGE = "Usage: agentplane guard commit <task-id> -m <message> --allow <path> [--allow <path>...] [--auto-allow] [--allow-tasks] [--require-clean] [--quiet]";
-export const GUARD_COMMIT_USAGE_EXAMPLE = 'agentplane guard commit 202602030608-F1Q8AB -m "✨ F1Q8AB update" --allow packages/agentplane';
-export const COMMIT_USAGE = "Usage: agentplane commit <task-id> -m <message>";
-export const COMMIT_USAGE_EXAMPLE = 'agentplane commit 202602030608-F1Q8AB -m "✨ F1Q8AB update"';
-export const START_USAGE = "Usage: agentplane start <task-id> --author <id> --body <text> [flags]";
-export const START_USAGE_EXAMPLE = 'agentplane start 202602030608-F1Q8AB --author CODER --body "Start: ..."';
-export const BLOCK_USAGE = "Usage: agentplane block <task-id> --author <id> --body <text> [flags]";
-export const BLOCK_USAGE_EXAMPLE = 'agentplane block 202602030608-F1Q8AB --author CODER --body "Blocked: ..."';
-export const FINISH_USAGE = "Usage: agentplane finish <task-id> [<task-id>...] --author <id> --body <text> [flags]";
-export const FINISH_USAGE_EXAMPLE = 'agentplane finish 202602030608-F1Q8AB --author INTEGRATOR --body "Verified: ..."';
-export const VERIFY_USAGE = "Usage: agentplane verify <task-id> [--cwd <path>] [--log <path>] [--skip-if-unchanged] [--quiet] [--require] [--yes]";
-export const VERIFY_USAGE_EXAMPLE = "agentplane verify 202602030608-F1Q8AB";
-export const WORK_START_USAGE = "Usage: agentplane work start <task-id> --agent <id> --slug <slug> --worktree";
-export const WORK_START_USAGE_EXAMPLE = "agentplane work start 202602030608-F1Q8AB --agent CODER --slug cli --worktree";
-export const PR_OPEN_USAGE = "Usage: agentplane pr open <task-id> --author <id> [--branch <name>]";
-export const PR_OPEN_USAGE_EXAMPLE = "agentplane pr open 202602030608-F1Q8AB --author CODER";
-export const PR_UPDATE_USAGE = "Usage: agentplane pr update <task-id>";
-export const PR_UPDATE_USAGE_EXAMPLE = "agentplane pr update 202602030608-F1Q8AB";
-export const PR_CHECK_USAGE = "Usage: agentplane pr check <task-id>";
-export const PR_CHECK_USAGE_EXAMPLE = "agentplane pr check 202602030608-F1Q8AB";
-export const PR_NOTE_USAGE = "Usage: agentplane pr note <task-id> --author <id> --body <text>";
-export const PR_NOTE_USAGE_EXAMPLE = 'agentplane pr note 202602030608-F1Q8AB --author REVIEWER --body "..."';
-export const INTEGRATE_USAGE = "Usage: agentplane integrate <task-id> [--branch <name>] [--base <name>] [--merge-strategy squash|merge|rebase] [--run-verify] [--dry-run] [--quiet]";
-export const INTEGRATE_USAGE_EXAMPLE = "agentplane integrate 202602030608-F1Q8AB --run-verify";
-export const CLEANUP_MERGED_USAGE = "Usage: agentplane cleanup merged [--base <name>] [--yes] [--archive] [--quiet]";
-export const CLEANUP_MERGED_USAGE_EXAMPLE = "agentplane cleanup merged --yes";
-function pathIsUnder(candidate, prefix) {
-    if (prefix === "." || prefix === "")
-        return true;
-    if (candidate === prefix)
-        return true;
-    return candidate.startsWith(`${prefix}/`);
-}
-function normalizeAllowPrefix(prefix) {
-    return prefix.replace(/\/+$/, "");
-}
-function nowIso() {
-    return new Date().toISOString();
-}
-const ALLOWED_TASK_STATUSES = new Set(["TODO", "DOING", "DONE", "BLOCKED"]);
-function normalizeTaskStatus(value) {
-    const normalized = value.trim().toUpperCase();
-    if (!ALLOWED_TASK_STATUSES.has(normalized)) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: invalidValueMessage("status", value, `one of ${[...ALLOWED_TASK_STATUSES].join(", ")}`),
-        });
-    }
-    return normalized;
-}
-export function dedupeStrings(items) {
-    const seen = new Set();
-    const out = [];
-    for (const item of items) {
-        const trimmed = item.trim();
-        if (!trimmed)
-            continue;
-        if (seen.has(trimmed))
-            continue;
-        seen.add(trimmed);
-        out.push(trimmed);
-    }
-    return out;
-}
-function extractDocSection(doc, sectionName) {
-    const target = normalizeDocSectionName(sectionName);
-    if (!target)
-        return null;
-    const lines = doc.replaceAll("\r\n", "\n").split("\n");
-    let capturing = false;
-    const out = [];
-    for (const line of lines) {
-        const match = /^##\s+(.*)$/.exec(line.trim());
-        if (match) {
-            const key = normalizeDocSectionName(match[1] ?? "");
-            if (capturing)
-                break;
-            capturing = key === target;
-            continue;
-        }
-        if (capturing)
-            out.push(line);
-    }
-    if (!capturing)
-        return null;
-    return out.join("\n").trimEnd();
-}
-function stripListMarker(line) {
-    return line.replace(/^(?:[-*]|\d+\.)\s+/, "");
-}
-function parseVerifyStepsFromDoc(doc) {
-    const section = extractDocSection(doc, "Verify Steps");
-    if (!section)
-        return { commands: [], steps: [] };
-    const commands = [];
-    const steps = [];
-    const lines = section.split("\n");
-    let inFence = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        if (trimmed.startsWith("```")) {
-            inFence = !inFence;
-            continue;
-        }
-        if (inFence)
-            continue;
-        const normalized = stripListMarker(trimmed);
-        const lower = normalized.toLowerCase();
-        if (lower.startsWith("cmd:")) {
-            const command = normalized.slice(4).trim();
-            if (command)
-                commands.push(command);
-            continue;
-        }
-        steps.push(normalized);
-    }
-    return { commands, steps };
-}
-function renderVerificationSection(opts) {
-    const lines = [
-        `Status: ${opts.status}`,
-        `Verified at: ${opts.verifiedAt}`,
-        ...(opts.verifiedSha ? [`Verified sha: ${opts.verifiedSha}`] : []),
-        ...(opts.commands.length > 0
-            ? ["", "Commands:", ...opts.commands.map((command) => `- ${command}`)]
-            : []),
-        ...(opts.steps.length > 0
-            ? ["", "Manual steps:", ...opts.steps.map((step) => `- ${step}`)]
-            : []),
-        ...(opts.details ? ["", `Details: ${opts.details}`] : []),
-    ];
-    return lines.join("\n");
-}
-async function writeVerificationSection(opts) {
-    if (!opts.backend.getTaskDoc || !opts.backend.setTaskDoc) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: backendNotSupportedMessage("task docs"),
-        });
-    }
-    const baseDoc = ensureDocSections(opts.baseDoc ?? "", opts.config.tasks.doc.required_sections);
-    const nextDoc = setMarkdownSection(baseDoc, "Verification", opts.content);
-    const normalized = ensureDocSections(nextDoc, opts.config.tasks.doc.required_sections);
-    await opts.backend.setTaskDoc(opts.taskId, normalized, opts.updatedBy);
-}
-function toStringArray(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value
-        .filter((item) => typeof item === "string")
-        .map((item) => item.trim());
-}
-function requiresVerify(tags, requiredTags) {
-    const required = new Set(requiredTags.map((tag) => tag.trim().toLowerCase()).filter(Boolean));
-    if (required.size === 0)
-        return false;
-    return tags.some((tag) => required.has(tag.trim().toLowerCase()));
-}
-function buildDependencyState(tasks) {
-    const byId = new Map(tasks.map((task) => [task.id, task]));
-    const state = new Map();
-    for (const task of tasks) {
-        const dependsOn = dedupeStrings(toStringArray(task.depends_on));
-        const missing = [];
-        const incomplete = [];
-        for (const depId of dependsOn) {
-            const dep = byId.get(depId);
-            if (!dep) {
-                missing.push(depId);
-                continue;
-            }
-            const status = String(dep.status || "TODO").toUpperCase();
-            if (status !== "DONE") {
-                incomplete.push(depId);
-            }
-        }
-        state.set(task.id, { dependsOn, missing, incomplete });
-    }
-    return state;
-}
-function formatDepsSummary(dep) {
-    if (!dep)
-        return null;
-    if (dep.dependsOn.length === 0)
-        return "deps=none";
-    if (dep.missing.length === 0 && dep.incomplete.length === 0)
-        return "deps=ready";
-    const parts = [];
-    if (dep.missing.length > 0) {
-        parts.push(`missing:${dep.missing.join(",")}`);
-    }
-    if (dep.incomplete.length > 0) {
-        parts.push(`wait:${dep.incomplete.join(",")}`);
-    }
-    return `deps=${parts.join(",")}`;
-}
-function formatTaskLine(task, depState) {
-    const status = String(task.status || "TODO").toUpperCase();
-    const title = task.title?.trim() || "(untitled task)";
-    const extras = [];
-    if (task.owner?.trim())
-        extras.push(`owner=${task.owner.trim()}`);
-    if (task.priority !== undefined && String(task.priority).trim()) {
-        extras.push(`prio=${String(task.priority).trim()}`);
-    }
-    const depsSummary = formatDepsSummary(depState);
-    if (depsSummary)
-        extras.push(depsSummary);
-    const tags = dedupeStrings(toStringArray(task.tags));
-    if (tags.length > 0)
-        extras.push(`tags=${tags.join(",")}`);
-    const verify = dedupeStrings(toStringArray(task.verify));
-    if (verify.length > 0)
-        extras.push(`verify=${verify.length}`);
-    const suffix = extras.length > 0 ? ` (${extras.join(", ")})` : "";
-    return `${task.id} [${status}] ${title}${suffix}`;
-}
-function isTransitionAllowed(current, next) {
-    if (current === next)
-        return true;
-    if (current === "TODO")
-        return next === "DOING" || next === "BLOCKED";
-    if (current === "DOING")
-        return next === "DONE" || next === "BLOCKED";
-    if (current === "BLOCKED")
-        return next === "TODO" || next === "DOING";
-    if (current === "DONE")
-        return false;
-    return false;
-}
-function requireStructuredComment(body, prefix, minChars) {
-    const normalized = body.trim();
-    if (!normalized.toLowerCase().startsWith(prefix.toLowerCase())) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: `Comment body must start with ${prefix}`,
-        });
-    }
-    if (normalized.length < minChars) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: `Comment body must be at least ${minChars} characters`,
-        });
-    }
-}
-async function readHeadCommit(cwd) {
-    const { stdout } = await execFileAsync("git", ["log", "-1", "--pretty=%H:%s"], { cwd });
-    const trimmed = stdout.trim();
-    const [hash, message] = trimmed.split(":", 2);
-    if (!hash || !message) {
-        throw new Error("Unable to read git HEAD commit");
-    }
-    return { hash, message };
-}
-function deriveCommitMessageFromComment(opts) {
-    const summary = (opts.formattedComment ?? formatCommentBodyForCommit(opts.body, opts.config))
-        .trim()
-        .replaceAll(/\s+/g, " ");
-    if (!summary) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Comment body is required to build a commit message from the task comment",
-        });
-    }
-    const prefix = opts.emoji.trim();
-    if (!prefix) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Emoji prefix is required when deriving commit messages from task comments",
-        });
-    }
-    const suffix = extractTaskSuffix(opts.taskId);
-    if (!suffix) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: invalidValueMessage("task id", opts.taskId, "valid task id"),
-        });
-    }
-    return `${prefix} ${suffix} ${summary}`;
-}
-function enforceStatusCommitPolicy(opts) {
-    if (opts.policy === "off")
-        return;
-    if (opts.policy === "warn") {
-        if (!opts.quiet && !opts.confirmed) {
-            process.stderr.write(`${warnMessage(`${opts.action}: status/comment-driven commit requested; policy=warn (pass --confirm-status-commit to acknowledge)`)}\n`);
-        }
-        return;
-    }
-    if (opts.policy === "confirm" && !opts.confirmed) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: `${opts.action}: status/comment-driven commit blocked by status_commit_policy='confirm' ` +
-                "(pass --confirm-status-commit to proceed)",
-        });
-    }
-}
-export function suggestAllowPrefixes(paths) {
-    const out = new Set();
-    for (const filePath of paths) {
-        if (!filePath)
-            continue;
-        const idx = filePath.lastIndexOf("/");
-        if (idx <= 0)
-            out.add(filePath);
-        else
-            out.add(filePath.slice(0, idx));
-    }
-    return [...out].toSorted((a, b) => a.localeCompare(b));
-}
-const HOOK_MARKER = "agentplane-hook";
-const SHIM_MARKER = "agentplane-hook-shim";
-export const HOOK_NAMES = ["commit-msg", "pre-commit", "pre-push"];
-async function archivePrArtifacts(taskDir) {
-    const prDir = path.join(taskDir, "pr");
-    if (!(await fileExists(prDir)))
-        return null;
-    const archiveRoot = path.join(taskDir, "pr-archive");
-    await mkdir(archiveRoot, { recursive: true });
-    const stamp = new Date().toISOString().replaceAll(/[:.]/g, "");
-    let dest = path.join(archiveRoot, stamp);
-    if (await fileExists(dest)) {
-        dest = path.join(archiveRoot, `${stamp}-${Math.random().toString(36).slice(2, 8)}`);
-    }
-    await rename(prDir, dest);
-    return dest;
-}
-async function resolvePathFallback(filePath) {
-    try {
-        return await realpath(filePath);
-    }
-    catch {
-        return path.resolve(filePath);
-    }
-}
-function isPathWithin(parent, candidate) {
-    const rel = path.relative(parent, candidate);
-    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-}
-async function gitRevParse(cwd, args) {
-    const { stdout } = await execFileAsync("git", ["rev-parse", ...args], { cwd, env: gitEnv() });
-    const trimmed = stdout.trim();
-    if (!trimmed)
-        throw new Error("Failed to resolve git path");
-    return trimmed;
-}
-export async function gitInitRepo(cwd, branch) {
-    try {
-        await execFileAsync("git", ["init", "-q", "-b", branch], { cwd, env: gitEnv() });
-        return;
-    }
-    catch {
-        await execFileAsync("git", ["init", "-q"], { cwd, env: gitEnv() });
-    }
-    try {
-        const current = await gitCurrentBranch(cwd);
-        if (current !== branch) {
-            await execFileAsync("git", ["checkout", "-q", "-b", branch], { cwd, env: gitEnv() });
-        }
-    }
-    catch {
-        await execFileAsync("git", ["checkout", "-q", "-b", branch], { cwd, env: gitEnv() });
-    }
-}
-async function gitCurrentBranch(cwd) {
-    try {
-        const { stdout } = await execFileAsync("git", ["symbolic-ref", "--short", "HEAD"], {
-            cwd,
-            env: gitEnv(),
-        });
-        const trimmed = stdout.trim();
-        if (trimmed)
-            return trimmed;
-    }
-    catch {
-        // fall through
-    }
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-        cwd,
-        env: gitEnv(),
-    });
-    const trimmed = stdout.trim();
-    if (!trimmed || trimmed === "HEAD")
-        throw new Error("Failed to resolve git branch");
-    return trimmed;
-}
-async function gitBranchExists(cwd, branch) {
-    try {
-        await execFileAsync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
-            cwd,
-            env: gitEnv(),
-        });
-        return true;
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code === 1)
-            return false;
-        throw err;
-    }
-}
-async function gitListBranches(cwd) {
-    const { stdout } = await execFileAsync("git", ["branch", "--format=%(refname:short)"], {
-        cwd,
-        env: gitEnv(),
-    });
-    return stdout
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-async function gitStagedPaths(cwd) {
-    const { stdout } = await execFileAsync("git", ["diff", "--cached", "--name-only"], {
-        cwd,
-        env: gitEnv(),
-    });
-    return stdout
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-async function gitAddPaths(cwd, paths) {
-    if (paths.length === 0)
-        return;
-    await execFileAsync("git", ["add", "--", ...paths], { cwd, env: gitEnv() });
-}
-async function gitCommit(cwd, message, opts) {
-    const args = ["commit", "-m", message];
-    if (opts?.skipHooks)
-        args.push("--no-verify");
-    const env = opts?.env ? { ...gitEnv(), ...opts.env } : gitEnv();
-    await execFileAsync("git", args, { cwd, env });
-}
-export async function resolveInitBaseBranch(gitRoot, fallback) {
-    let current = null;
-    try {
-        current = await gitCurrentBranch(gitRoot);
-    }
-    catch {
-        current = null;
-    }
-    const branches = await gitListBranches(gitRoot);
-    if (current)
-        return current;
-    if (branches.includes(fallback))
-        return fallback;
-    if (branches.length > 0) {
-        const first = branches[0];
-        if (first)
-            return first;
-    }
-    return fallback;
-}
-export async function promptInitBaseBranch(opts) {
-    const branches = await gitListBranches(opts.gitRoot);
-    let current = null;
-    try {
-        current = await gitCurrentBranch(opts.gitRoot);
-    }
-    catch {
-        current = null;
-    }
-    const promptNewBranch = async (hasBranches) => {
-        const raw = await promptInput(`Enter new base branch name (default ${opts.fallback}): `);
-        const candidate = raw.trim() || opts.fallback;
-        if (!candidate) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "Base branch name cannot be empty",
-            });
-        }
-        if (await gitBranchExists(opts.gitRoot, candidate))
-            return candidate;
-        try {
-            await execFileAsync("git", hasBranches ? ["branch", candidate] : ["checkout", "-q", "-b", candidate], { cwd: opts.gitRoot, env: gitEnv() });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : `Failed to create branch ${candidate}`;
-            throw new CliError({ exitCode: 5, code: "E_GIT", message });
-        }
-        return candidate;
-    };
-    if (branches.length === 0) {
-        return await promptNewBranch(false);
-    }
-    const createLabel = "Create new branch";
-    const defaultChoice = current && branches.includes(current) ? current : (branches[0] ?? opts.fallback);
-    const choice = await promptChoice("Select base branch", [...branches, createLabel], defaultChoice);
-    if (choice === createLabel) {
-        return await promptNewBranch(true);
-    }
-    return choice;
-}
-export async function ensureInitCommit(opts) {
-    const stagedBefore = await gitStagedPaths(opts.gitRoot);
-    if (stagedBefore.length > 0) {
-        throw new CliError({
-            exitCode: 5,
-            code: "E_GIT",
-            message: "Git index has staged changes; commit or unstage them before running agentplane init.",
-        });
-    }
-    await setPinnedBaseBranch({
-        cwd: opts.gitRoot,
-        rootOverride: opts.gitRoot,
-        value: opts.baseBranch,
-    });
-    const dedupedPaths = [...new Set(opts.installPaths)].filter((entry) => entry.length > 0);
-    await gitAddPaths(opts.gitRoot, dedupedPaths);
-    const staged = await gitStagedPaths(opts.gitRoot);
-    if (staged.length === 0)
-        return;
-    const message = `chore: install agentplane ${opts.version}`;
-    await gitCommit(opts.gitRoot, message, { skipHooks: opts.skipHooks });
-}
-function toGitPath(filePath) {
-    return filePath.split(path.sep).join("/");
-}
-async function gitShowFile(cwd, ref, relPath) {
-    const { stdout } = await execFileAsync("git", ["show", `${ref}:${relPath}`], {
-        cwd,
-        env: gitEnv(),
-    });
-    return stdout;
-}
-async function gitDiffNames(cwd, base, branch) {
-    const { stdout } = await execFileAsync("git", ["diff", "--name-only", `${base}...${branch}`], {
-        cwd,
-        env: gitEnv(),
-    });
-    return stdout
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-async function gitDiffStat(cwd, base, branch) {
-    const { stdout } = await execFileAsync("git", ["diff", "--stat", `${base}...${branch}`], {
-        cwd,
-        env: gitEnv(),
-    });
-    return stdout.trimEnd();
-}
-async function gitAheadBehind(cwd, base, branch) {
-    const { stdout } = await execFileAsync("git", ["rev-list", "--left-right", "--count", `${base}...${branch}`], { cwd, env: gitEnv() });
-    const trimmed = stdout.trim();
-    if (!trimmed)
-        return { ahead: 0, behind: 0 };
-    const parts = trimmed.split(/\s+/);
-    if (parts.length !== 2)
-        return { ahead: 0, behind: 0 };
-    const behind = Number.parseInt(parts[0] ?? "0", 10) || 0;
-    const ahead = Number.parseInt(parts[1] ?? "0", 10) || 0;
-    return { ahead, behind };
-}
-async function listWorktrees(cwd) {
-    const { stdout } = await execFileAsync("git", ["worktree", "list", "--porcelain"], {
-        cwd,
-        env: gitEnv(),
-    });
-    const worktrees = [];
-    const lines = stdout.split("\n");
-    let current = null;
-    for (const line of lines) {
-        if (line.startsWith("worktree ")) {
-            if (current)
-                worktrees.push(current);
-            current = { path: line.slice("worktree ".length).trim(), branch: null };
-            continue;
-        }
-        if (line.startsWith("branch ") && current) {
-            current.branch = line.slice("branch ".length).trim();
-        }
-    }
-    if (current)
-        worktrees.push(current);
-    return worktrees;
-}
-async function findWorktreeForBranch(cwd, branch) {
-    const target = branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`;
-    const worktrees = await listWorktrees(cwd);
-    const match = worktrees.find((entry) => entry.branch === branch || entry.branch === target || entry.branch === `refs/heads/${branch}`);
-    return match ? match.path : null;
-}
-function stripBranchRef(branch) {
-    return branch.startsWith("refs/heads/") ? branch.slice("refs/heads/".length) : branch;
-}
-function parseTaskIdFromBranch(prefix, branch) {
-    const normalized = stripBranchRef(branch);
-    if (!normalized.startsWith(`${prefix}/`))
-        return null;
-    const rest = normalized.slice(prefix.length + 1);
-    const taskId = rest.split("/", 1)[0];
-    return taskId ? taskId.trim() : null;
-}
-async function gitListTaskBranches(cwd, prefix) {
-    const { stdout } = await execFileAsync("git", ["for-each-ref", "--format=%(refname:short)", `refs/heads/${prefix}`], { cwd, env: gitEnv() });
-    return stdout
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-async function resolveGitHooksDir(cwd) {
-    const repoRoot = await gitRevParse(cwd, ["--show-toplevel"]);
-    const commonDirRaw = await gitRevParse(cwd, ["--git-common-dir"]);
-    const hooksRaw = await gitRevParse(cwd, ["--git-path", "hooks"]);
-    const commonDir = path.resolve(path.isAbsolute(commonDirRaw) ? commonDirRaw : path.join(repoRoot, commonDirRaw));
-    const hooksDir = path.resolve(path.isAbsolute(hooksRaw) ? hooksRaw : path.join(repoRoot, hooksRaw));
-    const resolvedRoot = path.resolve(repoRoot);
-    if (!isPathWithin(resolvedRoot, hooksDir) && !isPathWithin(commonDir, hooksDir)) {
-        throw new CliError({
-            exitCode: 5,
-            code: "E_GIT",
-            message: [
-                "Refusing to manage git hooks outside the repository.",
-                `hooks_path=${hooksDir}`,
-                `repo_root=${resolvedRoot}`,
-                `common_dir=${commonDir}`,
-                "Fix:",
-                "  1) Use a repo-relative core.hooksPath (e.g., .git/hooks)",
-                "  2) Re-run `agentplane hooks install`",
-            ].join("\n"),
-        });
-    }
-    return hooksDir;
-}
-async function fileIsManaged(filePath, marker) {
-    try {
-        const content = await readFile(filePath, "utf8");
-        return content.includes(marker);
-    }
-    catch {
-        return false;
-    }
-}
-function hookScriptText(hook) {
-    return [
-        "#!/usr/bin/env sh",
-        `# ${HOOK_MARKER} (do not edit)`,
-        "set -e",
-        "if ! command -v agentplane >/dev/null 2>&1; then",
-        '  echo "agentplane hooks: agentplane not found in PATH" >&2',
-        "  exit 1",
-        "fi",
-        "exec agentplane hooks run " + hook + ' "$@"',
-        "",
-    ].join("\n");
-}
-function shimScriptText() {
-    return [
-        "#!/usr/bin/env sh",
-        `# ${SHIM_MARKER} (do not edit)`,
-        "set -e",
-        "if ! command -v agentplane >/dev/null 2>&1; then",
-        '  echo "agentplane shim: agentplane not found in PATH" >&2',
-        "  exit 1",
-        "fi",
-        'exec agentplane "$@"',
-        "",
-    ].join("\n");
-}
-function validateWorkSlug(slug) {
-    const trimmed = slug.trim();
-    if (!trimmed) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(WORK_START_USAGE, WORK_START_USAGE_EXAMPLE),
-        });
-    }
-    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(trimmed)) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Slug must be lowercase kebab-case (a-z, 0-9, hyphen)",
-        });
-    }
-}
-function validateWorkAgent(agent) {
-    const trimmed = agent.trim();
-    if (!trimmed) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(WORK_START_USAGE, WORK_START_USAGE_EXAMPLE),
-        });
-    }
-    if (!/^[A-Z0-9_]+$/.test(trimmed)) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Agent id must be uppercase letters, numbers, or underscores",
-        });
-    }
-}
-function isRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isIsoDate(value) {
-    return typeof value === "string" && !Number.isNaN(Date.parse(value));
-}
-function parsePrMeta(raw, taskId) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`JSON Parse error: ${message}`);
-    }
-    if (!isRecord(parsed))
-        throw new Error("pr/meta.json must be an object");
-    if (parsed.schema_version !== 1)
-        throw new Error("pr/meta.json schema_version must be 1");
-    if (parsed.task_id !== taskId)
-        throw new Error("pr/meta.json task_id mismatch");
-    if (!isIsoDate(parsed.created_at))
-        throw new Error("pr/meta.json created_at must be ISO");
-    if (!isIsoDate(parsed.updated_at))
-        throw new Error("pr/meta.json updated_at must be ISO");
-    return parsed;
-}
-function extractLastVerifiedSha(logText) {
-    const regex = /verified_sha=([0-9a-f]{7,40})/gi;
-    let match = null;
-    let last = null;
-    while ((match = regex.exec(logText))) {
-        last = match[1] ?? null;
-    }
-    return last;
-}
-async function appendVerifyLog(logPath, header, content) {
-    await mkdir(path.dirname(logPath), { recursive: true });
-    const lines = [header.trimEnd()];
-    if (content)
-        lines.push(content.trimEnd());
-    lines.push("");
-    await writeFile(logPath, `${lines.join("\n")}\n`, { flag: "a" });
-}
-async function runShellCommand(command, cwd) {
-    try {
-        const { stdout, stderr } = await execFileAsync("sh", ["-lc", command], {
-            cwd,
-            env: process.env,
-            maxBuffer: 10 * 1024 * 1024,
-        });
-        let output = "";
-        if (stdout)
-            output += stdout;
-        if (stderr)
-            output += (output && !output.endsWith("\n") ? "\n" : "") + stderr;
-        return { code: 0, output };
-    }
-    catch (err) {
-        const error = err;
-        let output = "";
-        if (error.stdout)
-            output += String(error.stdout);
-        if (error.stderr)
-            output += (output && !output.endsWith("\n") ? "\n" : "") + String(error.stderr);
-        const code = typeof error.code === "number" ? error.code : 1;
-        return { code, output };
-    }
-}
-function renderPrReviewTemplate(opts) {
-    return [
-        "# PR Review",
-        "",
-        `Opened by ${opts.author} on ${opts.createdAt}`,
-        `Branch: ${opts.branch}`,
-        "",
-        "## Summary",
-        "",
-        "- ",
-        "",
-        "## Checklist",
-        "",
-        "- [ ] Tests added/updated",
-        "- [ ] Lint/format passes",
-        "- [ ] Docs updated",
-        "",
-        "## Handoff Notes",
-        "",
-        "- ",
-        "",
-        "<!-- BEGIN AUTO SUMMARY -->",
-        "<!-- END AUTO SUMMARY -->",
-        "",
-    ].join("\n");
-}
-function updateAutoSummaryBlock(body, summary) {
-    const begin = "<!-- BEGIN AUTO SUMMARY -->";
-    const end = "<!-- END AUTO SUMMARY -->";
-    const normalizedBody = body.replaceAll("\r\n", "\n");
-    const beginIndex = normalizedBody.indexOf(begin);
-    const endIndex = normalizedBody.indexOf(end);
-    const block = `${begin}\n${summary}\n${end}`;
-    if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
-        const before = normalizedBody.slice(0, beginIndex);
-        const after = normalizedBody.slice(endIndex + end.length);
-        return `${before}${block}${after}`;
-    }
-    const trimmed = normalizedBody.trimEnd();
-    return `${trimmed}\n\n${block}\n`;
-}
-function appendHandoffNote(body, noteLine) {
-    const normalized = body.replaceAll("\r\n", "\n");
-    const heading = "## Handoff Notes";
-    const lines = normalized.split("\n");
-    const headingIndex = lines.findIndex((line) => line.trim() === heading);
-    const note = `- ${noteLine}`;
-    if (headingIndex === -1) {
-        const trimmed = normalized.trimEnd();
-        return `${trimmed}\n\n${heading}\n\n${note}\n`;
-    }
-    let nextHeading = lines.length;
-    for (let i = headingIndex + 1; i < lines.length; i++) {
-        if (lines[i]?.startsWith("## ")) {
-            nextHeading = i;
-            break;
-        }
-    }
-    const before = lines.slice(0, nextHeading);
-    const after = lines.slice(nextHeading);
-    if (before.at(-1)?.trim() !== "")
-        before.push("");
-    before.push(note, "");
-    return [...before, ...after].join("\n");
-}
-async function ensureShim(agentplaneDir, gitRoot) {
-    const shimDir = path.join(agentplaneDir, "bin");
-    const shimPath = path.join(shimDir, "agentplane");
-    await mkdir(shimDir, { recursive: true });
-    if (await fileExists(shimPath)) {
-        const managed = await fileIsManaged(shimPath, SHIM_MARKER);
-        if (!managed) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `Refusing to overwrite existing shim: ${path.relative(gitRoot, shimPath)}`,
-            });
-        }
-    }
-    await writeFile(shimPath, shimScriptText(), "utf8");
-    await chmod(shimPath, 0o755);
-}
-function readCommitSubject(message) {
-    for (const line of message.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#"))
-            continue;
-        return trimmed;
-    }
-    return "";
-}
-function subjectHasSuffix(subject, suffixes) {
-    const lowered = subject.toLowerCase();
-    return suffixes.some((suffix) => suffix && lowered.includes(suffix.toLowerCase()));
-}
-export async function cmdGuardClean(opts) {
-    try {
-        const staged = await getStagedFiles({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
-        if (staged.length > 0) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: "Staged files exist",
-            });
-        }
-        if (!opts.quiet) {
-            process.stdout.write(`${successMessage("index clean", undefined, "no staged files")}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "guard clean", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdGuardSuggestAllow(opts) {
-    try {
-        const staged = await getStagedFiles({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
-        if (staged.length === 0) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "No staged files (git index empty)",
-            });
-        }
-        const prefixes = suggestAllowPrefixes(staged);
-        if (opts.format === "args") {
-            const args = prefixes.map((p) => `--allow ${p}`).join(" ");
-            process.stdout.write(`${args}\n`);
-        }
-        else {
-            for (const prefix of prefixes)
-                process.stdout.write(`${prefix}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        throw mapCoreError(err, { command: "guard suggest-allow", root: opts.rootOverride ?? null });
-    }
-}
-async function guardCommitCheck(opts) {
-    const resolved = await resolveProject({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride ?? null,
-    });
-    const loaded = await loadConfig(resolved.agentplaneDir);
-    const policy = validateCommitSubject({
-        subject: opts.message,
-        taskId: opts.taskId,
-        genericTokens: loaded.config.commit.generic_tokens,
-    });
-    if (!policy.ok) {
-        throw new CliError({ exitCode: 5, code: "E_GIT", message: policy.errors.join("\n") });
-    }
-    const staged = await getStagedFiles({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
-    if (staged.length === 0) {
-        throw new CliError({
-            exitCode: 5,
-            code: "E_GIT",
-            message: "No staged files (git index empty)",
-        });
-    }
-    if (opts.allow.length === 0) {
-        throw new CliError({
-            exitCode: 5,
-            code: "E_GIT",
-            message: "Provide at least one --allow <path> prefix",
-        });
-    }
-    const allow = opts.allow.map((prefix) => normalizeAllowPrefix(prefix));
-    const denied = new Set();
-    if (!opts.allowTasks)
-        denied.add(".agentplane/tasks.json");
-    if (opts.requireClean) {
-        const unstaged = await getUnstagedFiles({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        if (unstaged.length > 0) {
-            throw new CliError({ exitCode: 5, code: "E_GIT", message: "Working tree is dirty" });
-        }
-    }
-    for (const filePath of staged) {
-        if (denied.has(filePath)) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `Staged file is forbidden by default: ${filePath} (use --allow-tasks to override)`,
-            });
-        }
-        if (!allow.some((prefix) => pathIsUnder(filePath, prefix))) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `Staged file is outside allowlist: ${filePath}`,
-            });
-        }
-    }
-}
-async function gitStatusChangedPaths(opts) {
-    const resolved = await resolveProject({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride ?? null,
-    });
-    const { stdout } = await execFileAsync("git", ["status", "--porcelain", "-uall"], {
-        cwd: resolved.gitRoot,
-    });
-    const files = [];
-    for (const line of stdout.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        const filePart = trimmed.slice(2).trim();
-        if (!filePart)
-            continue;
-        const name = filePart.includes("->") ? filePart.split("->").at(-1)?.trim() : filePart;
-        if (name)
-            files.push(name);
-    }
-    return files;
-}
-async function ensureGitClean(opts) {
-    const staged = await getStagedFiles({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
-    if (staged.length > 0) {
-        throw new CliError({ exitCode: 5, code: "E_GIT", message: "Working tree has staged changes" });
-    }
-    const unstaged = await getUnstagedFiles({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride ?? null,
-    });
-    if (unstaged.length > 0) {
-        throw new CliError({
-            exitCode: 5,
-            code: "E_GIT",
-            message: "Working tree has unstaged changes",
-        });
-    }
-}
-async function stageAllowlist(opts) {
-    const resolved = await resolveProject({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride ?? null,
-    });
-    const changed = await gitStatusChangedPaths({ cwd: opts.cwd, rootOverride: opts.rootOverride });
-    if (changed.length === 0) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "No changes to stage (working tree clean)",
-        });
-    }
-    const allow = opts.allow.map((prefix) => normalizeAllowPrefix(prefix.trim().replace(/^\.?\//, "")));
-    const denied = new Set();
-    if (!opts.allowTasks)
-        denied.add(".agentplane/tasks.json");
-    const staged = [];
-    for (const filePath of changed) {
-        if (denied.has(filePath))
-            continue;
-        if (allow.some((prefix) => pathIsUnder(filePath, prefix))) {
-            staged.push(filePath);
-        }
-    }
-    const unique = [...new Set(staged)].toSorted((a, b) => a.localeCompare(b));
-    if (unique.length === 0) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "No changes matched allowed prefixes (use --commit-auto-allow or update --commit-allow)",
-        });
-    }
-    await execFileAsync("git", ["add", "--", ...unique], { cwd: resolved.gitRoot });
-    return unique;
-}
-async function commitFromComment(opts) {
-    let allowPrefixes = opts.allow.map((prefix) => prefix.trim()).filter(Boolean);
-    if (opts.autoAllow && allowPrefixes.length === 0) {
-        const changed = await gitStatusChangedPaths({ cwd: opts.cwd, rootOverride: opts.rootOverride });
-        allowPrefixes = suggestAllowPrefixes(changed);
-    }
-    if (allowPrefixes.length === 0) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Provide at least one --commit-allow prefix or enable --commit-auto-allow",
-        });
-    }
-    const staged = await stageAllowlist({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride,
-        allow: allowPrefixes,
-        allowTasks: opts.allowTasks,
-    });
-    const message = deriveCommitMessageFromComment({
-        taskId: opts.taskId,
-        body: opts.commentBody,
-        emoji: opts.emoji,
-        formattedComment: opts.formattedComment,
-        config: opts.config,
-    });
-    await guardCommitCheck({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride,
-        taskId: opts.taskId,
-        message,
-        allow: allowPrefixes,
-        allowTasks: opts.allowTasks,
-        requireClean: opts.requireClean,
-        quiet: opts.quiet,
-    });
-    const resolved = await resolveProject({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride ?? null,
-    });
-    const env = {
-        ...process.env,
-        AGENTPLANE_TASK_ID: opts.taskId,
-        AGENTPLANE_ALLOW_TASKS: opts.allowTasks ? "1" : "0",
-        AGENTPLANE_ALLOW_BASE: opts.allowTasks ? "1" : "0",
-    };
-    await execFileAsync("git", ["commit", "-m", message], { cwd: resolved.gitRoot, env });
-    const { stdout } = await execFileAsync("git", ["log", "-1", "--pretty=%H:%s"], {
-        cwd: resolved.gitRoot,
-    });
-    const trimmed = stdout.trim();
-    const [hash, subject] = trimmed.split(":", 2);
-    if (!opts.quiet) {
-        process.stdout.write(`${successMessage("committed", `${hash?.slice(0, 12) ?? ""} ${subject ?? ""}`.trim(), `staged=${staged.join(", ")}`)}\n`);
-    }
-    return { hash: hash ?? "", message: subject ?? "", staged };
-}
-export async function cmdGuardCommit(opts) {
-    try {
-        await guardCommitCheck(opts);
-        if (!opts.quiet)
-            process.stdout.write("OK\n");
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "guard commit", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdCommit(opts) {
-    try {
-        let allow = opts.allow;
-        if (opts.autoAllow && allow.length === 0) {
-            const staged = await getStagedFiles({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride ?? null,
-            });
-            const prefixes = suggestAllowPrefixes(staged);
-            if (prefixes.length === 0) {
-                throw new CliError({
-                    exitCode: 5,
-                    code: "E_GIT",
-                    message: "No staged files (git index empty)",
-                });
-            }
-            allow = prefixes;
-        }
-        await guardCommitCheck({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-            message: opts.message,
-            allow,
-            allowTasks: opts.allowTasks,
-            requireClean: opts.requireClean,
-            quiet: opts.quiet,
-        });
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const env = {
-            ...process.env,
-            AGENTPLANE_TASK_ID: opts.taskId,
-            AGENTPLANE_ALLOW_TASKS: opts.allowTasks ? "1" : "0",
-            AGENTPLANE_ALLOW_BASE: opts.allowBase ? "1" : "0",
-        };
-        await execFileAsync("git", ["commit", "-m", opts.message], { cwd: resolved.gitRoot, env });
-        if (!opts.quiet) {
-            const { stdout } = await execFileAsync("git", ["log", "-1", "--pretty=%H:%s"], {
-                cwd: resolved.gitRoot,
-            });
-            const trimmed = stdout.trim();
-            const [hash, subject] = trimmed.split(":", 2);
-            process.stdout.write(`${successMessage("committed", `${hash?.slice(0, 12) ?? ""} ${subject ?? ""}`.trim())}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "commit", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdStart(opts) {
-    try {
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        if (opts.commitFromComment) {
-            enforceStatusCommitPolicy({
-                policy: loaded.config.status_commit_policy,
-                action: "start",
-                confirmed: opts.confirmStatusCommit,
-                quiet: opts.quiet,
-            });
-        }
-        const { prefix, min_chars: minChars } = loaded.config.tasks.comments.start;
-        requireStructuredComment(opts.body, prefix, minChars);
-        const { backend, task } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const currentStatus = String(task.status || "TODO").toUpperCase();
-        if (!opts.force && !isTransitionAllowed(currentStatus, "DOING")) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: `Refusing status transition ${currentStatus} -> DOING (use --force to override)`,
-            });
-        }
-        if (!opts.force) {
-            const allTasks = await backend.listTasks();
-            const depState = buildDependencyState(allTasks);
-            const dep = depState.get(task.id);
-            if (dep && (dep.missing.length > 0 || dep.incomplete.length > 0)) {
-                if (!opts.quiet) {
-                    if (dep.missing.length > 0) {
-                        process.stderr.write(`${warnMessage(`missing deps: ${dep.missing.join(", ")}`)}\n`);
-                    }
-                    if (dep.incomplete.length > 0) {
-                        process.stderr.write(`${warnMessage(`incomplete deps: ${dep.incomplete.join(", ")}`)}\n`);
-                    }
-                }
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `Task is not ready: ${task.id} (use --force to override)`,
-                });
-            }
-        }
-        const formattedComment = opts.commitFromComment
-            ? formatCommentBodyForCommit(opts.body, loaded.config)
-            : null;
-        const commentBody = formattedComment ?? opts.body;
-        const existingComments = Array.isArray(task.comments)
-            ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
-            : [];
-        const commentsValue = [
-            ...existingComments,
-            { author: opts.author, body: commentBody },
-        ];
-        const nextTask = {
-            ...task,
-            status: "DOING",
-            comments: commentsValue,
-            doc_version: 2,
-            doc_updated_at: nowIso(),
-            doc_updated_by: opts.author,
-        };
-        await backend.writeTask(nextTask);
-        let commitInfo = null;
-        if (opts.commitFromComment) {
-            commitInfo = await commitFromComment({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride,
-                taskId: opts.taskId,
-                commentBody: opts.body,
-                formattedComment,
-                emoji: opts.commitEmoji ?? "🚧",
-                allow: opts.commitAllow,
-                autoAllow: opts.commitAutoAllow || opts.commitAllow.length === 0,
-                allowTasks: opts.commitAllowTasks,
-                requireClean: opts.commitRequireClean,
-                quiet: opts.quiet,
-                config: loaded.config,
-            });
-        }
-        if (!opts.quiet) {
-            const suffix = commitInfo ? ` (commit=${commitInfo.hash.slice(0, 12)})` : "";
-            process.stdout.write(`${successMessage("started", `${opts.taskId}${suffix}`)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "start", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdBlock(opts) {
-    try {
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        if (opts.commitFromComment) {
-            enforceStatusCommitPolicy({
-                policy: loaded.config.status_commit_policy,
-                action: "block",
-                confirmed: opts.confirmStatusCommit,
-                quiet: opts.quiet,
-            });
-        }
-        const { prefix, min_chars: minChars } = loaded.config.tasks.comments.blocked;
-        requireStructuredComment(opts.body, prefix, minChars);
-        const { backend, task } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const currentStatus = String(task.status || "TODO").toUpperCase();
-        if (!opts.force && !isTransitionAllowed(currentStatus, "BLOCKED")) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: `Refusing status transition ${currentStatus} -> BLOCKED (use --force to override)`,
-            });
-        }
-        const formattedComment = opts.commitFromComment
-            ? formatCommentBodyForCommit(opts.body, loaded.config)
-            : null;
-        const commentBody = formattedComment ?? opts.body;
-        const existingComments = Array.isArray(task.comments)
-            ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
-            : [];
-        const commentsValue = [...existingComments, { author: opts.author, body: commentBody }];
-        const nextTask = {
-            ...task,
-            status: "BLOCKED",
-            comments: commentsValue,
-            doc_version: 2,
-            doc_updated_at: nowIso(),
-            doc_updated_by: opts.author,
-        };
-        await backend.writeTask(nextTask);
-        let commitInfo = null;
-        if (opts.commitFromComment) {
-            commitInfo = await commitFromComment({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride,
-                taskId: opts.taskId,
-                commentBody: opts.body,
-                formattedComment,
-                emoji: opts.commitEmoji ?? defaultCommitEmojiForStatus("BLOCKED"),
-                allow: opts.commitAllow,
-                autoAllow: opts.commitAutoAllow || opts.commitAllow.length === 0,
-                allowTasks: opts.commitAllowTasks,
-                requireClean: opts.commitRequireClean,
-                quiet: opts.quiet,
-                config: loaded.config,
-            });
-        }
-        if (!opts.quiet) {
-            const suffix = commitInfo ? ` (commit=${commitInfo.hash.slice(0, 12)})` : "";
-            process.stdout.write(`${successMessage("blocked", `${opts.taskId}${suffix}`)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "block", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdFinish(opts) {
-    try {
-        if (opts.noRequireTaskIdInCommit) {
-            // Parity flag (commit subject checks are not enforced in node CLI).
-        }
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        const { prefix, min_chars: minChars } = loaded.config.tasks.comments.verified;
-        requireStructuredComment(opts.body, prefix, minChars);
-        if (opts.commitFromComment || opts.statusCommit) {
-            enforceStatusCommitPolicy({
-                policy: loaded.config.status_commit_policy,
-                action: "finish",
-                confirmed: opts.confirmStatusCommit,
-                quiet: opts.quiet,
-            });
-        }
-        if ((opts.commitFromComment || opts.statusCommit) && opts.taskIds.length !== 1) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "--commit-from-comment/--status-commit requires exactly one task id",
-            });
-        }
-        const primaryTaskId = opts.taskIds[0] ?? "";
-        if ((opts.commitFromComment || opts.statusCommit) && !primaryTaskId) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "--commit-from-comment/--status-commit requires exactly one task id",
-            });
-        }
-        const { backend, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const commitInfo = opts.commit
-            ? await readCommitInfo(resolved.gitRoot, opts.commit)
-            : await readHeadCommit(resolved.gitRoot);
-        for (const taskId of opts.taskIds) {
-            const { task } = await loadBackendTask({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride,
-                taskId,
-            });
-            if (!opts.force) {
-                const currentStatus = String(task.status || "TODO").toUpperCase();
-                if (currentStatus === "DONE") {
-                    throw new CliError({
-                        exitCode: 2,
-                        code: "E_USAGE",
-                        message: `Task is already DONE: ${task.id} (use --force to override)`,
-                    });
-                }
-            }
-            const existingComments = Array.isArray(task.comments)
-                ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
-                : [];
-            const commentsValue = [...existingComments, { author: opts.author, body: opts.body }];
-            const nextTask = {
-                ...task,
-                status: "DONE",
-                commit: { hash: commitInfo.hash, message: commitInfo.message },
-                comments: commentsValue,
-                doc_version: 2,
-                doc_updated_at: nowIso(),
-                doc_updated_by: opts.author,
-            };
-            await backend.writeTask(nextTask);
-        }
-        if (!opts.skipVerify) {
-            // No-op for parity; verify is handled by `agentplane verify`.
-        }
-        if (!backend.exportTasksJson) {
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: backendNotSupportedMessage("exportTasksJson()"),
-            });
-        }
-        const outPath = path.join(resolved.gitRoot, config.paths.tasks_path);
-        await backend.exportTasksJson(outPath);
-        const lintResult = await lintTasksFile({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        if (lintResult.errors.length > 0) {
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: lintResult.errors.join("\n"),
-            });
-        }
-        if (opts.commitFromComment) {
-            await commitFromComment({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride,
-                taskId: primaryTaskId,
-                commentBody: opts.body,
-                formattedComment: formatCommentBodyForCommit(opts.body, loaded.config),
-                emoji: opts.commitEmoji ?? defaultCommitEmojiForStatus("DONE"),
-                allow: opts.commitAllow,
-                autoAllow: opts.commitAutoAllow || opts.commitAllow.length === 0,
-                allowTasks: opts.commitAllowTasks,
-                requireClean: opts.commitRequireClean,
-                quiet: opts.quiet,
-                config: loaded.config,
-            });
-        }
-        if (opts.statusCommit) {
-            await commitFromComment({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride,
-                taskId: primaryTaskId,
-                commentBody: opts.body,
-                formattedComment: formatCommentBodyForCommit(opts.body, loaded.config),
-                emoji: opts.statusCommitEmoji ?? defaultCommitEmojiForStatus("DONE"),
-                allow: opts.statusCommitAllow,
-                autoAllow: opts.statusCommitAutoAllow || opts.statusCommitAllow.length === 0,
-                allowTasks: true,
-                requireClean: opts.statusCommitRequireClean,
-                quiet: opts.quiet,
-                config: loaded.config,
-            });
-        }
-        if (!opts.quiet) {
-            process.stdout.write(`${successMessage("finished")}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "finish", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdVerify(opts) {
-    try {
-        const { task, backend, config, resolved } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const docText = typeof task.doc === "string" ? task.doc : "";
-        const { commands: docCommands, steps: docSteps } = parseVerifyStepsFromDoc(docText);
-        const rawVerify = task.verify;
-        if (rawVerify !== undefined && rawVerify !== null && !Array.isArray(rawVerify)) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: `${task.id}: verify must be a list of strings`,
-            });
-        }
-        const taskCommands = Array.isArray(rawVerify)
-            ? rawVerify
-                .filter((item) => typeof item === "string")
-                .map((item) => item.trim())
-                .filter(Boolean)
-            : [];
-        const commands = docCommands.length > 0 ? docCommands : taskCommands;
-        let baseDoc = typeof task.doc === "string" ? task.doc : "";
-        if (docSteps.length > 0 && !opts.quiet) {
-            process.stdout.write(`${infoMessage(`${task.id}: manual verify steps:`)}\n`);
-            for (const step of docSteps) {
-                process.stdout.write(`- ${step}\n`);
-            }
-        }
-        if (commands.length === 0) {
-            if (opts.require) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `${task.id}: no verify commands configured`,
-                });
-            }
-            if (!opts.quiet) {
-                process.stdout.write(`${infoMessage(`${task.id}: no verify commands configured`)}\n`);
-            }
-            return 0;
-        }
-        const requireVerifyApproval = config.agents?.approvals?.require_verify === true;
-        if (requireVerifyApproval && !opts.yes) {
-            if (!process.stdin.isTTY || opts.quiet) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "Verification requires explicit approval (use --yes in non-interactive mode or set agents.approvals.require_verify=false).",
-                });
-            }
-            const approved = await promptYesNo("Require explicit approval for verification. Proceed?", false);
-            if (!approved) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "Verification cancelled by user.",
-                });
-            }
-        }
-        if (!backend.getTaskDoc || !backend.setTaskDoc) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: backendNotSupportedMessage("task docs"),
-            });
-        }
-        if (!baseDoc) {
-            const fetched = await backend.getTaskDoc(task.id);
-            if (typeof fetched === "string")
-                baseDoc = fetched;
-        }
-        const execCwd = opts.execCwd ? path.resolve(opts.cwd, opts.execCwd) : resolved.gitRoot;
-        if (!isPathWithin(resolved.gitRoot, execCwd)) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: `--cwd must stay under repo root: ${execCwd}`,
-            });
-        }
-        const taskDir = path.join(resolved.gitRoot, config.paths.workflow_dir, opts.taskId);
-        const prDir = path.join(taskDir, "pr");
-        const metaPath = path.join(prDir, "meta.json");
-        let logPath = null;
-        if (opts.logPath) {
-            logPath = path.resolve(opts.cwd, opts.logPath);
-            if (!isPathWithin(resolved.gitRoot, logPath)) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `--log must stay under repo root: ${logPath}`,
-                });
-            }
-        }
-        else if (await fileExists(prDir)) {
-            logPath = path.join(prDir, "verify.log");
-        }
-        let meta = null;
-        if (await fileExists(metaPath)) {
-            const rawMeta = await readFile(metaPath, "utf8");
-            meta = parsePrMeta(rawMeta, opts.taskId);
-        }
-        const headSha = await gitRevParse(execCwd, ["HEAD"]);
-        const currentSha = headSha;
-        if (opts.skipIfUnchanged) {
-            const changed = await gitStatusChangedPaths({
-                cwd: execCwd,
-                rootOverride: opts.rootOverride,
-            });
-            if (changed.length > 0) {
-                if (!opts.quiet) {
-                    process.stdout.write(`${warnMessage(`${task.id}: working tree is dirty; ignoring --skip-if-unchanged`)}\n`);
-                }
-            }
-            else {
-                let lastVerifiedSha = meta?.last_verified_sha ?? null;
-                if (!lastVerifiedSha && logPath && (await fileExists(logPath))) {
-                    const logText = await readFile(logPath, "utf8");
-                    lastVerifiedSha = extractLastVerifiedSha(logText);
-                }
-                if (lastVerifiedSha && lastVerifiedSha === currentSha) {
-                    const header = `[${nowIso()}] ℹ️ skipped (unchanged verified_sha=${currentSha})`;
-                    if (logPath) {
-                        await appendVerifyLog(logPath, header, "");
-                    }
-                    if (!opts.quiet) {
-                        process.stdout.write(`${infoMessage(`${task.id}: verify skipped (unchanged sha ${currentSha.slice(0, 12)})`)}\n`);
-                    }
-                    if (meta) {
-                        const nextMeta = {
-                            ...meta,
-                            last_verified_sha: currentSha,
-                            last_verified_at: nowIso(),
-                            verify: meta.verify ? { ...meta.verify, status: "pass" } : { status: "pass" },
-                        };
-                        await writeFile(metaPath, `${JSON.stringify(nextMeta, null, 2)}\n`, "utf8");
-                    }
-                    return 0;
-                }
-            }
-        }
-        let verifyError = null;
-        let failedCommand = null;
-        for (const command of commands) {
-            try {
-                if (!opts.quiet) {
-                    process.stdout.write(`$ ${command}\n`);
-                }
-                const timestamp = nowIso();
-                const result = await runShellCommand(command, execCwd);
-                const shaPrefix = currentSha ? `sha=${currentSha} ` : "";
-                const header = `[${timestamp}] ${shaPrefix}$ ${command}`.trimEnd();
-                if (logPath) {
-                    await appendVerifyLog(logPath, header, result.output);
-                }
-                if (result.code !== 0) {
-                    throw new CliError({
-                        exitCode: result.code || 1,
-                        code: "E_IO",
-                        message: `Verify command failed: ${command}`,
-                    });
-                }
-            }
-            catch (err) {
-                verifyError = err instanceof Error ? err : new Error(String(err));
-                failedCommand = command;
-                break;
-            }
-        }
-        if (verifyError) {
-            const details = verifyError.message;
-            const failureAt = nowIso();
-            const content = renderVerificationSection({
-                status: "fail",
-                verifiedAt: failureAt,
-                verifiedSha: null,
-                commands,
-                steps: docSteps,
-                details: failedCommand ? `${details} (command: ${failedCommand})` : details,
-            });
-            await writeVerificationSection({
-                backend,
-                taskId: task.id,
-                config,
-                baseDoc,
-                content,
-                updatedBy: "VERIFY",
-            });
-            if (meta) {
-                const nextMeta = {
-                    ...meta,
-                    last_verified_at: failureAt,
-                    verify: meta.verify
-                        ? { ...meta.verify, status: "fail", command: commands.join(" && ") }
-                        : { status: "fail", command: commands.join(" && ") },
-                };
-                await writeFile(metaPath, `${JSON.stringify(nextMeta, null, 2)}\n`, "utf8");
-            }
-            const existingComments = Array.isArray(task.comments)
-                ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
-                : [];
-            const failureBody = failedCommand
-                ? `Verify failed: ${details} (command: ${failedCommand})`
-                : `Verify failed: ${details}`;
-            const nextTask = {
-                ...task,
-                status: "DOING",
-                comments: [...existingComments, { author: "VERIFY", body: failureBody }],
-                doc_version: 2,
-                doc_updated_at: failureAt,
-                doc_updated_by: "VERIFY",
-            };
-            await backend.writeTask(nextTask);
-            throw verifyError;
-        }
-        if (currentSha) {
-            const header = `[${nowIso()}] ✅ verified_sha=${currentSha}`;
-            if (logPath) {
-                await appendVerifyLog(logPath, header, "");
-            }
-        }
-        if (!opts.quiet) {
-            process.stdout.write(`${successMessage("verify passed", task.id)}\n`);
-        }
-        const successAt = nowIso();
-        const successContent = renderVerificationSection({
-            status: "pass",
-            verifiedAt: successAt,
-            verifiedSha: currentSha,
-            commands,
-            steps: docSteps,
-            details: null,
-        });
-        await writeVerificationSection({
-            backend,
-            taskId: task.id,
-            config,
-            baseDoc,
-            content: successContent,
-            updatedBy: "VERIFY",
-        });
-        if (meta) {
-            const nextMeta = {
-                ...meta,
-                last_verified_sha: currentSha,
-                last_verified_at: successAt,
-                verify: meta.verify
-                    ? { ...meta.verify, status: "pass", command: commands.join(" && ") }
-                    : { status: "pass", command: commands.join(" && ") },
-            };
-            await writeFile(metaPath, `${JSON.stringify(nextMeta, null, 2)}\n`, "utf8");
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "verify", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdWorkStart(opts) {
-    try {
-        validateWorkAgent(opts.agent);
-        validateWorkSlug(opts.slug);
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        if (loaded.config.workflow_mode !== "branch_pr") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: workflowModeMessage(loaded.config.workflow_mode, "branch_pr"),
-            });
-        }
-        if (!opts.worktree) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(WORK_START_USAGE, WORK_START_USAGE_EXAMPLE),
-            });
-        }
-        await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const baseBranch = await getBaseBranch({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const currentBranch = await gitCurrentBranch(resolved.gitRoot);
-        if (currentBranch !== baseBranch) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `work start must be run on base branch ${baseBranch} (current: ${currentBranch})`,
-            });
-        }
-        const prefix = loaded.config.branch.task_prefix;
-        const branchName = `${prefix}/${opts.taskId}/${opts.slug.trim()}`;
-        const worktreesDir = path.resolve(resolved.gitRoot, loaded.config.paths.worktrees_dir);
-        if (!isPathWithin(resolved.gitRoot, worktreesDir)) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `worktrees_dir must be inside the repo: ${worktreesDir}`,
-            });
-        }
-        const worktreePath = path.join(worktreesDir, `${opts.taskId}-${opts.slug.trim()}`);
-        if (await fileExists(worktreePath)) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `Worktree path already exists: ${worktreePath}`,
-            });
-        }
-        await mkdir(worktreesDir, { recursive: true });
-        const branchExists = await gitBranchExists(resolved.gitRoot, branchName);
-        const worktreeArgs = branchExists
-            ? ["worktree", "add", worktreePath, branchName]
-            : ["worktree", "add", "-b", branchName, worktreePath, baseBranch];
-        await execFileAsync("git", worktreeArgs, { cwd: resolved.gitRoot, env: gitEnv() });
-        process.stdout.write(`${successMessage("work start", branchName, `worktree=${path.relative(resolved.gitRoot, worktreePath)}`)}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "work start", root: opts.rootOverride ?? null });
-    }
-}
-async function resolvePrPaths(opts) {
-    const resolved = await resolveProject({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride ?? null,
-    });
-    const loaded = await loadConfig(resolved.agentplaneDir);
-    const taskDir = path.join(resolved.gitRoot, loaded.config.paths.workflow_dir, opts.taskId);
-    const prDir = path.join(taskDir, "pr");
-    return {
-        resolved,
-        config: loaded.config,
-        prDir,
-        metaPath: path.join(prDir, "meta.json"),
-        diffstatPath: path.join(prDir, "diffstat.txt"),
-        verifyLogPath: path.join(prDir, "verify.log"),
-        reviewPath: path.join(prDir, "review.md"),
-    };
-}
-export async function cmdPrOpen(opts) {
-    try {
-        const author = opts.author.trim();
-        if (!author)
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(PR_OPEN_USAGE, PR_OPEN_USAGE_EXAMPLE),
-            });
-        const { task } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const { resolved, config, prDir, metaPath, diffstatPath, verifyLogPath, reviewPath } = await resolvePrPaths(opts);
-        if (config.workflow_mode !== "branch_pr") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: workflowModeMessage(config.workflow_mode, "branch_pr"),
-            });
-        }
-        const branch = (opts.branch ?? (await gitCurrentBranch(resolved.gitRoot))).trim();
-        if (!branch)
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(PR_OPEN_USAGE, PR_OPEN_USAGE_EXAMPLE),
-            });
-        await mkdir(prDir, { recursive: true });
-        const now = nowIso();
-        let meta = null;
-        if (await fileExists(metaPath)) {
-            const raw = await readFile(metaPath, "utf8");
-            meta = parsePrMeta(raw, task.id);
-        }
-        const createdAt = meta?.created_at ?? now;
-        const nextMeta = {
-            schema_version: 1,
-            task_id: task.id,
-            branch,
-            created_at: createdAt,
-            updated_at: now,
-            last_verified_sha: meta?.last_verified_sha ?? null,
-            last_verified_at: meta?.last_verified_at ?? null,
-            verify: meta?.verify ?? { status: "skipped" },
-        };
-        await writeFile(metaPath, `${JSON.stringify(nextMeta, null, 2)}\n`, "utf8");
-        if (!(await fileExists(diffstatPath)))
-            await writeFile(diffstatPath, "", "utf8");
-        if (!(await fileExists(verifyLogPath)))
-            await writeFile(verifyLogPath, "", "utf8");
-        if (!(await fileExists(reviewPath))) {
-            const review = renderPrReviewTemplate({ author, createdAt, branch });
-            await writeFile(reviewPath, review, "utf8");
-        }
-        process.stdout.write(`${successMessage("pr open", path.relative(resolved.gitRoot, prDir))}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "pr open", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdPrUpdate(opts) {
-    try {
-        await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const { resolved, config, prDir, metaPath, diffstatPath, reviewPath } = await resolvePrPaths(opts);
-        if (config.workflow_mode !== "branch_pr") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: workflowModeMessage(config.workflow_mode, "branch_pr"),
-            });
-        }
-        if (!(await fileExists(metaPath)) || !(await fileExists(reviewPath))) {
-            const missing = [];
-            if (!(await fileExists(metaPath)))
-                missing.push(path.relative(resolved.gitRoot, metaPath));
-            if (!(await fileExists(reviewPath)))
-                missing.push(path.relative(resolved.gitRoot, reviewPath));
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: `PR artifacts missing: ${missing.join(", ")} (run \`agentplane pr open\`)`,
-            });
-        }
-        const baseBranch = await getBaseBranch({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const branch = await gitCurrentBranch(resolved.gitRoot);
-        const { stdout: diffStatOut } = await execFileAsync("git", ["diff", "--stat", `${baseBranch}...HEAD`], { cwd: resolved.gitRoot, env: gitEnv() });
-        const diffstat = diffStatOut.trimEnd();
-        await writeFile(diffstatPath, diffstat ? `${diffstat}\n` : "", "utf8");
-        const { stdout: headOut } = await execFileAsync("git", ["rev-parse", "HEAD"], {
-            cwd: resolved.gitRoot,
-            env: gitEnv(),
-        });
-        const headSha = headOut.trim();
-        const summaryLines = [
-            `- Updated: ${nowIso()}`,
-            `- Branch: ${branch}`,
-            `- Head: ${headSha.slice(0, 12)}`,
-            "- Diffstat:",
-            "```",
-            diffstat || "No changes detected.",
-            "```",
-        ];
-        const reviewText = await readFile(reviewPath, "utf8");
-        const nextReview = updateAutoSummaryBlock(reviewText, summaryLines.join("\n"));
-        await writeFile(reviewPath, nextReview, "utf8");
-        const rawMeta = await readFile(metaPath, "utf8");
-        const meta = parsePrMeta(rawMeta, opts.taskId);
-        const nextMeta = {
-            ...meta,
-            branch,
-            updated_at: nowIso(),
-            last_verified_sha: meta.last_verified_sha ?? null,
-            last_verified_at: meta.last_verified_at ?? null,
-        };
-        await writeFile(metaPath, `${JSON.stringify(nextMeta, null, 2)}\n`, "utf8");
-        process.stdout.write(`${successMessage("pr update", path.relative(resolved.gitRoot, prDir))}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "pr update", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdPrCheck(opts) {
-    try {
-        const { task } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const { resolved, config, prDir, metaPath, diffstatPath, verifyLogPath, reviewPath } = await resolvePrPaths(opts);
-        if (config.workflow_mode !== "branch_pr") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: workflowModeMessage(config.workflow_mode, "branch_pr"),
-            });
-        }
-        const errors = [];
-        const relPrDir = path.relative(resolved.gitRoot, prDir);
-        const relMetaPath = path.relative(resolved.gitRoot, metaPath);
-        const relDiffstatPath = path.relative(resolved.gitRoot, diffstatPath);
-        const relVerifyLogPath = path.relative(resolved.gitRoot, verifyLogPath);
-        const relReviewPath = path.relative(resolved.gitRoot, reviewPath);
-        if (!(await fileExists(prDir)))
-            errors.push(`Missing PR directory: ${relPrDir}`);
-        if (!(await fileExists(metaPath)))
-            errors.push(`Missing ${relMetaPath}`);
-        if (!(await fileExists(diffstatPath)))
-            errors.push(`Missing ${relDiffstatPath}`);
-        if (!(await fileExists(verifyLogPath)))
-            errors.push(`Missing ${relVerifyLogPath}`);
-        if (!(await fileExists(reviewPath)))
-            errors.push(`Missing ${relReviewPath}`);
-        let meta = null;
-        if (await fileExists(metaPath)) {
-            try {
-                meta = parsePrMeta(await readFile(metaPath, "utf8"), task.id);
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                errors.push(message);
-            }
-        }
-        if (await fileExists(reviewPath)) {
-            const review = await readFile(reviewPath, "utf8");
-            const requiredSections = ["## Summary", "## Checklist", "## Handoff Notes"];
-            for (const section of requiredSections) {
-                if (!review.includes(section))
-                    errors.push(`Missing section: ${section}`);
-            }
-            if (!review.includes("<!-- BEGIN AUTO SUMMARY -->")) {
-                errors.push("Missing auto summary start marker");
-            }
-            if (!review.includes("<!-- END AUTO SUMMARY -->")) {
-                errors.push("Missing auto summary end marker");
-            }
-        }
-        if (task.verify && task.verify.length > 0) {
-            if (meta?.verify?.status !== "pass") {
-                errors.push("Verify requirements not satisfied (meta.verify.status != pass)");
-            }
-            if (!meta?.last_verified_sha || !meta.last_verified_at) {
-                errors.push("Verify metadata missing (last_verified_sha/last_verified_at)");
-            }
-        }
-        if (errors.length > 0) {
-            throw new CliError({ exitCode: 3, code: "E_VALIDATION", message: errors.join("\n") });
-        }
-        process.stdout.write(`${successMessage("pr check", path.relative(resolved.gitRoot, prDir))}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "pr check", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdPrNote(opts) {
-    try {
-        const author = opts.author.trim();
-        const body = opts.body.trim();
-        if (!author || !body) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(PR_NOTE_USAGE, PR_NOTE_USAGE_EXAMPLE),
-            });
-        }
-        const { config, reviewPath, resolved } = await resolvePrPaths(opts);
-        if (config.workflow_mode !== "branch_pr") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: workflowModeMessage(config.workflow_mode, "branch_pr"),
-            });
-        }
-        if (!(await fileExists(reviewPath))) {
-            const relReviewPath = path.relative(resolved.gitRoot, reviewPath);
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: `Missing ${relReviewPath} (run \`agentplane pr open\`)`,
-            });
-        }
-        const review = await readFile(reviewPath, "utf8");
-        const updated = appendHandoffNote(review, `${author}: ${body}`);
-        await writeFile(reviewPath, updated, "utf8");
-        process.stdout.write(`${successMessage("pr note", opts.taskId)}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "pr note", root: opts.rootOverride ?? null });
-    }
-}
-async function readPrArtifact(opts) {
-    const filePath = path.join(opts.prDir, opts.fileName);
-    if (await fileExists(filePath)) {
-        return await readFile(filePath, "utf8");
-    }
-    const rel = toGitPath(path.relative(opts.resolved.gitRoot, filePath));
-    try {
-        return await gitShowFile(opts.resolved.gitRoot, opts.branch, rel);
-    }
-    catch {
-        return null;
-    }
-}
-function validateReviewContents(review, errors) {
-    const requiredSections = ["## Summary", "## Checklist", "## Handoff Notes"];
-    for (const section of requiredSections) {
-        if (!review.includes(section))
-            errors.push(`Missing section: ${section}`);
-    }
-    if (!review.includes("<!-- BEGIN AUTO SUMMARY -->")) {
-        errors.push("Missing auto summary start marker");
-    }
-    if (!review.includes("<!-- END AUTO SUMMARY -->")) {
-        errors.push("Missing auto summary end marker");
-    }
-}
-export async function cmdIntegrate(opts) {
-    let tempWorktreePath = null;
-    let createdTempWorktree = false;
-    try {
-        const { task } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        if (loaded.config.workflow_mode !== "branch_pr") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: workflowModeMessage(loaded.config.workflow_mode, "branch_pr"),
-            });
-        }
-        await ensureGitClean({ cwd: opts.cwd, rootOverride: opts.rootOverride });
-        const baseBranch = (opts.base ?? (await getBaseBranch({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }))).trim();
-        const currentBranch = await gitCurrentBranch(resolved.gitRoot);
-        if (currentBranch !== baseBranch) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `integrate must run on base branch ${baseBranch} (current: ${currentBranch})`,
-            });
-        }
-        const { prDir, metaPath, diffstatPath, verifyLogPath } = await resolvePrPaths({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
-        let meta = null;
-        let branch = (opts.branch ?? "").trim();
-        if (await fileExists(metaPath)) {
-            meta = parsePrMeta(await readFile(metaPath, "utf8"), task.id);
-            if (!branch)
-                branch = (meta.branch ?? "").trim();
-        }
-        if (!branch) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(INTEGRATE_USAGE, INTEGRATE_USAGE_EXAMPLE),
-            });
-        }
-        if (!(await gitBranchExists(resolved.gitRoot, branch))) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: unknownEntityMessage("branch", branch),
-            });
-        }
-        const metaSource = meta ??
-            parsePrMeta(await gitShowFile(resolved.gitRoot, branch, toGitPath(path.relative(resolved.gitRoot, metaPath))), task.id);
-        const baseCandidate = opts.base ?? metaSource.base_branch ?? baseBranch;
-        const base = typeof baseCandidate === "string" && baseCandidate.trim().length > 0
-            ? baseCandidate.trim()
-            : baseBranch;
-        const errors = [];
-        const relDiffstat = path.relative(resolved.gitRoot, path.join(prDir, "diffstat.txt"));
-        const relVerifyLog = path.relative(resolved.gitRoot, path.join(prDir, "verify.log"));
-        const relReview = path.relative(resolved.gitRoot, path.join(prDir, "review.md"));
-        const diffstatText = await readPrArtifact({
-            resolved,
-            prDir,
-            fileName: "diffstat.txt",
-            branch,
-        });
-        if (diffstatText === null)
-            errors.push(`Missing ${relDiffstat}`);
-        const verifyLogText = await readPrArtifact({
-            resolved,
-            prDir,
-            fileName: "verify.log",
-            branch,
-        });
-        if (verifyLogText === null)
-            errors.push(`Missing ${relVerifyLog}`);
-        const reviewText = await readPrArtifact({
-            resolved,
-            prDir,
-            fileName: "review.md",
-            branch,
-        });
-        if (reviewText === null)
-            errors.push(`Missing ${relReview}`);
-        if (reviewText)
-            validateReviewContents(reviewText, errors);
-        if (errors.length > 0) {
-            throw new CliError({ exitCode: 3, code: "E_VALIDATION", message: errors.join("\n") });
-        }
-        const changedPaths = await gitDiffNames(resolved.gitRoot, base, branch);
-        const tasksPath = loaded.config.paths.tasks_path;
-        if (changedPaths.includes(tasksPath)) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `Branch ${branch} modifies ${tasksPath} (single-writer violation)`,
-            });
-        }
-        const rawVerify = task.verify;
-        const verifyCommands = Array.isArray(rawVerify)
-            ? rawVerify
-                .filter((item) => typeof item === "string")
-                .map((item) => item.trim())
-                .filter(Boolean)
-            : [];
-        let branchHeadSha = await gitRevParse(resolved.gitRoot, [branch]);
-        let alreadyVerifiedSha = null;
-        if (verifyCommands.length > 0) {
-            const metaVerified = metaSource?.last_verified_sha ?? null;
-            if (metaVerified && metaVerified === branchHeadSha) {
-                alreadyVerifiedSha = branchHeadSha;
-            }
-            else if (verifyLogText) {
-                const logSha = extractLastVerifiedSha(verifyLogText);
-                if (logSha && logSha === branchHeadSha)
-                    alreadyVerifiedSha = logSha;
-            }
-        }
-        let shouldRunVerify = opts.runVerify || (verifyCommands.length > 0 && alreadyVerifiedSha === null);
-        if (opts.dryRun) {
-            if (!opts.quiet) {
-                process.stdout.write(`${successMessage("integrate dry-run", task.id, `base=${base} branch=${branch} verify=${shouldRunVerify ? "yes" : "no"}`)}\n`);
-            }
-            return 0;
-        }
-        let worktreePath = await findWorktreeForBranch(resolved.gitRoot, branch);
-        if (opts.mergeStrategy === "rebase" && !worktreePath) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "rebase strategy requires an existing worktree for the task branch",
-            });
-        }
-        if (shouldRunVerify && !worktreePath) {
-            const worktreesDir = path.resolve(resolved.gitRoot, loaded.config.paths.worktrees_dir);
-            if (!isPathWithin(resolved.gitRoot, worktreesDir)) {
-                throw new CliError({
-                    exitCode: 5,
-                    code: "E_GIT",
-                    message: `worktrees_dir must be inside the repo: ${worktreesDir}`,
-                });
-            }
-            tempWorktreePath = path.join(worktreesDir, `_integrate_tmp_${task.id}`);
-            const tempExists = await fileExists(tempWorktreePath);
-            if (tempExists) {
-                const registered = await findWorktreeForBranch(resolved.gitRoot, branch);
-                if (!registered) {
-                    throw new CliError({
-                        exitCode: 5,
-                        code: "E_GIT",
-                        message: `Temp worktree path exists but is not registered: ${tempWorktreePath}`,
-                    });
-                }
-            }
-            else {
-                await mkdir(worktreesDir, { recursive: true });
-                await execFileAsync("git", ["worktree", "add", tempWorktreePath, branch], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                });
-                createdTempWorktree = true;
-            }
-            worktreePath = tempWorktreePath;
-        }
-        const verifyEntries = [];
-        if (opts.mergeStrategy !== "rebase" && shouldRunVerify && verifyCommands.length > 0) {
-            if (!worktreePath) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "Unable to locate or create a worktree for verify execution",
-                });
-            }
-            for (const command of verifyCommands) {
-                if (!opts.quiet)
-                    process.stdout.write(`$ ${command}\n`);
-                const timestamp = nowIso();
-                const result = await runShellCommand(command, worktreePath);
-                const shaPrefix = branchHeadSha ? `sha=${branchHeadSha} ` : "";
-                verifyEntries.push({
-                    header: `[${timestamp}] ${shaPrefix}$ ${command}`.trimEnd(),
-                    content: result.output,
-                });
-                if (result.code !== 0) {
-                    throw new CliError({
-                        exitCode: result.code || 1,
-                        code: "E_IO",
-                        message: `Verify command failed: ${command}`,
-                    });
-                }
-            }
-            if (branchHeadSha) {
-                verifyEntries.push({
-                    header: `[${nowIso()}] ✅ verified_sha=${branchHeadSha}`,
-                    content: "",
-                });
-            }
-            if (!opts.quiet) {
-                process.stdout.write(`${successMessage("verify passed", task.id)}\n`);
-            }
-        }
-        const baseShaBeforeMerge = await gitRevParse(resolved.gitRoot, [base]);
-        const headBeforeMerge = await gitRevParse(resolved.gitRoot, ["HEAD"]);
-        let mergeHash = "";
-        if (opts.mergeStrategy === "squash") {
-            try {
-                await execFileAsync("git", ["merge", "--squash", branch], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                });
-            }
-            catch (err) {
-                await execFileAsync("git", ["reset", "--hard", headBeforeMerge], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                });
-                const message = err instanceof Error ? err.message : "git merge --squash failed";
-                throw new CliError({ exitCode: 2, code: "E_GIT", message });
-            }
-            const { stdout: staged } = await execFileAsync("git", ["diff", "--cached", "--name-only"], {
-                cwd: resolved.gitRoot,
-                env: gitEnv(),
-            });
-            if (!staged.trim()) {
-                await execFileAsync("git", ["reset", "--hard", headBeforeMerge], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                });
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `Nothing to integrate: ${branch} is already merged into ${base}`,
-                });
-            }
-            const { stdout: subjectOut } = await execFileAsync("git", ["log", "-1", "--pretty=format:%s", branch], { cwd: resolved.gitRoot, env: gitEnv() });
-            let subject = subjectOut.trim();
-            if (!subject.includes(task.id)) {
-                subject = `🧩 ${task.id} integrate ${branch}`;
-            }
-            const env = {
-                ...process.env,
-                AGENTPLANE_TASK_ID: task.id,
-                AGENTPLANE_ALLOW_BASE: "1",
-                AGENTPLANE_ALLOW_TASKS: "0",
-            };
-            try {
-                await execFileAsync("git", ["commit", "-m", subject], {
-                    cwd: resolved.gitRoot,
-                    env,
-                });
-            }
-            catch (err) {
-                await execFileAsync("git", ["reset", "--hard", headBeforeMerge], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                });
-                const message = err instanceof Error ? err.message : "git commit failed";
-                throw new CliError({ exitCode: 2, code: "E_GIT", message });
-            }
-            mergeHash = await gitRevParse(resolved.gitRoot, ["HEAD"]);
-        }
-        else if (opts.mergeStrategy === "merge") {
-            const env = {
-                ...process.env,
-                AGENTPLANE_TASK_ID: task.id,
-                AGENTPLANE_ALLOW_BASE: "1",
-                AGENTPLANE_ALLOW_TASKS: "0",
-            };
-            try {
-                await execFileAsync("git", ["merge", "--no-ff", branch, "-m", `🔀 ${task.id} merge ${branch}`], {
-                    cwd: resolved.gitRoot,
-                    env,
-                });
-            }
-            catch (err) {
-                await execFileAsync("git", ["merge", "--abort"], { cwd: resolved.gitRoot, env: gitEnv() });
-                const message = err instanceof Error ? err.message : "git merge failed";
-                throw new CliError({ exitCode: 2, code: "E_GIT", message });
-            }
-            mergeHash = await gitRevParse(resolved.gitRoot, ["HEAD"]);
-        }
-        else {
-            if (!worktreePath) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "rebase strategy requires an existing worktree for the task branch",
-                });
-            }
-            try {
-                await execFileAsync("git", ["rebase", base], { cwd: worktreePath, env: gitEnv() });
-            }
-            catch (err) {
-                await execFileAsync("git", ["rebase", "--abort"], { cwd: worktreePath, env: gitEnv() });
-                const message = err instanceof Error ? err.message : "git rebase failed";
-                throw new CliError({ exitCode: 2, code: "E_GIT", message });
-            }
-            branchHeadSha = await gitRevParse(resolved.gitRoot, [branch]);
-            if (!opts.runVerify && verifyCommands.length > 0) {
-                alreadyVerifiedSha = null;
-                const metaVerified = metaSource?.last_verified_sha ?? null;
-                if (metaVerified && metaVerified === branchHeadSha) {
-                    alreadyVerifiedSha = branchHeadSha;
-                }
-                else if (verifyLogText) {
-                    const logSha = extractLastVerifiedSha(verifyLogText);
-                    if (logSha && logSha === branchHeadSha)
-                        alreadyVerifiedSha = logSha;
-                }
-                shouldRunVerify = alreadyVerifiedSha === null;
-            }
-            if (shouldRunVerify && verifyCommands.length > 0) {
-                if (!worktreePath) {
-                    throw new CliError({
-                        exitCode: 2,
-                        code: "E_USAGE",
-                        message: "Unable to locate or create a worktree for verify execution",
-                    });
-                }
-                for (const command of verifyCommands) {
-                    if (!opts.quiet)
-                        process.stdout.write(`$ ${command}\n`);
-                    const timestamp = nowIso();
-                    const result = await runShellCommand(command, worktreePath);
-                    const shaPrefix = branchHeadSha ? `sha=${branchHeadSha} ` : "";
-                    verifyEntries.push({
-                        header: `[${timestamp}] ${shaPrefix}$ ${command}`.trimEnd(),
-                        content: result.output,
-                    });
-                    if (result.code !== 0) {
-                        throw new CliError({
-                            exitCode: result.code || 1,
-                            code: "E_IO",
-                            message: `Verify command failed: ${command}`,
-                        });
-                    }
-                }
-                if (branchHeadSha) {
-                    verifyEntries.push({
-                        header: `[${nowIso()}] ✅ verified_sha=${branchHeadSha}`,
-                        content: "",
-                    });
-                }
-                if (!opts.quiet) {
-                    process.stdout.write(`${successMessage("verify passed", task.id)}\n`);
-                }
-            }
-            try {
-                await execFileAsync("git", ["merge", "--ff-only", branch], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                });
-            }
-            catch (err) {
-                await execFileAsync("git", ["reset", "--hard", headBeforeMerge], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                }).catch(() => null);
-                const message = err instanceof Error ? err.message : "git merge --ff-only failed";
-                throw new CliError({ exitCode: 2, code: "E_GIT", message });
-            }
-            mergeHash = await gitRevParse(resolved.gitRoot, ["HEAD"]);
-        }
-        if (!(await fileExists(prDir))) {
-            throw new CliError({
-                exitCode: 3,
-                code: "E_VALIDATION",
-                message: `Missing PR artifact dir after merge: ${path.relative(resolved.gitRoot, prDir)}`,
-            });
-        }
-        if (verifyEntries.length > 0) {
-            for (const entry of verifyEntries) {
-                await appendVerifyLog(verifyLogPath, entry.header, entry.content);
-            }
-        }
-        const rawMeta = await readFile(metaPath, "utf8");
-        const mergedMeta = parsePrMeta(rawMeta, task.id);
-        const now = nowIso();
-        const nextMeta = {
-            ...mergedMeta,
-            branch,
-            base_branch: base,
-            merge_strategy: opts.mergeStrategy,
-            status: "MERGED",
-            merged_at: mergedMeta.merged_at ?? now,
-            merge_commit: mergeHash,
-            head_sha: branchHeadSha,
-            updated_at: now,
-        };
-        if (verifyCommands.length > 0 && (shouldRunVerify || alreadyVerifiedSha)) {
-            nextMeta.last_verified_sha = branchHeadSha;
-            nextMeta.last_verified_at = now;
-            nextMeta.verify = mergedMeta.verify
-                ? { ...mergedMeta.verify, status: "pass" }
-                : { status: "pass", command: verifyCommands.join(" && ") };
-        }
-        await writeFile(metaPath, `${JSON.stringify(nextMeta, null, 2)}\n`, "utf8");
-        const diffstat = await gitDiffStat(resolved.gitRoot, baseShaBeforeMerge, branch);
-        await writeFile(diffstatPath, diffstat ? `${diffstat}\n` : "", "utf8");
-        const verifyDesc = verifyCommands.length === 0
-            ? "skipped(no commands)"
-            : shouldRunVerify
-                ? "ran"
-                : alreadyVerifiedSha
-                    ? `skipped(already verified_sha=${alreadyVerifiedSha})`
-                    : "skipped";
-        const finishBody = `Verified: Integrated via ${opts.mergeStrategy}; verify=${verifyDesc}; pr=${path.relative(resolved.gitRoot, prDir)}.`;
-        await cmdFinish({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskIds: [task.id],
-            author: "INTEGRATOR",
-            body: finishBody,
-            commit: undefined,
-            skipVerify: false,
-            force: false,
-            noRequireTaskIdInCommit: false,
-            commitFromComment: false,
-            commitEmoji: undefined,
-            commitAllow: [],
-            commitAutoAllow: false,
-            commitAllowTasks: false,
-            commitRequireClean: false,
-            statusCommit: false,
-            statusCommitEmoji: undefined,
-            statusCommitAllow: [],
-            statusCommitAutoAllow: false,
-            statusCommitRequireClean: false,
-            confirmStatusCommit: false,
-            quiet: opts.quiet,
-        });
-        if (!opts.quiet) {
-            process.stdout.write(`${successMessage("integrate", task.id, `merge=${mergeHash.slice(0, 12)}`)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "integrate", root: opts.rootOverride ?? null });
-    }
-    finally {
-        if (createdTempWorktree && tempWorktreePath) {
-            try {
-                await execFileAsync("git", ["worktree", "remove", "--force", tempWorktreePath], {
-                    cwd: opts.cwd,
-                    env: gitEnv(),
-                });
-            }
-            catch {
-                // ignore cleanup errors
-            }
-        }
-    }
-}
-export async function cmdCleanupMerged(opts) {
-    try {
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        if (loaded.config.workflow_mode !== "branch_pr") {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: workflowModeMessage(loaded.config.workflow_mode, "branch_pr"),
-            });
-        }
-        await ensureGitClean({ cwd: opts.cwd, rootOverride: opts.rootOverride });
-        const baseBranch = (opts.base ?? (await getBaseBranch({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }))).trim();
-        if (!baseBranch) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(CLEANUP_MERGED_USAGE, CLEANUP_MERGED_USAGE_EXAMPLE),
-            });
-        }
-        if (!(await gitBranchExists(resolved.gitRoot, baseBranch))) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: unknownEntityMessage("base branch", baseBranch),
-            });
-        }
-        const currentBranch = await gitCurrentBranch(resolved.gitRoot);
-        if (currentBranch !== baseBranch) {
-            throw new CliError({
-                exitCode: 5,
-                code: "E_GIT",
-                message: `cleanup merged must run on base branch ${baseBranch} (current: ${currentBranch})`,
-            });
-        }
-        const repoRoot = await resolvePathFallback(resolved.gitRoot);
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const tasks = await backend.listTasks();
-        const tasksById = new Map(tasks.map((task) => [task.id, task]));
-        const prefix = loaded.config.branch.task_prefix;
-        const branches = await gitListTaskBranches(resolved.gitRoot, prefix);
-        const candidates = [];
-        for (const branch of branches) {
-            if (branch === baseBranch)
-                continue;
-            const taskId = parseTaskIdFromBranch(prefix, branch);
-            if (!taskId)
-                continue;
-            const task = tasksById.get(taskId);
-            if (!task)
-                continue;
-            const status = String(task.status || "").toUpperCase();
-            if (status !== "DONE")
-                continue;
-            const diff = await gitDiffNames(resolved.gitRoot, baseBranch, branch);
-            if (diff.length > 0)
-                continue;
-            const worktreePath = await findWorktreeForBranch(resolved.gitRoot, branch);
-            candidates.push({ taskId, branch, worktreePath });
-        }
-        const sortedCandidates = candidates.toSorted((a, b) => a.taskId.localeCompare(b.taskId));
-        if (!opts.quiet) {
-            const archiveLabel = opts.archive ? " archive=on" : "";
-            process.stdout.write(`cleanup merged (base=${baseBranch}${archiveLabel})\n`);
-            if (sortedCandidates.length === 0) {
-                process.stdout.write("no candidates\n");
-                return 0;
-            }
-            for (const item of sortedCandidates) {
-                process.stdout.write(`- ${item.taskId}: branch=${item.branch} worktree=${item.worktreePath ?? "-"}\n`);
-            }
-        }
-        if (!opts.yes) {
-            if (!opts.quiet) {
-                process.stdout.write("Re-run with --yes to delete these branches/worktrees.\n");
-            }
-            return 0;
-        }
-        for (const item of sortedCandidates) {
-            const worktreePath = item.worktreePath ? await resolvePathFallback(item.worktreePath) : null;
-            if (worktreePath) {
-                if (!isPathWithin(repoRoot, worktreePath)) {
-                    throw new CliError({
-                        exitCode: 5,
-                        code: "E_GIT",
-                        message: `Refusing to remove worktree outside repo: ${worktreePath}`,
-                    });
-                }
-                if (worktreePath === repoRoot) {
-                    throw new CliError({
-                        exitCode: 5,
-                        code: "E_GIT",
-                        message: "Refusing to remove the current worktree",
-                    });
-                }
-            }
-            if (opts.archive) {
-                const taskDir = path.join(resolved.gitRoot, loaded.config.paths.workflow_dir, item.taskId);
-                await archivePrArtifacts(taskDir);
-            }
-            if (worktreePath) {
-                await execFileAsync("git", ["worktree", "remove", "--force", worktreePath], {
-                    cwd: resolved.gitRoot,
-                    env: gitEnv(),
-                });
-            }
-            await execFileAsync("git", ["branch", "-D", item.branch], {
-                cwd: resolved.gitRoot,
-                env: gitEnv(),
-            });
-        }
-        if (!opts.quiet) {
-            process.stdout.write(`${successMessage("cleanup merged", undefined, `deleted=${candidates.length}`)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "cleanup merged", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdHooksInstall(opts) {
-    try {
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const hooksDir = await resolveGitHooksDir(resolved.gitRoot);
-        await mkdir(hooksDir, { recursive: true });
-        await mkdir(resolved.agentplaneDir, { recursive: true });
-        await ensureShim(resolved.agentplaneDir, resolved.gitRoot);
-        for (const hook of HOOK_NAMES) {
-            const hookPath = path.join(hooksDir, hook);
-            if (await fileExists(hookPath)) {
-                const managed = await fileIsManaged(hookPath, HOOK_MARKER);
-                if (!managed) {
-                    throw new CliError({
-                        exitCode: 5,
-                        code: "E_GIT",
-                        message: `Refusing to overwrite existing hook: ${path.relative(resolved.gitRoot, hookPath)}`,
-                    });
-                }
-            }
-            await writeFile(hookPath, hookScriptText(hook), "utf8");
-            await chmod(hookPath, 0o755);
-        }
-        if (!opts.quiet) {
-            process.stdout.write(`${path.relative(resolved.gitRoot, hooksDir)}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "hooks install", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdHooksUninstall(opts) {
-    try {
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const hooksDir = await resolveGitHooksDir(resolved.gitRoot);
-        let removed = 0;
-        for (const hook of HOOK_NAMES) {
-            const hookPath = path.join(hooksDir, hook);
-            if (!(await fileExists(hookPath)))
-                continue;
-            const managed = await fileIsManaged(hookPath, HOOK_MARKER);
-            if (!managed)
-                continue;
-            await rm(hookPath, { force: true });
-            removed++;
-        }
-        if (!opts.quiet) {
-            process.stdout.write(removed > 0
-                ? `${successMessage("removed hooks", undefined, `count=${removed}`)}\n`
-                : `${infoMessage("no agentplane hooks found")}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "hooks uninstall", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdHooksRun(opts) {
-    try {
-        if (opts.hook === "commit-msg") {
-            const messagePath = opts.args[0];
-            if (!messagePath) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: "Missing commit message file path",
-                });
-            }
-            const raw = await readFile(messagePath, "utf8");
-            const subject = readCommitSubject(raw);
-            if (!subject) {
-                throw new CliError({
-                    exitCode: 5,
-                    code: "E_GIT",
-                    message: "Commit message subject is empty",
-                });
-            }
-            const taskId = (process.env.AGENTPLANE_TASK_ID ?? "").trim();
-            if (taskId) {
-                const suffix = taskId.split("-").at(-1) ?? "";
-                if (!subject.includes(taskId) && (suffix.length === 0 || !subject.includes(suffix))) {
-                    throw new CliError({
-                        exitCode: 5,
-                        code: "E_GIT",
-                        message: "Commit subject must include task id or suffix",
-                    });
-                }
-                return 0;
-            }
-            const { backend } = await loadTaskBackend({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride ?? null,
-            });
-            const tasks = await backend.listTasks();
-            const suffixes = tasks.map((task) => task.id.split("-").at(-1) ?? "").filter(Boolean);
-            if (suffixes.length === 0) {
-                throw new CliError({
-                    exitCode: 5,
-                    code: "E_GIT",
-                    message: "No task IDs available to validate commit subject",
-                });
-            }
-            if (!subjectHasSuffix(subject, suffixes)) {
-                throw new CliError({
-                    exitCode: 5,
-                    code: "E_GIT",
-                    message: "Commit subject must mention a task suffix",
-                });
-            }
-            return 0;
-        }
-        if (opts.hook === "pre-commit") {
-            const staged = await getStagedFiles({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride ?? null,
-            });
-            if (staged.length === 0)
-                return 0;
-            const allowTasks = (process.env.AGENTPLANE_ALLOW_TASKS ?? "").trim() === "1";
-            const allowBase = (process.env.AGENTPLANE_ALLOW_BASE ?? "").trim() === "1";
-            const resolved = await resolveProject({
-                cwd: opts.cwd,
-                rootOverride: opts.rootOverride ?? null,
-            });
-            const loaded = await loadConfig(resolved.agentplaneDir);
-            const tasksPath = loaded.config.paths.tasks_path;
-            const tasksStaged = staged.includes(tasksPath);
-            const nonTasks = staged.filter((entry) => entry !== tasksPath);
-            if (tasksStaged && !allowTasks) {
-                throw new CliError({
-                    exitCode: 5,
-                    code: "E_GIT",
-                    message: `${tasksPath} is protected by agentplane hooks (set AGENTPLANE_ALLOW_TASKS=1 to override)`,
-                });
-            }
-            if (loaded.config.workflow_mode === "branch_pr") {
-                const baseBranch = await getBaseBranch({
-                    cwd: opts.cwd,
-                    rootOverride: opts.rootOverride ?? null,
-                });
-                const currentBranch = await gitCurrentBranch(resolved.gitRoot);
-                if (tasksStaged && currentBranch !== baseBranch) {
-                    throw new CliError({
-                        exitCode: 5,
-                        code: "E_GIT",
-                        message: `${tasksPath} commits are allowed only on ${baseBranch} in branch_pr mode`,
-                    });
-                }
-                if (nonTasks.length > 0 && currentBranch === baseBranch && !allowBase) {
-                    throw new CliError({
-                        exitCode: 5,
-                        code: "E_GIT",
-                        message: `Code commits are forbidden on ${baseBranch} in branch_pr mode`,
-                    });
-                }
-            }
-            return 0;
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, {
-            command: `hooks run ${opts.hook}`,
-            root: opts.rootOverride ?? null,
-        });
-    }
-}
-export async function cmdBranchBaseGet(opts) {
-    try {
-        const value = await getBaseBranch({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
-        process.stdout.write(`${value}\n`);
-        return 0;
-    }
-    catch (err) {
-        throw mapCoreError(err, { command: "branch base get", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdBranchBaseSet(opts) {
-    const trimmed = opts.value.trim();
-    if (trimmed.length === 0) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(BRANCH_BASE_USAGE, BRANCH_BASE_USAGE_EXAMPLE),
-        });
-    }
-    try {
-        const value = await setPinnedBaseBranch({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-            value: trimmed,
-        });
-        process.stdout.write(`${value}\n`);
-        return 0;
-    }
-    catch (err) {
-        throw mapCoreError(err, { command: "branch base set", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdBranchStatus(opts) {
-    try {
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        const branch = (opts.branch ?? (await gitCurrentBranch(resolved.gitRoot))).trim();
-        const base = (opts.base ?? (await getBaseBranch({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }))).trim();
-        if (!branch || !base) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: usageMessage(BRANCH_STATUS_USAGE, BRANCH_STATUS_USAGE_EXAMPLE),
-            });
-        }
-        if (!(await gitBranchExists(resolved.gitRoot, branch))) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: unknownEntityMessage("branch", branch),
-            });
-        }
-        if (!(await gitBranchExists(resolved.gitRoot, base))) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: unknownEntityMessage("base branch", base),
-            });
-        }
-        const taskId = parseTaskIdFromBranch(loaded.config.branch.task_prefix, branch);
-        const worktree = await findWorktreeForBranch(resolved.gitRoot, branch);
-        const { ahead, behind } = await gitAheadBehind(resolved.gitRoot, base, branch);
-        process.stdout.write(`branch=${branch} base=${base} ahead=${ahead} behind=${behind} task_id=${taskId ?? "-"}\n`);
-        if (worktree) {
-            process.stdout.write(`worktree=${worktree}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "branch status", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdBranchRemove(opts) {
-    const branch = (opts.branch ?? "").trim();
-    const worktree = (opts.worktree ?? "").trim();
-    if (!branch && !worktree) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(BRANCH_REMOVE_USAGE, BRANCH_REMOVE_USAGE_EXAMPLE),
-        });
-    }
-    try {
-        const resolved = await resolveProject({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        const loaded = await loadConfig(resolved.agentplaneDir);
-        if (worktree) {
-            const worktreePath = path.isAbsolute(worktree)
-                ? await resolvePathFallback(worktree)
-                : await resolvePathFallback(path.join(resolved.gitRoot, worktree));
-            const worktreesRoot = path.resolve(resolved.gitRoot, loaded.config.paths.worktrees_dir);
-            if (!isPathWithin(worktreesRoot, worktreePath)) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: `Refusing to remove worktree outside ${worktreesRoot}: ${worktreePath}`,
-                });
-            }
-            await execFileAsync("git", ["worktree", "remove", ...(opts.force ? ["--force"] : []), worktreePath], { cwd: resolved.gitRoot, env: gitEnv() });
-            if (!opts.quiet) {
-                process.stdout.write(`${successMessage("removed worktree", worktreePath)}\n`);
-            }
-        }
-        if (branch) {
-            if (!(await gitBranchExists(resolved.gitRoot, branch))) {
-                throw new CliError({
-                    exitCode: 2,
-                    code: "E_USAGE",
-                    message: unknownEntityMessage("branch", branch),
-                });
-            }
-            await execFileAsync("git", ["branch", opts.force ? "-D" : "-d", branch], {
-                cwd: resolved.gitRoot,
-                env: gitEnv(),
-            });
-            if (!opts.quiet) {
-                process.stdout.write(`${successMessage("removed branch", branch)}\n`);
-            }
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapCoreError(err, { command: "branch remove", root: opts.rootOverride ?? null });
-    }
-}
-function normalizeDocUpdatedBy(value) {
-    const trimmed = value?.trim() ?? "";
-    if (!trimmed)
-        return "";
-    if (trimmed.toLowerCase() === "agentplane")
-        return "";
-    return trimmed;
-}
-function resolveDocUpdatedBy(task, author) {
-    const fromAuthor = normalizeDocUpdatedBy(author);
-    if (fromAuthor)
-        return fromAuthor;
-    const fromTask = normalizeDocUpdatedBy(typeof task.doc_updated_by === "string" ? task.doc_updated_by : undefined);
-    if (fromTask)
-        return fromTask;
-    return normalizeDocUpdatedBy(typeof task.owner === "string" ? task.owner : undefined);
-}
-function taskDataToFrontmatter(task) {
-    return {
-        id: task.id,
-        title: task.title,
-        status: task.status,
-        priority: task.priority,
-        owner: task.owner,
-        depends_on: task.depends_on ?? [],
-        tags: task.tags ?? [],
-        verify: task.verify ?? [],
-        commit: task.commit ?? null,
-        comments: task.comments ?? [],
-        doc_version: task.doc_version,
-        doc_updated_at: task.doc_updated_at,
-        doc_updated_by: task.doc_updated_by,
-        description: task.description ?? "",
-    };
-}
-async function loadBackendTask(opts) {
-    const { backend, backendId, resolved, config } = await loadTaskBackend({
-        cwd: opts.cwd,
-        rootOverride: opts.rootOverride ?? null,
-    });
-    const task = await backend.getTask(opts.taskId);
-    if (!task) {
-        const tasksDir = path.join(resolved.gitRoot, config.paths.workflow_dir);
-        const readmePath = path.join(tasksDir, opts.taskId, "README.md");
-        throw new CliError({
-            exitCode: 4,
-            code: "E_IO",
-            message: `ENOENT: no such file or directory, open '${readmePath}'`,
-        });
-    }
-    return { backend, backendId, resolved, config, task };
-}
-export const TASK_DOC_SET_USAGE = "Usage: agentplane task doc set <task-id> --section <name> (--text <text> | --file <path>)";
-export const TASK_DOC_SET_USAGE_EXAMPLE = 'agentplane task doc set 202602030608-F1Q8AB --section Summary --text "..."';
-export const TASK_DOC_SHOW_USAGE = "Usage: agentplane task doc show <task-id> [--section <name>] [--quiet]";
-export const TASK_DOC_SHOW_USAGE_EXAMPLE = "agentplane task doc show 202602030608-F1Q8AB --section Summary";
-function parseTaskDocShowFlags(args) {
-    const out = { quiet: false };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (arg === "--quiet") {
-            out.quiet = true;
-            continue;
-        }
-        if (arg === "--section") {
-            const next = args[i + 1];
-            if (!next) {
-                throw new CliError({ exitCode: 2, code: "E_USAGE", message: missingValueMessage(arg) });
-            }
-            out.section = next;
-            i++;
-            continue;
-        }
-        throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-    }
-    return out;
-}
-function parseTaskDocSetFlags(args) {
-    const out = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        if (!arg.startsWith("--")) {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unexpected argument: ${arg}` });
-        }
-        const next = args[i + 1];
-        if (!next) {
-            throw new CliError({ exitCode: 2, code: "E_USAGE", message: missingValueMessage(arg) });
-        }
-        switch (arg) {
-            case "--section": {
-                out.section = next;
-                break;
-            }
-            case "--text": {
-                out.text = next;
-                break;
-            }
-            case "--file": {
-                out.file = next;
-                break;
-            }
-            case "--updated-by": {
-                out.updatedBy = next;
-                break;
-            }
-            default: {
-                throw new CliError({ exitCode: 2, code: "E_USAGE", message: `Unknown flag: ${arg}` });
-            }
-        }
-        i++;
-    }
-    return out;
-}
-export async function cmdTaskDocSet(opts) {
-    const flags = parseTaskDocSetFlags(opts.args);
-    if (!flags.section) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(TASK_DOC_SET_USAGE, TASK_DOC_SET_USAGE_EXAMPLE),
-        });
-    }
-    const hasText = flags.text !== undefined;
-    const hasFile = flags.file !== undefined;
-    if (hasText === hasFile) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: usageMessage(TASK_DOC_SET_USAGE, TASK_DOC_SET_USAGE_EXAMPLE),
-        });
-    }
-    let updatedBy;
-    if (flags.updatedBy !== undefined) {
-        const trimmed = flags.updatedBy.trim();
-        if (trimmed.length === 0) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: "--updated-by must be non-empty",
-            });
-        }
-        updatedBy = trimmed;
-    }
-    let text = flags.text ?? "";
-    if (hasFile) {
-        try {
-            text = await readFile(path.resolve(opts.cwd, flags.file ?? ""), "utf8");
-        }
-        catch (err) {
-            throw mapCoreError(err, { command: "task doc set", filePath: flags.file ?? "" });
-        }
-    }
-    try {
-        const { backend, resolved, config } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        if (!backend.getTaskDoc || !backend.setTaskDoc) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: backendNotSupportedMessage("task docs"),
-            });
-        }
-        const allowed = config.tasks.doc.sections;
-        if (!allowed.includes(flags.section)) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: unknownEntityMessage("doc section", flags.section),
-            });
-        }
-        const normalizedAllowed = new Set(allowed.map((section) => normalizeDocSectionName(section)));
-        const targetKey = normalizeDocSectionName(flags.section);
-        const headingKeys = new Set();
-        for (const line of text.replaceAll("\r\n", "\n").split("\n")) {
-            const match = /^##\s+(.*)$/.exec(line.trim());
-            if (!match)
-                continue;
-            const key = normalizeDocSectionName(match[1] ?? "");
-            if (key && normalizedAllowed.has(key))
-                headingKeys.add(key);
-        }
-        const existing = await backend.getTaskDoc(opts.taskId);
-        const baseDoc = ensureDocSections(existing ?? "", config.tasks.doc.required_sections);
-        if (headingKeys.size > 0 && (headingKeys.size > 1 || !headingKeys.has(targetKey))) {
-            const fullDoc = ensureDocSections(text, config.tasks.doc.required_sections);
-            await backend.setTaskDoc(opts.taskId, fullDoc, updatedBy);
-        }
-        else {
-            let nextText = text;
-            if (headingKeys.size > 0 && headingKeys.has(targetKey)) {
-                const lines = nextText.replaceAll("\r\n", "\n").split("\n");
-                let firstContent = 0;
-                while (firstContent < lines.length && lines[firstContent]?.trim() === "")
-                    firstContent++;
-                if ((lines[firstContent]?.trim() ?? "") === `## ${flags.section}`) {
-                    lines.splice(firstContent, 1);
-                    if (lines[firstContent]?.trim() === "")
-                        lines.splice(firstContent, 1);
-                    nextText = lines.join("\n");
-                }
-            }
-            const nextDoc = setMarkdownSection(baseDoc, flags.section, nextText);
-            const normalized = ensureDocSections(nextDoc, config.tasks.doc.required_sections);
-            await backend.setTaskDoc(opts.taskId, normalized, updatedBy);
-        }
-        const tasksDir = path.join(resolved.gitRoot, config.paths.workflow_dir);
-        process.stdout.write(`${path.join(tasksDir, opts.taskId, "README.md")}\n`);
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "task doc set", root: opts.rootOverride ?? null });
-    }
-}
-export async function cmdTaskDocShow(opts) {
-    const flags = parseTaskDocShowFlags(opts.args);
-    try {
-        const { backend } = await loadTaskBackend({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride ?? null,
-        });
-        if (!backend.getTaskDoc) {
-            throw new CliError({
-                exitCode: 2,
-                code: "E_USAGE",
-                message: backendNotSupportedMessage("task docs"),
-            });
-        }
-        const doc = (await backend.getTaskDoc(opts.taskId)) ?? "";
-        if (flags.section) {
-            const sectionKey = normalizeDocSectionName(flags.section);
-            const { sections } = parseDocSections(doc);
-            const entry = sections.get(sectionKey);
-            const content = entry?.lines ?? [];
-            if (content.length > 0) {
-                process.stdout.write(`${content.join("\n").trimEnd()}\n`);
-                return 0;
-            }
-            if (!flags.quiet) {
-                process.stdout.write(`${infoMessage(`section has no content: ${flags.section}`)}\n`);
-            }
-            return 0;
-        }
-        if (doc.trim()) {
-            process.stdout.write(`${doc.trimEnd()}\n`);
-            return 0;
-        }
-        if (!flags.quiet) {
-            process.stdout.write(`${infoMessage("task doc metadata missing")}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        if (err instanceof CliError)
-            throw err;
-        throw mapBackendError(err, { command: "task doc show", root: opts.rootOverride ?? null });
-    }
-}
+export { TASK_NEW_USAGE, TASK_NEW_USAGE_EXAMPLE, TASK_ADD_USAGE, TASK_ADD_USAGE_EXAMPLE, TASK_SCRUB_USAGE, TASK_SCRUB_USAGE_EXAMPLE, TASK_UPDATE_USAGE, TASK_UPDATE_USAGE_EXAMPLE, TASK_SCAFFOLD_USAGE, TASK_SCAFFOLD_USAGE_EXAMPLE, TASK_DOC_SET_USAGE, TASK_DOC_SET_USAGE_EXAMPLE, TASK_DOC_SHOW_USAGE, TASK_DOC_SHOW_USAGE_EXAMPLE, START_USAGE, START_USAGE_EXAMPLE, BLOCK_USAGE, BLOCK_USAGE_EXAMPLE, FINISH_USAGE, FINISH_USAGE_EXAMPLE, VERIFY_USAGE, VERIFY_USAGE_EXAMPLE, dedupeStrings, cmdTaskNew, cmdTaskAdd, cmdTaskUpdate, cmdTaskScrub, cmdTaskListWithFilters, cmdTaskNext, cmdReady, cmdTaskSearch, cmdTaskScaffold, cmdTaskNormalize, cmdTaskMigrate, cmdTaskComment, cmdTaskSetStatus, cmdTaskShow, cmdTaskList, cmdTaskExport, cmdTaskLint, cmdTaskDocSet, cmdTaskDocShow, cmdStart, cmdBlock, cmdFinish, cmdVerify, } from "./task/index.js";
+export { BRANCH_BASE_USAGE, BRANCH_BASE_USAGE_EXAMPLE, BRANCH_STATUS_USAGE, BRANCH_STATUS_USAGE_EXAMPLE, BRANCH_REMOVE_USAGE, BRANCH_REMOVE_USAGE_EXAMPLE, WORK_START_USAGE, WORK_START_USAGE_EXAMPLE, CLEANUP_MERGED_USAGE, CLEANUP_MERGED_USAGE_EXAMPLE, gitInitRepo, resolveInitBaseBranch, promptInitBaseBranch, ensureInitCommit, cmdWorkStart, cmdCleanupMerged, cmdBranchBaseGet, cmdBranchBaseSet, cmdBranchBaseClear, cmdBranchBaseExplain, cmdBranchStatus, cmdBranchRemove, } from "./branch/index.js";
+export { PR_OPEN_USAGE, PR_OPEN_USAGE_EXAMPLE, PR_UPDATE_USAGE, PR_UPDATE_USAGE_EXAMPLE, PR_CHECK_USAGE, PR_CHECK_USAGE_EXAMPLE, PR_NOTE_USAGE, PR_NOTE_USAGE_EXAMPLE, INTEGRATE_USAGE, INTEGRATE_USAGE_EXAMPLE, cmdPrOpen, cmdPrUpdate, cmdPrCheck, cmdPrNote, cmdIntegrate, } from "./pr/index.js";
+export { GUARD_COMMIT_USAGE, GUARD_COMMIT_USAGE_EXAMPLE, COMMIT_USAGE, COMMIT_USAGE_EXAMPLE, suggestAllowPrefixes, cmdGuardClean, cmdGuardSuggestAllow, cmdGuardCommit, cmdCommit, } from "./guard/index.js";
+export { HOOK_NAMES, cmdHooksInstall, cmdHooksUninstall, cmdHooksRun } from "./hooks/index.js";