agentplane 0.3.6 → 0.3.8

package/dist/commands/task/reclaim.command.js

@@ -0,0 +1,102 @@
+import { usageError } from "../../cli/spec/errors.js";
+import { createCliEmitter, infoMessage } from "../../cli/output.js";
+import { buildRecordedTaskHandoff, buildTaskResumeContext } from "./handoff.shared.js";
+import { resolveTaskHandoffPaths, writeTaskHandoff } from "../shared/task-handoff.js";
+export const taskReclaimSpec = {
+    id: ["task", "reclaim"],
+    group: "Task",
+    summary: "Claim an interrupted task and persist a recovery handoff snapshot.",
+    args: [{ name: "task-id", required: true, valueHint: "<task-id>" }],
+    options: [
+        {
+            kind: "string",
+            name: "author",
+            valueHint: "<role>",
+            description: "Role reclaiming the task.",
+        },
+        {
+            kind: "string",
+            name: "reason",
+            valueHint: "<text>",
+            description: "Why the task is being reclaimed.",
+        },
+        {
+            kind: "boolean",
+            name: "force",
+            default: false,
+            description: "Allow reclaim even when the latest run still appears alive.",
+        },
+        {
+            kind: "boolean",
+            name: "json",
+            default: false,
+            description: "Emit the persisted reclaim handoff as JSON.",
+        },
+    ],
+    validateRaw: (raw) => {
+        for (const key of ["author", "reason"]) {
+            const value = raw.opts[key];
+            if (typeof value !== "string" || value.trim() === "") {
+                throw usageError({
+                    spec: taskReclaimSpec,
+                    message: `Missing required option: --${key}.`,
+                });
+            }
+        }
+    },
+    parse: (raw) => ({
+        taskId: String(raw.args["task-id"]),
+        author: String(raw.opts.author),
+        reason: String(raw.opts.reason),
+        force: raw.opts.force === true,
+        json: raw.opts.json === true,
+    }),
+};
+const emitter = createCliEmitter();
+export const runTaskReclaim = async (ctx, parsed) => {
+    const resume = await buildTaskResumeContext({
+        cwd: ctx.cwd,
+        rootOverride: ctx.rootOverride ?? null,
+        task_id: parsed.taskId,
+    });
+    if (resume.runner.next_action === "wait" && !parsed.force) {
+        throw usageError({
+            spec: taskReclaimSpec,
+            message: `Refusing to reclaim ${parsed.taskId}: the latest runner still appears alive. ` +
+                `Use --force only if the handoff really is orphaned.`,
+        });
+    }
+    const built = await buildRecordedTaskHandoff({
+        cwd: ctx.cwd,
+        rootOverride: ctx.rootOverride ?? null,
+        task_id: parsed.taskId,
+        from_role: resume.latest_handoff?.to_role ?? resume.latest_handoff?.from_role ?? "UNASSIGNED",
+        to_role: parsed.author,
+        reason: parsed.reason,
+        next_actions: [
+            `Reclaim by ${parsed.author}: follow runner_next_action=${resume.runner.next_action ?? "none"}.`,
+        ],
+    });
+    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: "author", value: parsed.author },
+        { label: "runner_next_action", value: built.handoff.runner?.next_action ?? "none" },
+    ];
+    if (built.handoff.runner?.next_command) {
+        entries.push({ label: "runner_next_command", value: built.handoff.runner.next_command });
+    }
+    entries.push({ label: "latest", value: paths.latest_path });
+    emitter.report(entries, {
+        header: infoMessage(`task reclaimed: ${parsed.taskId}`),
+    });
+    return 0;
+};

package/dist/commands/task/resume-context.command.d.ts

@@ -0,0 +1,9 @@
+import type { CommandCtx, CommandSpec } from "../../cli/spec/spec.js";
+export type TaskResumeContextParsed = {
+    taskId: string;
+    runId?: string;
+    json: boolean;
+};
+export declare const taskResumeContextSpec: CommandSpec<TaskResumeContextParsed>;
+export declare const runTaskResumeContext: (ctx: CommandCtx, parsed: TaskResumeContextParsed) => Promise<number>;
+//# sourceMappingURL=resume-context.command.d.ts.map

