agentplane 0.3.6 → 0.3.8

package/dist/commands/task/finish.js

@@ -1,17 +1,14 @@
-import { ensureDocSections } from "@agentplaneorg/core";
 import { mapBackendError } from "../../cli/error-map.js";
 import { infoMessage, invalidValueMessage, successMessage } from "../../cli/output.js";
-import { formatCommentBodyForCommit } from "../../shared/comment-format.js";
 import { CliError } from "../../shared/errors.js";
 import { readFile, rm } from "node:fs/promises";
 import path from "node:path";
-import { buildGitCommitEnv, cmdCommit, commitFromComment } from "../guard/index.js";
 import { ensureActionApproved } from "../shared/approval-requirements.js";
 import { ensureReconciledBeforeMutation } from "../shared/reconcile-check.js";
-import { loadCommandContext, loadTaskFromContext, } from "../shared/task-backend.js";
+import { loadCommandContext } from "../shared/task-backend.js";
 import { backendIsLocalFileBackend, getTaskStore } from "../shared/task-store.js";
-import { readDirectWorkLock } from "../../shared/direct-work-lock.js";
-import { appendTaskEvent, defaultCommitEmojiForStatus, enforceStatusCommitPolicy, ensureAgentFilledRequiredDocSections, ensureVerificationSatisfiedIfRequired, normalizeTaskDocVersion, nowIso, readCommitInfo, readHeadCommit, requireStructuredComment, resolvePrimaryTag, toStringArray, } from "./shared.js";
+import { createTaskCloseCommit, existingCommitInfo, loadTaskForFinish, writeFinishedTasks, } from "./finish-shared.js";
+import { defaultCommitEmojiForStatus, enforceStatusCommitPolicy, prepareTaskTransitionComment, readCommitInfo, requireStructuredComment, runTaskTransitionCommentCommit, } from "./shared.js";
 async function clearDirectWorkLockIfMatches(opts) {
     const lockPath = path.join(opts.agentplaneDir, "cache", "direct-work.json");
     try {
@@ -28,43 +25,6 @@ async function clearDirectWorkLockIfMatches(opts) {
         // best-effort
     }
 }
-function assertTaskCanFinish(opts) {
-    if (!opts.force && String(opts.task.status || "TODO").toUpperCase() === "DONE") {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: `Task is already DONE: ${opts.task.id} (use --force to override)`,
-        });
-    }
-    ensureVerificationSatisfiedIfRequired(opts.task, opts.config);
-    const normalizedDoc = ensureDocSections(typeof opts.task.doc === "string" ? opts.task.doc : "", opts.config.tasks.doc.required_sections);
-    ensureAgentFilledRequiredDocSections({
-        task: opts.task,
-        config: opts.config,
-        doc: normalizedDoc,
-        action: "finish task",
-    });
-    if (!opts.isMetaTask)
-        return;
-    const tags = Array.isArray(opts.task.tags)
-        ? opts.task.tags.filter((t) => typeof t === "string")
-        : [];
-    const isSpike = tags.includes("spike");
-    if (!isSpike && opts.taskCount === 1 && !opts.resultSummary) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Missing required --result for non-spike tasks.",
-        });
-    }
-    if (opts.resultProvided && !opts.resultSummary) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: "Invalid value for --result: empty.",
-        });
-    }
-}
 export async function cmdFinish(opts) {
     try {
         const ctx = opts.ctx ??
@@ -88,6 +48,13 @@ export async function cmdFinish(opts) {
                 message: "--commit-from-comment/--status-commit requires exactly one task id",
             });
         }
