agentplane 0.1.6 → 0.1.7

package/dist/commands/task/shared.js

@@ -0,0 +1,283 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { invalidValueForFlag, invalidValueMessage, missingValueMessage, warnMessage, } from "../../cli/output.js";
+import { CliError } from "../../shared/errors.js";
+export const execFileAsync = promisify(execFile);
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function normalizeDependsOnInput(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "[]")
+        return [];
+    return [trimmed];
+}
+const ALLOWED_TASK_STATUSES = new Set(["TODO", "DOING", "DONE", "BLOCKED"]);
+export 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;
+}
+export function toStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim());
+}
+export 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()));
+}
+export 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(",")}`;
+}
+export 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}`;
+}
+export 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;
+}
+export 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`,
+        });
+    }
+}
+export 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 };
+}
+export 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 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 };
+}
+export function defaultCommitEmojiForStatus(status) {
+    const normalized = status.trim().toUpperCase();
+    if (normalized === "DOING")
+        return "🚧";
+    if (normalized === "DONE")
+        return "✅";
+    if (normalized === "BLOCKED")
+        return "⛔";
+    return "🧩";
+}
+export 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 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");
+}

package/dist/commands/task/show.d.ts

@@ -0,0 +1,6 @@
+export declare function cmdTaskShow(opts: {
+    cwd: string;
+    rootOverride?: string;
+    taskId: string;
+}): Promise<number>;
+//# sourceMappingURL=show.d.ts.map

package/dist/commands/task/show.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show.d.ts","sourceRoot":"","sources":["../../../src/commands/task/show.ts"],"names":[],"mappings":"AAOA,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BlB"}

package/dist/commands/task/show.js

@@ -0,0 +1,35 @@
+import { validateTaskDocMetadata } from "@agentplaneorg/core";
+import { mapBackendError } from "../../cli/error-map.js";
+import { CliError } from "../../shared/errors.js";
+import { loadBackendTask, taskDataToFrontmatter } from "../shared/task-backend.js";
+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,
+        });
+    }
+}

package/dist/commands/task/start.d.ts

@@ -0,0 +1,19 @@
+export declare const START_USAGE = "Usage: agentplane start <task-id> --author <id> --body <text> [flags]";
+export declare const START_USAGE_EXAMPLE = "agentplane start 202602030608-F1Q8AB --author CODER --body \"Start: ...\"";
+export declare function cmdStart(opts: {
+    cwd: string;
+    rootOverride?: string;
+    taskId: string;
+    author: string;
+    body: string;
+    commitFromComment: boolean;
+    commitEmoji?: string;
+    commitAllow: string[];
+    commitAutoAllow: boolean;
+    commitAllowTasks: boolean;
+    commitRequireClean: boolean;
+    confirmStatusCommit: boolean;
+    force: boolean;
+    quiet: boolean;
+}): Promise<number>;
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/task/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../src/commands/task/start.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,WAAW,0EAA0E,CAAC;AACnG,eAAO,MAAM,mBAAmB,8EAC2C,CAAC;AAE5E,wBAAsB,QAAQ,CAAC,IAAI,EAAE;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;IACzB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAgHlB"}

package/dist/commands/task/start.js

@@ -0,0 +1,109 @@
+import { loadConfig, resolveProject } from "@agentplaneorg/core";
+import { mapBackendError } from "../../cli/error-map.js";
+import { successMessage, warnMessage } from "../../cli/output.js";
+import { formatCommentBodyForCommit } from "../../shared/comment-format.js";
+import { CliError } from "../../shared/errors.js";
+import { commitFromComment } from "../guard/index.js";
+import { loadBackendTask } from "../shared/task-backend.js";
+import { buildDependencyState, enforceStatusCommitPolicy, isTransitionAllowed, nowIso, requireStructuredComment, } from "./shared.js";
+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 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 });
+    }
+}

package/dist/commands/task/update.d.ts

@@ -0,0 +1,8 @@
+export declare const TASK_UPDATE_USAGE = "Usage: agentplane task update <task-id> [flags]";
+export declare const TASK_UPDATE_USAGE_EXAMPLE = "agentplane task update 202602030608-F1Q8AB --title \"...\" --owner CODER";
+export declare function cmdTaskUpdate(opts: {
+    cwd: string;
+    rootOverride?: string;
+    args: string[];
+}): Promise<number>;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/task/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/commands/task/update.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,iBAAiB,oDAAoD,CAAC;AACnF,eAAO,MAAM,yBAAyB,6EACoC,CAAC;AAuG3E,wBAAsB,aAAa,CAAC,IAAI,EAAE;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoDlB"}

package/dist/commands/task/update.js

@@ -0,0 +1,144 @@
+import { loadTaskBackend } from "../../backends/task-backend.js";
+import { mapBackendError } from "../../cli/error-map.js";
+import { missingValueMessage, successMessage, unknownEntityMessage, usageMessage, } from "../../cli/output.js";
+import { CliError } from "../../shared/errors.js";
+import { dedupeStrings, normalizeDependsOnInput, requiresVerify, toStringArray } from "./shared.js";
+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';
+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 });
+    }
+}

package/dist/commands/task/verify.d.ts

@@ -0,0 +1,14 @@
+export declare const VERIFY_USAGE = "Usage: agentplane verify <task-id> [--cwd <path>] [--log <path>] [--skip-if-unchanged] [--quiet] [--require] [--yes]";
+export declare const VERIFY_USAGE_EXAMPLE = "agentplane verify 202602030608-F1Q8AB";
+export declare function cmdVerify(opts: {
+    cwd: string;
+    rootOverride?: string;
+    taskId: string;
+    execCwd?: string;
+    logPath?: string;
+    skipIfUnchanged: boolean;
+    quiet: boolean;
+    require: boolean;
+    yes: boolean;
+}): Promise<number>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/commands/task/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/commands/task/verify.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,YAAY,yHAC+F,CAAC;AACzH,eAAO,MAAM,oBAAoB,0CAA0C,CAAC;AAsG5E,wBAAsB,SAAS,CAAC,IAAI,EAAE;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;CACd,GAAG,OAAO,CAAC,MAAM,CAAC,CA4RlB"}