package/dist/commands/task/resume-context.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-context.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/resume-context.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAKtE,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,uBAAuB,CAqBtE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,KAAK,UAAU,EAAE,QAAQ,uBAAuB,oBAiC1F,CAAC"}

package/dist/commands/task/resume-context.command.js

@@ -0,0 +1,60 @@
+import { infoMessage } from "../../cli/output.js";
+import { buildTaskResumeContext } from "./handoff.shared.js";
+export const taskResumeContextSpec = {
+    id: ["task", "resume-context"],
+    group: "Task",
+    summary: "Print deterministic recovery context for continuing a task after interruption.",
+    args: [
+        { name: "task-id", required: true, valueHint: "<task-id>" },
+        { name: "run-id", required: false, valueHint: "[run-id]" },
+    ],
+    options: [
+        {
+            kind: "boolean",
+            name: "json",
+            default: false,
+            description: "Emit machine-readable resume context JSON.",
+        },
+    ],
+    parse: (raw) => ({
+        taskId: String(raw.args["task-id"]),
+        runId: typeof raw.args["run-id"] === "string" ? raw.args["run-id"] : undefined,
+        json: raw.opts.json === true,
+    }),
+};
+export const runTaskResumeContext = async (ctx, parsed) => {
+    const resume = await buildTaskResumeContext({
+        cwd: ctx.cwd,
+        rootOverride: ctx.rootOverride ?? null,
+        task_id: parsed.taskId,
+        run_id: parsed.runId,
+    });
+    if (parsed.json) {
+        process.stdout.write(`${JSON.stringify(resume, null, 2)}\n`);
+        return 0;
+    }
+    process.stdout.write(`${infoMessage(`task resume-context: ${parsed.taskId}`)}\n`);
+    process.stdout.write(`task_status: ${resume.task_status}\n`);
+    process.stdout.write(`branch: ${resume.branch ?? "<unknown>"}\n`);
+    process.stdout.write(`base_branch: ${resume.base_branch ?? "<unknown>"}\n`);
+    process.stdout.write(`head_sha: ${resume.head_sha ?? "<unknown>"}\n`);
+    if (resume.pr_branch)
+        process.stdout.write(`pr_branch: ${resume.pr_branch}\n`);
+    process.stdout.write(`runner_status: ${resume.runner.status ?? "none"}\n`);
+    process.stdout.write(`runner_next_action: ${resume.runner.next_action ?? "none"}\n`);
+    if (resume.runner.next_command)
+        process.stdout.write(`runner_next_command: ${resume.runner.next_command}\n`);
+    if (resume.runner.resume_command)
+        process.stdout.write(`runner_resume_command: ${resume.runner.resume_command}\n`);
+    if (resume.runner.retry_command)
+        process.stdout.write(`runner_retry_command: ${resume.runner.retry_command}\n`);
+    if (resume.latest_handoff) {
+        process.stdout.write(`handoff_from: ${resume.latest_handoff.from_role}\n`);
+        process.stdout.write(`handoff_to: ${resume.latest_handoff.to_role ?? "unassigned"}\n`);
+        process.stdout.write(`handoff_reason: ${resume.latest_handoff.reason}\n`);
+    }
+    else {
+        process.stdout.write("handoff: none\n");
+    }
+    return 0;
+};

package/dist/commands/task/run-cancel.command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandHandler } from "../../cli/spec/spec.js";
+import type { TaskRunCancelParsed } from "./run-cancel.spec.js";
+export { taskRunCancelSpec } from "./run-cancel.spec.js";
+export type { TaskRunCancelParsed } from "./run-cancel.spec.js";
+export declare const runTaskRunCancel: CommandHandler<TaskRunCancelParsed>;
+//# sourceMappingURL=run-cancel.command.d.ts.map