+        if (opts.commitFromComment && statusCommitRequested) {
+            throw new CliError({
+                exitCode: 2,
+                code: "E_USAGE",
+                message: "--commit-from-comment cannot be combined with --status-commit in finish; use one deterministic commit path.",
+            });
+        }
         if ((opts.closeCommit || opts.noCloseCommit) && opts.taskIds.length !== 1) {
             throw new CliError({
                 exitCode: 2,
@@ -145,10 +112,6 @@ export async function cmdFinish(opts) {
                 message: "--status-commit requires --status-commit-allow <path-prefix>",
             });
         }
-        const gitRoot = ctx.resolvedProject.gitRoot;
-        const commitInfo = opts.commit
-            ? await readCommitInfo(gitRoot, opts.commit)
-            : await readHeadCommit(gitRoot);
         const useStore = backendIsLocalFileBackend(ctx);
         const store = useStore ? getTaskStore(ctx) : null;
         const backendWritesTaskReadmes = ctx.taskBackend.capabilities.writes_task_readmes === true;
@@ -157,7 +120,12 @@ export async function cmdFinish(opts) {
             opts.taskIds.length === 1 &&
             !opts.commitFromComment &&
             !statusCommitRequested;
-        const shouldCloseCommit = opts.closeCommit === true || (defaultDirectCloseCommit && opts.noCloseCommit !== true);
+        const statusPathRequiresTrackedTaskCommit = backendWritesTaskReadmes &&
+            opts.taskIds.length === 1 &&
+            (opts.commitFromComment || statusCommitRequested);
+        const shouldCloseCommit = opts.closeCommit === true ||
+            statusPathRequiresTrackedTaskCommit ||
+            (defaultDirectCloseCommit && opts.noCloseCommit !== true);
         const metaTaskId = opts.taskIds.length === 1 ? (opts.taskIds[0] ?? "") : "";
         const wantMeta = typeof opts.result === "string" || typeof opts.risk === "string" || opts.breaking === true;
         const resultProvided = typeof opts.result === "string";
@@ -173,90 +141,36 @@ export async function cmdFinish(opts) {
         const breaking = opts.breaking === true;
         let primaryStatusFrom = null;
         let primaryTag = null;
+        const loadedTasks = [];
         for (const taskId of opts.taskIds) {
-            const task = useStore ? await store.get(taskId) : await loadTaskFromContext({ ctx, taskId });
-            assertTaskCanFinish({
-                task,
-                config: ctx.config,
+            const loaded = await loadTaskForFinish({
+                ctx,
+                store,
+                useStore,
+                taskId,
                 taskCount: opts.taskIds.length,
-                isMetaTask: taskId === metaTaskId,
+                metaTaskId,
                 resultProvided,
                 resultSummary,
                 force: opts.force,
+                capturePrimaryLifecycleMeta: taskId === primaryTaskId,
             });
-            if (taskId === primaryTaskId &&
-                (opts.commitFromComment || statusCommitRequested) &&
-                primaryStatusFrom === null) {
-                primaryStatusFrom = String(task.status || "TODO").toUpperCase();
-                primaryTag = resolvePrimaryTag(toStringArray(task.tags), ctx).primary;
-            }
-            const at = nowIso();
-            if (useStore) {
-                await store.patch(taskId, (current) => {
-                    assertTaskCanFinish({
-                        task: current,
-                        config: ctx.config,
-                        taskCount: opts.taskIds.length,
-                        isMetaTask: taskId === metaTaskId,
-                        resultProvided,
-                        resultSummary,
-                        force: opts.force,
-                    });
-                    const currentStatus = String(current.status || "TODO").toUpperCase();
-                    return {
-                        task: {
-                            status: "DONE",
-                            commit: { hash: commitInfo.hash, message: commitInfo.message },
-                            ...(taskId === metaTaskId && resultSummary ? { result_summary: resultSummary } : {}),
-                            ...(taskId === metaTaskId && riskLevel ? { risk_level: riskLevel } : {}),
-                            ...(taskId === metaTaskId && breaking ? { breaking: true } : {}),
-                        },
-                        appendComments: [{ author: opts.author, body: opts.body }],
-                        appendEvents: [
-                            {
-                                type: "status",
-                                at,
-                                author: opts.author,
-                                from: currentStatus,
-                                to: "DONE",
-                                note: opts.body,
-                            },
-                        ],
-                        docMeta: {
-                            touch: true,
-                            updatedBy: opts.author,
-                            version: normalizeTaskDocVersion(current.doc_version),
-                        },
-                    };
-                });
-            }
-            else {
-                const existingComments = Array.isArray(task.comments)
-                    ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
-                    : [];
-                const nextTask = {
-                    ...task,
-                    status: "DONE",
-                    commit: { hash: commitInfo.hash, message: commitInfo.message },
-                    comments: [...existingComments, { author: opts.author, body: opts.body }],
-                    events: appendTaskEvent(task, {
-                        type: "status",
-                        at,
-                        author: opts.author,
-                        from: String(task.status || "TODO").toUpperCase(),
-                        to: "DONE",
-                        note: opts.body,
-                    }),
-                    result_summary: taskId === metaTaskId && resultSummary ? resultSummary : task.result_summary,
-                    risk_level: taskId === metaTaskId && riskLevel ? riskLevel : task.risk_level,
-                    breaking: taskId === metaTaskId && breaking ? true : task.breaking,
-                    doc_version: normalizeTaskDocVersion(task.doc_version),
-                    doc_updated_at: at,
-                    doc_updated_by: opts.author,
-                };
-                await ctx.taskBackend.writeTask(nextTask);
+            loadedTasks.push(loaded.loaded);
+            if (taskId === primaryTaskId) {
+                primaryStatusFrom = loaded.primaryStatusFrom;
+                primaryTag = loaded.primaryTag;
             }
         }
+        const tasksMissingCommit = loadedTasks
+            .filter(({ task }) => !existingCommitInfo(task))
+            .map(({ taskId }) => taskId);
+        if (!opts.commitFromComment && !opts.commit && tasksMissingCommit.length > 0) {
+            throw new CliError({
+                exitCode: 2,
+                code: "E_USAGE",
+                message: "finish requires --commit <hash> or existing task commit metadata on every task; implicit HEAD fallback was removed.",
+            });
+        }
         if (opts.commitFromComment || statusCommitRequested) {
             enforceStatusCommitPolicy({
                 policy: ctx.config.status_commit_policy,
@@ -267,22 +181,18 @@ export async function cmdFinish(opts) {
                 statusTo: "DONE",
             });
         }
-        // tasks.json is export-only; generated via `agentplane task export`.
-        let executorAgent = null;
-        if (opts.commitFromComment || statusCommitRequested) {
-            const mode = ctx.config.workflow_mode;
-            executorAgent = opts.author;
-            if (mode === "direct") {
-                const lock = await readDirectWorkLock(ctx.resolvedProject.agentplaneDir);
-                const lockAgent = lock?.task_id === primaryTaskId ? (lock.agent?.trim() ?? "") : "";
-                if (lockAgent)
-                    executorAgent = lockAgent;
-            }
-        }
+        const gitRoot = ctx.resolvedProject.gitRoot;
+        let taskCommitInfo = opts.commit
+            ? await readCommitInfo(gitRoot, opts.commit)
+            : null;
+        const preparedComment = opts.commitFromComment || statusCommitRequested
+            ? prepareTaskTransitionComment({
+                body: opts.body,
+                enabled: true,
+                config: ctx.config,
+            })
+            : null;
         if (opts.commitFromComment) {
-            if (!opts.quiet) {
-                process.stdout.write(`${infoMessage("task marked DONE; creating commit from verification comment")}\n`);
-            }
             if (typeof opts.commitEmoji === "string" && opts.commitEmoji.trim() !== "✅") {
                 throw new CliError({
                     exitCode: 2,
@@ -290,72 +200,28 @@ export async function cmdFinish(opts) {
                     message: invalidValueMessage("--commit-emoji", opts.commitEmoji, "✅ (finish commits must use a checkmark)"),
                 });
             }
-            const committed = await commitFromComment({
+            taskCommitInfo = await runTaskTransitionCommentCommit({
                 ctx,
                 cwd: opts.cwd,
                 rootOverride: opts.rootOverride,
                 taskId: primaryTaskId,
                 primaryTag: primaryTag ?? "meta",
-                executorAgent: executorAgent ?? undefined,
                 author: opts.author,
                 statusFrom: primaryStatusFrom ?? undefined,
                 statusTo: "DONE",
                 commentBody: opts.body,
-                formattedComment: formatCommentBodyForCommit(opts.body, ctx.config),
+                formattedComment: preparedComment?.formattedComment ?? null,
                 emoji: opts.commitEmoji ?? defaultCommitEmojiForStatus("DONE"),
                 allow: opts.commitAllow,
                 autoAllow: false,
                 allowTasks: opts.commitAllowTasks,
                 requireClean: opts.commitRequireClean,
                 quiet: opts.quiet,
-                config: ctx.config,
+                progressMessage: "creating commit from verification comment",
+                resolveExecutorAgent: true,
             });
-            // commitFromComment creates the git commit and returns the actual head hash/subject.
-            // Refresh task commit metadata to this hash and amend the same commit in local mode so
-            // "task done" metadata does not require a manual follow-up close commit.
-            await (useStore
-                ? store.patch(primaryTaskId, (current) => ({
-                    task: {
-                        commit: { hash: committed.hash, message: committed.message },
-                    },
-                    docMeta: {
-                        touch: true,
-                        updatedBy: opts.author,
-                        version: normalizeTaskDocVersion(current.doc_version),
-                    },
-                }))
-                : (async () => {
-                    const taskAfterCommit = await loadTaskFromContext({ ctx, taskId: primaryTaskId });
-                    const updatedAfterCommit = {
-                        ...taskAfterCommit,
-                        commit: { hash: committed.hash, message: committed.message },
-                        doc_version: normalizeTaskDocVersion(taskAfterCommit.doc_version),
-                        doc_updated_at: nowIso(),
-                        doc_updated_by: opts.author,
-                    };
-                    await ctx.taskBackend.writeTask(updatedAfterCommit);
-                })());
-            if (backendWritesTaskReadmes) {
-                const workflowReadmeRelPath = path.join(ctx.config.paths.workflow_dir, primaryTaskId, "README.md");
-                await ctx.git.stage([workflowReadmeRelPath]);
-                const env = buildGitCommitEnv({
-                    taskId: primaryTaskId,
-                    agentId: executorAgent ?? undefined,
-                    statusTo: "DONE",
-                    allowTasks: true,
-                    allowBase: false,
-                    allowPolicy: false,
-                    allowConfig: false,
-                    allowHooks: false,
-                    allowCI: false,
-                });
-                await ctx.git.commitAmendNoEdit({ env });
-            }
         }
         if (statusCommitRequested) {
-            if (!opts.quiet) {
-                process.stdout.write(`${infoMessage("task marked DONE; creating status commit")}\n`);
-            }
             if (typeof opts.statusCommitEmoji === "string" && opts.statusCommitEmoji.trim() !== "✅") {
                 throw new CliError({
                     exitCode: 2,
@@ -363,50 +229,53 @@ export async function cmdFinish(opts) {
                     message: invalidValueMessage("--status-commit-emoji", opts.statusCommitEmoji, "✅ (finish commits must use a checkmark)"),
                 });
             }
-            await commitFromComment({
+            await runTaskTransitionCommentCommit({
                 ctx,
                 cwd: opts.cwd,
                 rootOverride: opts.rootOverride,
                 taskId: primaryTaskId,
                 primaryTag: primaryTag ?? "meta",
-                executorAgent: executorAgent ?? undefined,
                 author: opts.author,
                 statusFrom: primaryStatusFrom ?? undefined,
                 statusTo: "DONE",
                 commentBody: opts.body,
-                formattedComment: formatCommentBodyForCommit(opts.body, ctx.config),
+                formattedComment: preparedComment?.formattedComment ?? null,
                 emoji: opts.statusCommitEmoji ?? defaultCommitEmojiForStatus("DONE"),
                 allow: opts.statusCommitAllow,
                 autoAllow: false,
                 allowTasks: true,
                 requireClean: opts.statusCommitRequireClean,
                 quiet: opts.quiet,
-                config: ctx.config,
+                progressMessage: "creating status commit",
+                resolveExecutorAgent: true,
             });
         }
+        await writeFinishedTasks({
+            ctx,
+            loadedTasks,
+            metaTaskId,
+            author: opts.author,
+            body: opts.body,
+            force: opts.force,
+            resultProvided,
+            resultSummary,
+            riskLevel,
+            breaking,
+            taskCommitInfo,
+        });
+        // tasks.json is export-only; generated via `agentplane task export`.
         if (shouldCloseCommit && primaryTaskId) {
             if (!opts.quiet) {
                 process.stdout.write(`${infoMessage("task marked DONE; creating deterministic close commit")}\n`);
             }
-            await cmdCommit({
+            await createTaskCloseCommit({
                 ctx,
                 cwd: opts.cwd,
                 rootOverride: opts.rootOverride,
                 taskId: primaryTaskId,
-                message: "",
-                close: true,
-                allow: [],
-                autoAllow: false,
-                allowTasks: true,
-                allowBase: false,
-                allowPolicy: false,
-                allowConfig: false,
-                allowHooks: false,
-                allowCI: false,
-                requireClean: true,
+                baseBranchOverride: opts.baseBranchOverride,
                 quiet: opts.quiet,
                 closeUnstageOthers: opts.closeCommit === true && opts.closeUnstageOthers === true,
-                closeCheckOnly: false,
             });
         }
         if (ctx.config.workflow_mode === "direct") {

package/dist/commands/task/handoff-record.command.d.ts

@@ -0,0 +1,17 @@
+import type { CommandCtx, CommandSpec } from "../../cli/spec/spec.js";
+export type TaskHandoffRecordParsed = {
+    taskId: string;
+    fromRole: string;
+    toRole?: string;
+    reason: string;
+    note?: string;
+    runId?: string;
+    nextActions: string[];
+    risks: string[];
+    openQuestions: string[];
+    evidencePaths: string[];
+    json: boolean;
+};
+export declare const taskHandoffRecordSpec: CommandSpec<TaskHandoffRecordParsed>;
+export declare const runTaskHandoffRecord: (ctx: CommandCtx, parsed: TaskHandoffRecordParsed) => Promise<number>;
+//# sourceMappingURL=handoff-record.command.d.ts.map

package/dist/commands/task/handoff-record.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-record.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/handoff-record.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAQtE,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,uBAAuB,CA+FtE,CAAC;AAIF,eAAO,MAAM,oBAAoB,GAAU,KAAK,UAAU,EAAE,QAAQ,uBAAuB,oBA0C1F,CAAC"}

package/dist/commands/task/handoff-record.command.js

@@ -0,0 +1,140 @@
+import { usageError } from "../../cli/spec/errors.js";
+import { createCliEmitter, infoMessage } from "../../cli/output.js";
+import { buildRecordedTaskHandoff } from "./handoff.shared.js";
+import { resolveTaskHandoffPaths, writeTaskHandoff } from "../shared/task-handoff.js";
+export const taskHandoffRecordSpec = {
+    id: ["task", "handoff", "record"],
+    group: "Task",
+    summary: "Record a task handoff snapshot with runner recovery hints.",
+    args: [{ name: "task-id", required: true, valueHint: "<task-id>" }],
+    options: [
+        {
+            kind: "string",
+            name: "from",
+            valueHint: "<role>",
+            description: "Role handing off the task.",
+        },
+        {
+            kind: "string",
+            name: "to",
+            valueHint: "<role>",
+            description: "Optional. Intended receiving role.",
+        },
+        {
+            kind: "string",
+            name: "reason",
+            valueHint: "<text>",
+            description: "Why the handoff is happening.",
+        },
+        {
+            kind: "string",
+            name: "note",
+            valueHint: "<text>",
+            description: "Optional. Free-form handoff note.",
+        },
+        {
+            kind: "string",
+            name: "run-id",
+            valueHint: "<run-id>",
+            description: "Optional. Pin handoff hints to a specific runner run.",
+        },
+        {
+            kind: "string",
+            name: "next-action",
+            valueHint: "<text>",
+            repeatable: true,
+            description: "Repeatable. Human next actions for the receiving agent.",
+        },
+        {
+            kind: "string",
+            name: "risk",
+            valueHint: "<text>",
+            repeatable: true,
+            description: "Repeatable. Risks or watch-outs that remain open.",
+        },
+        {
+            kind: "string",
+            name: "question",
+            valueHint: "<text>",
+            repeatable: true,
+            description: "Repeatable. Open questions for the next agent.",
+        },
+        {
+            kind: "string",
+            name: "evidence-path",
+            valueHint: "<path>",
+            repeatable: true,
+            description: "Repeatable. Relevant evidence or artifact paths.",
+        },
+        {
+            kind: "boolean",
+            name: "json",
+            default: false,
+            description: "Emit the persisted handoff snapshot as JSON.",
+        },
+    ],
+    validateRaw: (raw) => {
+        for (const key of ["from", "reason"]) {
+            const value = raw.opts[key];
+            if (typeof value !== "string" || value.trim() === "") {
+                throw usageError({
+                    spec: taskHandoffRecordSpec,
+                    message: `Missing required option: --${key}.`,
+                });
+            }
+        }
+    },
+    parse: (raw) => ({
+        taskId: String(raw.args["task-id"]),
+        fromRole: String(raw.opts.from),
+        toRole: typeof raw.opts.to === "string" ? raw.opts.to : undefined,
+        reason: String(raw.opts.reason),
+        note: typeof raw.opts.note === "string" ? raw.opts.note : undefined,
+        runId: typeof raw.opts["run-id"] === "string" ? raw.opts["run-id"] : undefined,
+        nextActions: raw.opts["next-action"] ?? [],
+        risks: raw.opts.risk ?? [],
+        openQuestions: raw.opts.question ?? [],
+        evidencePaths: raw.opts["evidence-path"] ?? [],
+        json: raw.opts.json === true,
+    }),
+};
+const emitter = createCliEmitter();
+export const runTaskHandoffRecord = async (ctx, parsed) => {
+    const built = await buildRecordedTaskHandoff({
+        cwd: ctx.cwd,
+        rootOverride: ctx.rootOverride ?? null,
+        task_id: parsed.taskId,
+        from_role: parsed.fromRole,
+        to_role: parsed.toRole,
+        reason: parsed.reason,
+        note: parsed.note,
+        run_id: parsed.runId,
+        next_actions: parsed.nextActions,
+        risks: parsed.risks,
+        open_questions: parsed.openQuestions,
+        evidence_paths: parsed.evidencePaths,
+    });
+    const paths = resolveTaskHandoffPaths({
+        git_root: built.ctx.resolvedProject.gitRoot,
+        workflow_dir: built.ctx.config.paths.workflow_dir,
+        task_id: parsed.taskId,
+    });
+    await writeTaskHandoff({ paths, handoff: built.handoff });
+    if (parsed.json) {
+        emitter.json(built.handoff);
+        return 0;
+    }
+    const entries = [
+        { label: "from", value: built.handoff.from_role },
+        { label: "to", value: built.handoff.to_role ?? "unassigned" },
+        { label: "reason", value: built.handoff.reason },
+    ];
+    if (built.handoff.runner?.run_id) {
+        entries.push({ label: "run_id", value: built.handoff.runner.run_id }, { label: "runner_status", value: built.handoff.runner.status ?? "unknown" }, { label: "runner_next_action", value: built.handoff.runner.next_action ?? "none" });
+    }
+    entries.push({ label: "latest", value: paths.latest_path });
+    emitter.report(entries, {
+        header: infoMessage(`task handoff recorded: ${parsed.taskId}`),
+    });
+    return 0;
+};

package/dist/commands/task/handoff-show.command.d.ts

@@ -0,0 +1,8 @@
+import type { CommandCtx, CommandSpec } from "../../cli/spec/spec.js";
+export type TaskHandoffShowParsed = {
+    taskId: string;
+    json: boolean;
+};
+export declare const taskHandoffShowSpec: CommandSpec<TaskHandoffShowParsed>;
+export declare const runTaskHandoffShow: (ctx: CommandCtx, parsed: TaskHandoffShowParsed) => Promise<number>;
+//# sourceMappingURL=handoff-show.command.d.ts.map

package/dist/commands/task/handoff-show.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-show.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/handoff-show.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAOtE,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,qBAAqB,CAiBlE,CAAC;AAIF,eAAO,MAAM,kBAAkB,GAAU,KAAK,UAAU,EAAE,QAAQ,qBAAqB,oBAsDtF,CAAC"}

package/dist/commands/task/handoff-show.command.js

@@ -0,0 +1,77 @@
+import { createCliEmitter, infoMessage } from "../../cli/output.js";
+import { loadCommandContext } from "../shared/task-backend.js";
+import { readTaskHandoffLatestRequired, resolveTaskHandoffPaths } from "../shared/task-handoff.js";
+export const taskHandoffShowSpec = {
+    id: ["task", "handoff", "show"],
+    group: "Task",
+    summary: "Show the latest persisted task handoff snapshot.",
+    args: [{ name: "task-id", required: true, valueHint: "<task-id>" }],
+    options: [
+        {
+            kind: "boolean",
+            name: "json",
+            default: false,
+            description: "Emit machine-readable handoff JSON.",
+        },
+    ],
+    parse: (raw) => ({
+        taskId: String(raw.args["task-id"]),
+        json: raw.opts.json === true,
+    }),
+};
+const emitter = createCliEmitter();
+export const runTaskHandoffShow = async (ctx, parsed) => {
+    const commandCtx = await loadCommandContext({
+        cwd: ctx.cwd,
+        rootOverride: ctx.rootOverride ?? null,
+    });
+    const paths = resolveTaskHandoffPaths({
+        git_root: commandCtx.resolvedProject.gitRoot,
+        workflow_dir: commandCtx.config.paths.workflow_dir,
+        task_id: parsed.taskId,
+    });
+    const handoff = await readTaskHandoffLatestRequired({
+        task_id: parsed.taskId,
+        paths,
+    });
+    if (parsed.json) {
+        emitter.json(handoff);
+        return 0;
+    }
+    const entries = [
+        { label: "from", value: handoff.from_role },
+        { label: "to", value: handoff.to_role ?? "unassigned" },
+        { label: "created_at", value: handoff.created_at },
+        { label: "reason", value: handoff.reason },
+    ];
+    if (handoff.branch)
+        entries.push({ label: "branch", value: handoff.branch });
+    if (handoff.base_branch)
+        entries.push({ label: "base_branch", value: handoff.base_branch });
+    if (handoff.head_sha)
+        entries.push({ label: "head_sha", value: handoff.head_sha });
+    if (handoff.pr_branch)
+        entries.push({ label: "pr_branch", value: handoff.pr_branch });
+    if (handoff.runner?.run_id) {
+        entries.push({ label: "run_id", value: handoff.runner.run_id }, { label: "runner_status", value: handoff.runner.status ?? "unknown" }, { label: "runner_next_action", value: handoff.runner.next_action ?? "none" });
+        if (handoff.runner.next_command) {
+            entries.push({ label: "runner_next_command", value: handoff.runner.next_command });
+        }
+    }
+    for (const action of handoff.next_actions ?? []) {
+        entries.push({ label: "next_action", value: action });
+    }
+    for (const risk of handoff.risks ?? []) {
+        entries.push({ label: "risk", value: risk });
+    }
+    for (const question of handoff.open_questions ?? []) {
+        entries.push({ label: "open_question", value: question });
+    }
+    for (const evidence of handoff.evidence_paths ?? []) {
+        entries.push({ label: "evidence_path", value: evidence });
+    }
+    emitter.report(entries, {
+        header: infoMessage(`task handoff show: ${parsed.taskId}`),
+    });
+    return 0;
+};

package/dist/commands/task/handoff.command.d.ts

@@ -0,0 +1,7 @@
+import type { CommandCtx, CommandSpec } from "../../cli/spec/spec.js";
+export type TaskHandoffParsed = {
+    subcommand?: string;
+};
+export declare const taskHandoffSpec: CommandSpec<TaskHandoffParsed>;
+export declare function runTaskHandoff(_ctx: CommandCtx, p: TaskHandoffParsed): Promise<number>;
+//# sourceMappingURL=handoff.command.d.ts.map

package/dist/commands/task/handoff.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/handoff.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAGtE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,iBAAiB,CAY1D,CAAC;AAEF,wBAAsB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM5F"}