package/dist/commands/task/run-cancel.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-cancel.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-cancel.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,wBAAwB,CAAC;AASzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAIhE,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,mBAAmB,CAsChE,CAAC"}

package/dist/commands/task/run-cancel.command.js

@@ -0,0 +1,45 @@
+import { mapBackendError } from "../../cli/error-map.js";
+import { createCliEmitter, infoMessage } from "../../cli/output.js";
+import { loadCommandContext } from "../shared/task-backend.js";
+import { CliError } from "../../shared/errors.js";
+import { cancelTaskRunnerExecution } from "../../runner/usecases/task-run-lifecycle.js";
+export { taskRunCancelSpec } from "./run-cancel.spec.js";
+const emitter = createCliEmitter();
+export const runTaskRunCancel = async (ctx, parsed) => {
+    try {
+        const commandCtx = await loadCommandContext({
+            cwd: ctx.cwd,
+            rootOverride: ctx.rootOverride ?? null,
+        });
+        const cancelled = await cancelTaskRunnerExecution({
+            ctx: commandCtx,
+            cwd: ctx.cwd,
+            rootOverride: ctx.rootOverride ?? null,
+            task_id: parsed.taskId,
+            run_id: parsed.runId,
+        });
+        const entries = [
+            { label: "run_id", value: parsed.runId },
+            { label: "previous_status", value: cancelled.previous_status },
+            { label: "state", value: cancelled.invocation.state_path },
+            { label: "events", value: cancelled.invocation.events_path },
+            { label: "status", value: cancelled.state.status },
+        ];
+        if (!cancelled.changed) {
+            entries.push({ label: "note", value: "run was already cancelled" });
+        }
+        emitter.report(entries, {
+            header: infoMessage(`task run cancelled: ${parsed.taskId}`),
+        });
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapBackendError(err, {
+            command: "task run cancel",
+            task_id: parsed.taskId,
+            run_id: parsed.runId,
+        });
+    }
+};

package/dist/commands/task/run-cancel.spec.d.ts

@@ -0,0 +1,7 @@
+import type { CommandSpec } from "../../cli/spec/spec.js";
+export type TaskRunCancelParsed = {
+    taskId: string;
+    runId: string;
+};
+export declare const taskRunCancelSpec: CommandSpec<TaskRunCancelParsed>;
+//# sourceMappingURL=run-cancel.spec.d.ts.map

package/dist/commands/task/run-cancel.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-cancel.spec.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-cancel.spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,MAAM,MAAM,mBAAmB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,mBAAmB,CAoB9D,CAAC"}

package/dist/commands/task/run-cancel.spec.js

@@ -0,0 +1,20 @@
+export const taskRunCancelSpec = {
+    id: ["task", "run", "cancel"],
+    group: "Task",
+    summary: "Cancel an existing runner run and stop the supervised process when present.",
+    description: "Loads an existing runner run from its artifacts, sends a termination signal to a live supervised process when one is recorded, and persists the resulting cancelled state for later resume or retry decisions.",
+    args: [
+        { name: "task-id", required: true, valueHint: "<task-id>" },
+        { name: "run-id", required: true, valueHint: "<run-id>" },
+    ],
+    examples: [
+        {
+            cmd: "agentplane task run cancel 202602030608-F1Q8AB run_20260323_abc123",
+            why: "Cancel a prepared run or send a termination signal to a live supervised run.",
+        },
+    ],
+    parse: (raw) => ({
+        taskId: String(raw.args["task-id"]),
+        runId: String(raw.args["run-id"]),
+    }),
+};

package/dist/commands/task/run-resume.command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandHandler } from "../../cli/spec/spec.js";
+import type { TaskRunResumeParsed } from "./run-resume.spec.js";
+export { taskRunResumeSpec } from "./run-resume.spec.js";
+export type { TaskRunResumeParsed } from "./run-resume.spec.js";
+export declare const runTaskRunResume: CommandHandler<TaskRunResumeParsed>;
+//# sourceMappingURL=run-resume.command.d.ts.map

package/dist/commands/task/run-resume.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-resume.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-resume.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAUzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAIhE,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,mBAAmB,CA+ChE,CAAC"}

package/dist/commands/task/run-resume.command.js

@@ -0,0 +1,55 @@
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { mapBackendError } from "../../cli/error-map.js";
+import { createCliEmitter, infoMessage } from "../../cli/output.js";
+import { loadCommandContext } from "../shared/task-backend.js";
+import { CliError } from "../../shared/errors.js";
+import { resumeTaskRunnerExecution } from "../../runner/usecases/task-run-lifecycle.js";
+export { taskRunResumeSpec } from "./run-resume.spec.js";
+const emitter = createCliEmitter();
+export const runTaskRunResume = async (ctx, parsed) => {
+    try {
+        const commandCtx = await loadCommandContext({
+            cwd: ctx.cwd,
+            rootOverride: ctx.rootOverride ?? null,
+        });
+        const resumed = await resumeTaskRunnerExecution({
+            ctx: commandCtx,
+            cwd: ctx.cwd,
+            rootOverride: ctx.rootOverride ?? null,
+            task_id: parsed.taskId,
+            run_id: parsed.runId,
+        });
+        const entries = [
+            { label: "run_id", value: parsed.runId },
+            { label: "previous_status", value: resumed.previous_status },
+            { label: "adapter", value: resumed.invocation.adapter_id },
+            { label: "state", value: resumed.invocation.state_path },
+            { label: "events", value: resumed.invocation.events_path },
+            { label: "status", value: resumed.result.status },
+            { label: "runner_exit_code", value: resumed.result.exit_code ?? "null" },
+        ];
+        if (resumed.result.stdout_summary) {
+            entries.push({ label: "stdout", value: resumed.result.stdout_summary });
+        }
+        emitter.report(entries, {
+            header: infoMessage(`task run resumed: ${parsed.taskId}`),
+        });
+        if (resumed.result.stderr_summary) {
+            emitter.report([{ label: "stderr", value: resumed.result.stderr_summary }], {
+                stream: "stderr",
+            });
+        }
+        return resumed.result.status === "success"
+            ? 0
+            : (resumed.result.exit_code ?? exitCodeForError("E_RUNTIME"));
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapBackendError(err, {
+            command: "task run resume",
+            task_id: parsed.taskId,
+            run_id: parsed.runId,
+        });
+    }
+};

package/dist/commands/task/run-resume.spec.d.ts

@@ -0,0 +1,7 @@
+import type { CommandSpec } from "../../cli/spec/spec.js";
+export type TaskRunResumeParsed = {
+    taskId: string;
+    runId: string;
+};
+export declare const taskRunResumeSpec: CommandSpec<TaskRunResumeParsed>;
+//# sourceMappingURL=run-resume.spec.d.ts.map

package/dist/commands/task/run-resume.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-resume.spec.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-resume.spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,MAAM,MAAM,mBAAmB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,mBAAmB,CAoB9D,CAAC"}

package/dist/commands/task/run-resume.spec.js

@@ -0,0 +1,20 @@
+export const taskRunResumeSpec = {
+    id: ["task", "run", "resume"],
+    group: "Task",
+    summary: "Resume an existing execute-mode runner run in place.",
+    description: "Loads an existing execute-mode runner run from its artifacts and re-executes the configured adapter against the same bundle and run directory.",
+    args: [
+        { name: "task-id", required: true, valueHint: "<task-id>" },
+        { name: "run-id", required: true, valueHint: "<run-id>" },
+    ],
+    examples: [
+        {
+            cmd: "agentplane task run resume 202602030608-F1Q8AB run_20260323_abc123",
+            why: "Resume or re-execute a prepared/failed/cancelled run in place.",
+        },
+    ],
+    parse: (raw) => ({
+        taskId: String(raw.args["task-id"]),
+        runId: String(raw.args["run-id"]),
+    }),
+};

package/dist/commands/task/run-retry.command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandHandler } from "../../cli/spec/spec.js";
+import type { TaskRunRetryParsed } from "./run-retry.spec.js";
+export { taskRunRetrySpec } from "./run-retry.spec.js";
+export type { TaskRunRetryParsed } from "./run-retry.spec.js";
+export declare const runTaskRunRetry: CommandHandler<TaskRunRetryParsed>;
+//# sourceMappingURL=run-retry.command.d.ts.map

package/dist/commands/task/run-retry.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-retry.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-retry.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAUzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAI9D,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,kBAAkB,CAgD9D,CAAC"}

package/dist/commands/task/run-retry.command.js

@@ -0,0 +1,56 @@
+import { exitCodeForError } from "../../cli/exit-codes.js";
+import { mapBackendError } from "../../cli/error-map.js";
+import { createCliEmitter, infoMessage } from "../../cli/output.js";
+import { loadCommandContext } from "../shared/task-backend.js";
+import { CliError } from "../../shared/errors.js";
+import { retryTaskRunnerExecution } from "../../runner/usecases/task-run-lifecycle.js";
+export { taskRunRetrySpec } from "./run-retry.spec.js";
+const emitter = createCliEmitter();
+export const runTaskRunRetry = async (ctx, parsed) => {
+    try {
+        const commandCtx = await loadCommandContext({
+            cwd: ctx.cwd,
+            rootOverride: ctx.rootOverride ?? null,
+        });
+        const retried = await retryTaskRunnerExecution({
+            ctx: commandCtx,
+            cwd: ctx.cwd,
+            rootOverride: ctx.rootOverride ?? null,
+            task_id: parsed.taskId,
+            run_id: parsed.runId,
+        });
+        const entries = [
+            { label: "source_run_id", value: retried.source_run_id },
+            { label: "previous_status", value: retried.source_status },
+            { label: "run_id", value: retried.invocation.run_id },
+            { label: "adapter", value: retried.invocation.adapter_id },
+            { label: "state", value: retried.invocation.state_path },
+            { label: "events", value: retried.invocation.events_path },
+            { label: "status", value: retried.result.status },
+            { label: "runner_exit_code", value: retried.result.exit_code ?? "null" },
+        ];
+        if (retried.result.stdout_summary) {
+            entries.push({ label: "stdout", value: retried.result.stdout_summary });
+        }
+        emitter.report(entries, {
+            header: infoMessage(`task run retried: ${parsed.taskId}`),
+        });
+        if (retried.result.stderr_summary) {
+            emitter.report([{ label: "stderr", value: retried.result.stderr_summary }], {
+                stream: "stderr",
+            });
+        }
+        return retried.result.status === "success"
+            ? 0
+            : (retried.result.exit_code ?? exitCodeForError("E_RUNTIME"));
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapBackendError(err, {
+            command: "task run retry",
+            task_id: parsed.taskId,
+            run_id: parsed.runId,
+        });
+    }
+};

package/dist/commands/task/run-retry.spec.d.ts

@@ -0,0 +1,7 @@
+import type { CommandSpec } from "../../cli/spec/spec.js";
+export type TaskRunRetryParsed = {
+    taskId: string;
+    runId: string;
+};
+export declare const taskRunRetrySpec: CommandSpec<TaskRunRetryParsed>;
+//# sourceMappingURL=run-retry.spec.d.ts.map

package/dist/commands/task/run-retry.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-retry.spec.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-retry.spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,kBAAkB,CAoB5D,CAAC"}

package/dist/commands/task/run-retry.spec.js

@@ -0,0 +1,20 @@
+export const taskRunRetrySpec = {
+    id: ["task", "run", "retry"],
+    group: "Task",
+    summary: "Retry an existing execute-mode runner run into a new run id.",
+    description: "Loads an existing runner run, snapshots its bundle into a new run id, and executes the configured adapter against the new run directory while retaining the source run for traceability.",
+    args: [
+        { name: "task-id", required: true, valueHint: "<task-id>" },
+        { name: "run-id", required: true, valueHint: "<run-id>" },
+    ],
+    examples: [
+        {
+            cmd: "agentplane task run retry 202602030608-F1Q8AB run_20260323_abc123",
+            why: "Create a new run from a failed/cancelled run snapshot and execute it.",
+        },
+    ],
+    parse: (raw) => ({
+        taskId: String(raw.args["task-id"]),
+        runId: String(raw.args["run-id"]),
+    }),
+};

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

@@ -0,0 +1,6 @@
+import type { CommandHandler } from "../../cli/spec/spec.js";
+import type { TaskRunShowParsed } from "./run-show.spec.js";
+export { taskRunShowSpec } from "./run-show.spec.js";
+export type { TaskRunShowParsed } from "./run-show.spec.js";
+export declare const runTaskRunShow: CommandHandler<TaskRunShowParsed>;
+//# sourceMappingURL=run-show.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-show.command.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-show.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAYzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAqE5D,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,iBAAiB,CA6F5D,CAAC"}

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

@@ -0,0 +1,133 @@
+import { mapBackendError } from "../../cli/error-map.js";
+import { createCliEmitter, infoMessage } from "../../cli/output.js";
+import { CliError } from "../../shared/errors.js";
+import { formatRunnerCapabilitySummaryLines, formatRunnerPolicyFieldSummaryLines, } from "../../runner/policy-display.js";
+import { loadTaskRunnerInspection } from "../../runner/usecases/task-run-inspect.js";
+export { taskRunShowSpec } from "./run-show.spec.js";
+const emitter = createCliEmitter();
+function formatTarget(target) {
+    if (target.kind === "task")
+        return `task ${target.task_id ?? "<unknown>"}`;
+    return (`recipe ${target.recipe_id ?? "<unknown>"}:${target.scenario_id ?? "<unknown>"}` +
+        (target.task_id ? ` -> task ${target.task_id}` : ""));
+}
+function formatArtifacts(artifacts) {
+    if (!artifacts?.length)
+        return null;
+    return artifacts
+        .map((artifact) => (artifact.label ? `${artifact.label}=${artifact.path}` : artifact.path))
+        .join(", ");
+}
+function formatMetrics(metrics) {
+    if (!metrics)
+        return null;
+    const parts = [];
+    if (typeof metrics.duration_ms === "number")
+        parts.push(`duration_ms=${metrics.duration_ms}`);
+    if (typeof metrics.stdout_bytes === "number")
+        parts.push(`stdout_bytes=${metrics.stdout_bytes}`);
+    if (typeof metrics.stderr_bytes === "number")
+        parts.push(`stderr_bytes=${metrics.stderr_bytes}`);
+    if (metrics.output_last_message_bytes === null ||
+        typeof metrics.output_last_message_bytes === "number") {
+        parts.push(`output_last_message_bytes=${metrics.output_last_message_bytes ?? "null"}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : null;
+}
+function buildRunShowJson(inspection) {
+    return {
+        task_id: inspection.task_id,
+        run_id: inspection.run_id,
+        selection: inspection.selection,
+        paths: inspection.paths,
+        bundle: inspection.bundle,
+        state: inspection.state,
+        events: inspection.events,
+        events_count: inspection.events.length,
+        last_event: inspection.events.at(-1) ?? null,
+    };
+}
+export const runTaskRunShow = async (ctx, parsed) => {
+    try {
+        const inspection = await loadTaskRunnerInspection({
+            cwd: ctx.cwd,
+            rootOverride: ctx.rootOverride ?? null,
+            task_id: parsed.taskId,
+            run_id: parsed.runId,
+        });
+        if (parsed.json) {
+            emitter.json(buildRunShowJson(inspection));
+            return 0;
+        }
+        const entries = [
+            { label: "selection", value: inspection.selection },
+            { label: "run_id", value: inspection.run_id },
+            { label: "status", value: inspection.state.status },
+            { label: "adapter", value: inspection.state.adapter_id },
+            { label: "mode", value: inspection.state.mode },
+            { label: "target", value: formatTarget(inspection.state.target) },
+            { label: "created_at", value: inspection.state.created_at },
+            { label: "updated_at", value: inspection.state.updated_at },
+            { label: "bundle", value: inspection.paths.bundle_path },
+            { label: "result", value: inspection.paths.result_path },
+            { label: "state", value: inspection.paths.state_path },
+            { label: "events", value: inspection.paths.events_path },
+            { label: "trace", value: inspection.paths.trace_path },
+            { label: "stderr", value: inspection.paths.stderr_path },
+            { label: "events_count", value: inspection.events.length },
+        ];
+        if (inspection.events.length > 0) {
+            const lastEvent = inspection.events.at(-1);
+            entries.push({ label: "last_event", value: lastEvent?.type ?? "unknown" });
+        }
+        const capabilities = inspection.bundle.execution.adapter_capabilities ??
+            inspection.state.prepared_metadata?.adapter_capabilities ??
+            null;
+        entries.push({ label: "capabilities", value: JSON.stringify(capabilities) }, ...formatRunnerCapabilitySummaryLines(capabilities ?? undefined), {
+            label: "policy_requested",
+            value: JSON.stringify(inspection.state.policy_decision?.requested ?? {}),
+        }, {
+            label: "policy_effective",
+            value: JSON.stringify(inspection.state.policy_decision?.effective ?? {}),
+        }, {
+            label: "policy_fields",
+            value: JSON.stringify(inspection.state.policy_decision?.fields ?? {}),
+        }, {
+            label: "policy_refusal",
+            value: JSON.stringify(inspection.state.policy_decision?.refusal_reason ?? null),
+        }, ...formatRunnerPolicyFieldSummaryLines(inspection.state.policy_decision));
+        if (inspection.state.result?.summary) {
+            entries.push({ label: "summary", value: inspection.state.result.summary });
+        }
+        if (inspection.state.result?.stdout_summary) {
+            entries.push({ label: "stdout_summary", value: inspection.state.result.stdout_summary });
+        }
+        if (inspection.state.result?.stderr_summary) {
+            entries.push({ label: "stderr_summary", value: inspection.state.result.stderr_summary });
+        }
+        if (inspection.state.result?.timeout_reason) {
+            entries.push({ label: "timeout_reason", value: inspection.state.result.timeout_reason });
+        }
+        const metrics = formatMetrics(inspection.state.result?.metrics);
+        if (metrics) {
+            entries.push({ label: "metrics", value: metrics });
+        }
+        const artifacts = formatArtifacts(inspection.state.result?.artifacts);
+        if (artifacts) {
+            entries.push({ label: "artifacts", value: artifacts });
+        }
+        emitter.report(entries, {
+            header: infoMessage(`task run show: ${parsed.taskId}`),
+        });
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapBackendError(err, {
+            command: "task run show",
+            task_id: parsed.taskId,
+            run_id: parsed.runId ?? null,
+        });
+    }
+};

package/dist/commands/task/run-show.spec.d.ts

@@ -0,0 +1,8 @@
+import type { CommandSpec } from "../../cli/spec/spec.js";
+export type TaskRunShowParsed = {
+    taskId: string;
+    runId?: string;
+    json: boolean;
+};
+export declare const taskRunShowSpec: CommandSpec<TaskRunShowParsed>;
+//# sourceMappingURL=run-show.spec.d.ts.map

package/dist/commands/task/run-show.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-show.spec.d.ts","sourceRoot":"","sources":["../../../src/commands/task/run-show.spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG1D,MAAM,MAAM,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAElF,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,iBAAiB,CA2C1D,CAAC"}