agentplane 0.3.7 → 0.3.8

package/dist/runner/usecases/scenario-materialize-task.js

@@ -0,0 +1,151 @@
+import path from "node:path";
+import { setMarkdownSection } from "@agentplaneorg/core";
+import { loadCommandContext } from "../../commands/shared/task-backend.js";
+import { TASK_DOC_VERSION_V3, buildDefaultVerifyStepsSection, defaultTaskDocV3, } from "../../commands/task/doc-template.js";
+import { buildTaskDocState } from "../../shared/task-doc-state.js";
+import { dedupeStrings } from "../../shared/strings.js";
+import { createRunnerRunId } from "../run-id.js";
+import { assembleRunnerRecipeContext, } from "../context/recipe-context.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+function seedRecipeTaskSummary(opts) {
+    const seeded = opts.scenario.task_template.doc?.summary?.trim();
+    if (seeded)
+        return seeded;
+    return [
+        opts.scenario.task_template.title,
+        "",
+        opts.scenario.task_template.description,
+        "",
+        `Recipe: ${opts.selection.recipe_id}:${opts.selection.scenario_id}@${opts.selection.recipe_version}`,
+        `Goal: ${opts.scenario.goal}`,
+    ].join("\n");
+}
+function seedRecipeTaskScope(opts) {
+    const seeded = opts.scenario.task_template.doc?.scope?.trim();
+    if (seeded)
+        return seeded;
+    const requiredInputs = opts.selection.required_inputs;
+    const outputs = opts.selection.outputs;
+    return [
+        `- In scope: execute recipe scenario "${opts.selection.recipe_id}:${opts.selection.scenario_id}" to achieve "${opts.scenario.goal}".`,
+        `- Required inputs: ${requiredInputs.length > 0 ? requiredInputs.join(", ") : "none declared"}.`,
+        `- Expected outputs: ${outputs.length > 0 ? outputs.join(", ") : "none declared"}.`,
+        "- Out of scope: work outside the scenario's declared goal, outputs, and artifacts.",
+    ].join("\n");
+}
+function seedRecipeTaskPlan(opts) {
+    const seeded = opts.scenario.task_template.doc?.plan?.trim();
+    if (seeded)
+        return seeded;
+    return [
+        `1. Resolve the inputs and dependencies for "${opts.selection.recipe_id}:${opts.selection.scenario_id}".`,
+        `2. Execute the scenario goal: ${opts.scenario.goal}`,
+        "3. Capture the declared outputs/artifacts and verification evidence in the task record.",
+    ].join("\n");
+}
+function seedRecipeTaskVerifySteps(opts) {
+    const seeded = opts.scenario.task_template.doc?.verify_steps?.trim();
+    if (seeded)
+        return seeded;
+    const primary = opts.scenario.task_template.tags?.[0] ?? "recipes";
+    return buildDefaultVerifyStepsSection({
+        primary,
+        verifyCommands: dedupeStrings(opts.scenario.task_template.verify ?? []),
+    });
+}
+function seedRecipeTaskRollbackPlan(opts) {
+    const seeded = opts.scenario.task_template.doc?.rollback_plan?.trim();
+    if (seeded)
+        return seeded;
+    return [
+        `- Revert the task created from recipe scenario "${opts.selection.recipe_id}:${opts.selection.scenario_id}".`,
+        "- Remove any runner artifacts produced by the scenario run if they are no longer needed.",
+        "- Re-run the relevant validation step to confirm the rollback restored the previous state.",
+    ].join("\n");
+}
+function seedRecipeTaskDoc(opts) {
+    let body = defaultTaskDocV3({
+        title: opts.scenario.task_template.title,
+        description: opts.scenario.task_template.description,
+    });
+    body = setMarkdownSection(body, "Summary", seedRecipeTaskSummary(opts));
+    body = setMarkdownSection(body, "Scope", seedRecipeTaskScope(opts));
+    body = setMarkdownSection(body, "Plan", seedRecipeTaskPlan(opts));
+    body = setMarkdownSection(body, "Verify Steps", seedRecipeTaskVerifySteps(opts));
+    body = setMarkdownSection(body, "Rollback Plan", seedRecipeTaskRollbackPlan(opts));
+    body = setMarkdownSection(body, "Findings", opts.scenario.task_template.doc?.findings?.trim() ?? "");
+    return body;
+}
+export function buildMaterializedRecipeTask(opts) {
+    const created_at = opts.created_at ?? nowIso();
+    const taskTemplate = opts.envelope.scenario.task_template;
+    const docState = buildTaskDocState({
+        doc: seedRecipeTaskDoc(opts.envelope),
+        owner: taskTemplate.owner,
+        updatedBy: taskTemplate.owner,
+        version: TASK_DOC_VERSION_V3,
+        updatedAt: created_at,
+    });
+    return {
+        id: opts.task_id,
+        title: taskTemplate.title,
+        description: taskTemplate.description,
+        status: "TODO",
+        priority: taskTemplate.priority ?? "med",
+        owner: taskTemplate.owner,
+        revision: 1,
+        origin: {
+            system: "recipe",
+            recipe_id: opts.envelope.selection.recipe_id,
+            scenario_id: opts.envelope.selection.scenario_id,
+            recipe_version: opts.envelope.selection.recipe_version,
+            run_id: opts.run_id,
+        },
+        depends_on: [],
+        tags: dedupeStrings(taskTemplate.tags ?? ["recipes"]),
+        verify: dedupeStrings(taskTemplate.verify ?? []),
+        comments: [],
+        events: [],
+        doc_version: docState.doc_version,
+        doc_updated_at: docState.doc_updated_at,
+        doc_updated_by: docState.doc_updated_by,
+        id_source: "generated",
+        doc: docState.doc,
+        sections: docState.sections,
+    };
+}
+export async function materializeRecipeScenarioTask(opts) {
+    const ctx = opts.ctx ??
+        (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
+    if (!ctx.taskBackend.generateTaskId) {
+        throw new Error("Backend does not support task materialization: missing generateTaskId()");
+    }
+    const envelope = await assembleRunnerRecipeContext({
+        project: ctx.resolvedProject,
+        recipe_id: opts.recipe_id,
+        scenario_id: opts.scenario_id,
+    });
+    const task_id = await ctx.taskBackend.generateTaskId({
+        length: ctx.config.tasks.id_suffix_length_default,
+        attempts: 1000,
+    });
+    const run_id = opts.run_id ?? createRunnerRunId();
+    const task = buildMaterializedRecipeTask({
+        envelope,
+        task_id,
+        run_id,
+    });
+    await ctx.taskBackend.writeTask(task);
+    return {
+        task,
+        task_id,
+        run_id,
+        readme_path: path.join(ctx.resolvedProject.gitRoot, ctx.config.paths.workflow_dir, task_id, "README.md"),
+        recipe_context: envelope.recipe,
+        selection: envelope.selection,
+        scenario: envelope.scenario,
+        entry: envelope.entry,
+    };
+}

package/dist/runner/usecases/task-run-inspect.d.ts

@@ -0,0 +1,41 @@
+import { type CommandContext } from "../../commands/shared/task-backend.js";
+import { type TaskRunnerPaths } from "../task-run-paths.js";
+import type { RunnerContextBundle, RunnerEvent, RunnerRunState } from "../types.js";
+export type LoadedTaskRunnerInspection = {
+    ctx: CommandContext;
+    task_id: string;
+    run_id: string;
+    selection: "explicit" | "latest";
+    paths: TaskRunnerPaths;
+    bundle: RunnerContextBundle;
+    state: RunnerRunState;
+    events: RunnerEvent[];
+    events_text: string;
+};
+export declare function loadTaskRunnerInspection(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+    run_id?: string;
+}): Promise<LoadedTaskRunnerInspection>;
+export declare function readTaskRunnerTraceArtifact(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+    run_id?: string;
+}): Promise<LoadedTaskRunnerInspection & {
+    trace_text: string;
+}>;
+export declare function readTaskRunnerTraceTail(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+    run_id?: string;
+    lines: number;
+}): Promise<LoadedTaskRunnerInspection & {
+    tail_text: string;
+}>;
+//# sourceMappingURL=task-run-inspect.d.ts.map

package/dist/runner/usecases/task-run-inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-run-inspect.d.ts","sourceRoot":"","sources":["../../../src/runner/usecases/task-run-inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAGhG,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAEpF,MAAM,MAAM,0BAA0B,GAAG;IACvC,GAAG,EAAE,cAAc,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,UAAU,GAAG,QAAQ,CAAC;IACjC,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAkDtC;AAED,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,0BAA0B,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAU/D;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,0BAA0B,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAW9D"}

package/dist/runner/usecases/task-run-inspect.js

@@ -0,0 +1,74 @@
+import { loadCommandContext } from "../../commands/shared/task-backend.js";
+import { CliError } from "../../shared/errors.js";
+import { resolveLatestRunnerRunId, RunnerRunRepository } from "../run-repository.js";
+import { resolveTaskRunnerPaths } from "../task-run-paths.js";
+export async function loadTaskRunnerInspection(opts) {
+    const ctx = opts.ctx ??
+        (await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null }));
+    const task = await ctx.taskBackend.getTask(opts.task_id);
+    if (!task) {
+        throw new CliError({
+            exitCode: 4,
+            code: "E_IO",
+            message: `Task not found: ${opts.task_id}`,
+        });
+    }
+    const runId = typeof opts.run_id === "string" && opts.run_id.trim().length > 0
+        ? opts.run_id
+        : await resolveLatestRunnerRunId({
+            git_root: ctx.resolvedProject.gitRoot,
+            workflow_dir: ctx.config.paths.workflow_dir,
+            task_id: opts.task_id,
+        });
+    const paths = resolveTaskRunnerPaths({
+        git_root: ctx.resolvedProject.gitRoot,
+        workflow_dir: ctx.config.paths.workflow_dir,
+        task_id: opts.task_id,
+        run_id: runId,
+    });
+    const repository = new RunnerRunRepository(paths);
+    const [record, eventsData] = await Promise.all([
+        repository.readRequiredRecord({
+            task_id: opts.task_id,
+            run_id: runId,
+        }),
+        repository.readEventsRequired({
+            task_id: opts.task_id,
+            run_id: runId,
+        }),
+    ]);
+    return {
+        ctx,
+        task_id: opts.task_id,
+        run_id: runId,
+        selection: opts.run_id ? "explicit" : "latest",
+        paths,
+        bundle: record.bundle,
+        state: record.state,
+        events: eventsData.events,
+        events_text: eventsData.events_text,
+    };
+}
+export async function readTaskRunnerTraceArtifact(opts) {
+    const inspection = await loadTaskRunnerInspection(opts);
+    const trace_text = await new RunnerRunRepository(inspection.paths).readTraceTextRequired({
+        task_id: inspection.task_id,
+        run_id: inspection.run_id,
+    });
+    return {
+        ...inspection,
+        trace_text,
+    };
+}
+export async function readTaskRunnerTraceTail(opts) {
+    const traced = await readTaskRunnerTraceArtifact(opts);
+    const lines = traced.trace_text.split(/\r?\n/u);
+    if (lines.at(-1) === "") {
+        lines.pop();
+    }
+    const tail = lines.slice(-opts.lines);
+    return {
+        ...traced,
+        tail_text: tail.length > 0 ? `${tail.join("\n")}\n` : "",
+    };
+}

package/dist/runner/usecases/task-run-lifecycle-cancel.d.ts

@@ -0,0 +1,10 @@
+import type { CommandContext } from "../../commands/shared/task-backend.js";
+import { type CancelledTaskRunnerExecution } from "./task-run-lifecycle-shared.js";
+export declare function cancelTaskRunnerExecution(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+    run_id: string;
+}): Promise<CancelledTaskRunnerExecution>;
+//# sourceMappingURL=task-run-lifecycle-cancel.d.ts.map

package/dist/runner/usecases/task-run-lifecycle-cancel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-run-lifecycle-cancel.d.ts","sourceRoot":"","sources":["../../../src/runner/usecases/task-run-lifecycle-cancel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAW5E,OAAO,EAML,KAAK,4BAA4B,EAClC,MAAM,gCAAgC,CAAC;AAExC,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAsKxC"}

package/dist/runner/usecases/task-run-lifecycle-cancel.js

@@ -0,0 +1,172 @@
+import { CliError } from "../../shared/errors.js";
+import { evolveRunnerRunState } from "../artifacts.js";
+import { isProcessAlive, waitForProcessExit, waitForRunnerStateStop, } from "../process-supervision.js";
+import { persistRunnerOutcomeToTask } from "../task-state.js";
+import { assertMatchingProcessIdentity, buildSyntheticCancelledState, loadExistingRunnerExecution, readRunningPid, signalProcess, } from "./task-run-lifecycle-shared.js";
+export async function cancelTaskRunnerExecution(opts) {
+    const loaded = await loadExistingRunnerExecution({
+        ctx: opts.ctx,
+        cwd: opts.cwd,
+        rootOverride: opts.rootOverride ?? null,
+        task_id: opts.task_id,
+        run_id: opts.run_id,
+        require_task_doing: false,
+    });
+    if (loaded.state.status === "success") {
+        throw new CliError({
+            exitCode: 2,
+            code: "E_USAGE",
+            message: `runner cancel requires a non-success run (current=${JSON.stringify(loaded.state.status)})`,
+        });
+    }
+    if (loaded.state.status === "cancelled") {
+        return { ...loaded, previous_status: loaded.state.status, changed: false };
+    }
+    if (loaded.state.status === "running") {
+        const pid = readRunningPid(loaded.state);
+        if (!pid) {
+            throw new CliError({
+                exitCode: 4,
+                code: "E_IO",
+                message: `runner cancel requires supervision metadata for running run ${opts.task_id}:${opts.run_id}`,
+            });
+        }
+        try {
+            await assertMatchingProcessIdentity({
+                task_id: opts.task_id,
+                run_id: opts.run_id,
+                state: loaded.state,
+                pid,
+            });
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                const refusedAt = new Date().toISOString();
+                await loaded.repository.appendEvent({
+                    at: refusedAt,
+                    type: "runner_cancel_refused",
+                    message: err.message,
+                    data: err.context ?? {
+                        task_id: opts.task_id,
+                        run_id: opts.run_id,
+                        pid,
+                    },
+                });
+            }
+            throw err;
+        }
+        const requested_at = new Date().toISOString();
+        const requestedState = evolveRunnerRunState({
+            state: loaded.state,
+            status: "running",
+            updated_at: requested_at,
+            supervision: {
+                ...loaded.state.supervision,
+                cancel_requested_at: requested_at,
+                cancel_signal: "SIGTERM",
+                heartbeat_at: requested_at,
+            },
+        });
+        await loaded.repository.writeState(requestedState);
+        await loaded.repository.appendEvent({
+            at: requested_at,
+            type: "runner_cancel_requested",
+            message: `runner cancel requested via SIGTERM for pid=${pid}`,
+            data: {
+                previous_status: loaded.state.status,
+                pid,
+                signal: "SIGTERM",
+            },
+        });
+        const exitedAfterTerm = signalProcess(pid, "SIGTERM")
+            ? await waitForProcessExit({ pid, timeout_ms: 1500 })
+            : true;
+        let finalSignal = "SIGTERM";
+        if (!exitedAfterTerm && isProcessAlive(pid)) {
+            const killRequestedAt = new Date().toISOString();
+            const killRequestedState = evolveRunnerRunState({
+                state: requestedState,
+                status: "running",
+                updated_at: killRequestedAt,
+                supervision: {
+                    ...requestedState.supervision,
+                    cancel_requested_at: requested_at,
+                    cancel_signal: "SIGKILL",
+                    force_killed: true,
+                    heartbeat_at: killRequestedAt,
+                },
+            });
+            await loaded.repository.writeState(killRequestedState);
+            await loaded.repository.appendEvent({
+                at: killRequestedAt,
+                type: "runner_force_kill_requested",
+                message: `runner cancel escalated to SIGKILL for pid=${pid}`,
+                data: {
+                    previous_status: loaded.state.status,
+                    pid,
+                    signal: "SIGKILL",
+                },
+            });
+            signalProcess(pid, "SIGKILL");
+            await waitForProcessExit({ pid, timeout_ms: 1500 });
+            finalSignal = "SIGKILL";
+        }
+        const settledState = await waitForRunnerStateStop({
+            state_path: loaded.invocation.state_path,
+            timeout_ms: 3000,
+        });
+        const nextState = settledState ??
+            buildSyntheticCancelledState({
+                state: (await loaded.repository.readState()) ?? requestedState,
+                signal: finalSignal,
+                updated_at: new Date().toISOString(),
+            });
+        if (!settledState) {
+            await loaded.repository.writeState(nextState);
+            await loaded.repository.appendEvent({
+                at: nextState.updated_at,
+                type: "runner_cancelled",
+                message: `runner process exited after ${finalSignal}; state synthesized as cancelled`,
+                data: {
+                    previous_status: loaded.state.status,
+                    pid,
+                    signal: finalSignal,
+                },
+            });
+        }
+        await persistRunnerOutcomeToTask({
+            ctx: loaded.ctx,
+            task_id: opts.task_id,
+            bundle: loaded.bundle,
+            state: nextState,
+        });
+        return {
+            ...loaded,
+            state: nextState,
+            previous_status: loaded.state.status,
+            changed: nextState.status === "cancelled",
+        };
+    }
+    const updated_at = new Date().toISOString();
+    const nextState = evolveRunnerRunState({
+        state: loaded.state,
+        status: "cancelled",
+        updated_at,
+    });
+    await loaded.repository.writeState(nextState);
+    await loaded.repository.appendEvent({
+        at: updated_at,
+        type: "runner_cancelled",
+        message: `runner marked cancelled from status=${loaded.state.status}`,
+        data: {
+            previous_status: loaded.state.status,
+        },
+    });
+    await persistRunnerOutcomeToTask({
+        ctx: loaded.ctx,
+        task_id: opts.task_id,
+        bundle: loaded.bundle,
+        state: nextState,
+    });
+    return { ...loaded, state: nextState, previous_status: loaded.state.status, changed: true };
+}

package/dist/runner/usecases/task-run-lifecycle-replay.d.ts

@@ -0,0 +1,18 @@
+import type { CommandContext } from "../../commands/shared/task-backend.js";
+import { type ResumedTaskRunnerExecution, type RetriedTaskRunnerExecution } from "./task-run-lifecycle-shared.js";
+export declare function resumeTaskRunnerExecution(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+    run_id: string;
+}): Promise<ResumedTaskRunnerExecution>;
+export declare function retryTaskRunnerExecution(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+    run_id: string;
+    new_run_id?: string;
+}): Promise<RetriedTaskRunnerExecution>;
+//# sourceMappingURL=task-run-lifecycle-replay.d.ts.map

package/dist/runner/usecases/task-run-lifecycle-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-run-lifecycle-replay.d.ts","sourceRoot":"","sources":["../../../src/runner/usecases/task-run-lifecycle-replay.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAG5E,OAAO,EAGL,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAChC,MAAM,gCAAgC,CAAC;AAGxC,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,0BAA0B,CAAC,CA4CtC;AAED,wBAAsB,wBAAwB,CAAC,IAAI,EAAE;IACnD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,0BAA0B,CAAC,CA8EtC"}

package/dist/runner/usecases/task-run-lifecycle-replay.js

@@ -0,0 +1,128 @@
+import { createRunnerAdapter } from "../adapters/index.js";
+import { evolveRunnerRunState } from "../artifacts.js";
+import { createRunnerRunId } from "../run-id.js";
+import { RunnerRunRepository } from "../run-repository.js";
+import { persistRunnerOutcomeToTask } from "../task-state.js";
+import { resolveTaskRunnerPaths } from "../task-run-paths.js";
+import { renderTaskRunnerBootstrap } from "./task-run.js";
+import { assertExecuteMode, loadExistingRunnerExecution, } from "./task-run-lifecycle-shared.js";
+import { CliError } from "../../shared/errors.js";
+export async function resumeTaskRunnerExecution(opts) {
+    const loaded = await loadExistingRunnerExecution({
+        ctx: opts.ctx,
+        cwd: opts.cwd,
+        rootOverride: opts.rootOverride ?? null,
+        task_id: opts.task_id,
+        run_id: opts.run_id,
+    });
+    assertExecuteMode(loaded.bundle, "resume");
+    if (loaded.state.status === "running" || loaded.state.status === "success") {
+        throw new CliError({
+            exitCode: 2,
+            code: "E_USAGE",
+            message: `runner resume requires a prepared, failed, or cancelled run ` +
+                `(current=${JSON.stringify(loaded.state.status)})`,
+        });
+    }
+    const requested_at = new Date().toISOString();
+    const resetState = evolveRunnerRunState({
+        state: loaded.state,
+        status: "prepared",
+        updated_at: requested_at,
+    });
+    await loaded.repository.writeState(resetState);
+    await loaded.repository.appendEvent({
+        at: requested_at,
+        type: "runner_resume_requested",
+        message: `runner resume requested from status=${loaded.state.status}`,
+        data: {
+            previous_status: loaded.state.status,
+        },
+    });
+    const result = await createRunnerAdapter(loaded.ctx.config).execute(loaded.invocation);
+    const nextState = (await loaded.repository.readState()) ?? resetState;
+    await persistRunnerOutcomeToTask({
+        ctx: loaded.ctx,
+        task_id: opts.task_id,
+        bundle: loaded.bundle,
+        state: nextState,
+    });
+    return { ...loaded, state: nextState, previous_status: loaded.state.status, result };
+}
+export async function retryTaskRunnerExecution(opts) {
+    const source = await loadExistingRunnerExecution({
+        ctx: opts.ctx,
+        cwd: opts.cwd,
+        rootOverride: opts.rootOverride ?? null,
+        task_id: opts.task_id,
+        run_id: opts.run_id,
+    });
+    assertExecuteMode(source.bundle, "retry");
+    if (source.state.status === "prepared" || source.state.status === "running") {
+        throw new CliError({
+            exitCode: 2,
+            code: "E_USAGE",
+            message: `runner retry requires a failed or cancelled run ` +
+                `(current=${JSON.stringify(source.state.status)}; use \`agentplane task run resume ${opts.task_id} ${opts.run_id}\` instead).`,
+        });
+    }
+    const nextRunId = opts.new_run_id ?? createRunnerRunId();
+    const paths = resolveTaskRunnerPaths({
+        git_root: source.ctx.resolvedProject.gitRoot,
+        workflow_dir: source.ctx.config.paths.workflow_dir,
+        task_id: opts.task_id,
+        run_id: nextRunId,
+    });
+    const retriedBundle = {
+        ...source.bundle,
+        execution: {
+            ...source.bundle.execution,
+            mode: "execute",
+            run_id: nextRunId,
+            artifact_paths: paths,
+        },
+    };
+    const adapter = createRunnerAdapter(source.ctx.config);
+    const invocation = await adapter.prepare(retriedBundle);
+    const retryRepository = RunnerRunRepository.fromBundle(retriedBundle);
+    const state = await retryRepository.writePrepared({
+        bundle: retriedBundle,
+        bootstrap_markdown: renderTaskRunnerBootstrap(retriedBundle, invocation),
+        invocation,
+    });
+    const requested_at = new Date().toISOString();
+    await source.repository.appendEvent({
+        at: requested_at,
+        type: "runner_retry_requested",
+        message: `runner retry requested into run_id=${nextRunId}`,
+        data: {
+            next_run_id: nextRunId,
+        },
+    });
+    await retryRepository.appendEvent({
+        at: requested_at,
+        type: "runner_retry_created",
+        message: `runner retry created from run_id=${source.state.run_id}`,
+        data: {
+            source_run_id: source.state.run_id,
+            source_status: source.state.status,
+        },
+    });
+    const result = await adapter.execute(invocation);
+    const nextState = (await retryRepository.readState()) ?? state;
+    await persistRunnerOutcomeToTask({
+        ctx: source.ctx,
+        task_id: opts.task_id,
+        bundle: retriedBundle,
+        state: nextState,
+    });
+    return {
+        ctx: source.ctx,
+        bundle: retriedBundle,
+        invocation,
+        state: nextState,
+        result,
+        source_run_id: source.state.run_id,
+        source_status: source.state.status,
+    };
+}

package/dist/runner/usecases/task-run-lifecycle-shared.d.ts

@@ -0,0 +1,45 @@
+import { type CommandContext } from "../../commands/shared/task-backend.js";
+import { RunnerRunRepository } from "../run-repository.js";
+import type { RunnerContextBundle, RunnerLifecycleStatus, RunnerProcessSignal, RunnerResult, RunnerRunState } from "../types.js";
+import { type ExecutedTaskRunnerExecution, type PreparedTaskRunnerExecution } from "./task-run.js";
+export type LoadedRunnerExecution = PreparedTaskRunnerExecution & {
+    ctx: CommandContext;
+    state: RunnerRunState;
+    repository: RunnerRunRepository;
+};
+export type CancelledTaskRunnerExecution = LoadedRunnerExecution & {
+    previous_status: RunnerLifecycleStatus;
+    changed: boolean;
+};
+export type ResumedTaskRunnerExecution = LoadedRunnerExecution & {
+    previous_status: RunnerLifecycleStatus;
+    result: RunnerResult;
+};
+export type RetriedTaskRunnerExecution = ExecutedTaskRunnerExecution & {
+    ctx: CommandContext;
+    source_run_id: string;
+    source_status: RunnerLifecycleStatus;
+};
+export declare function assertExecuteMode(bundle: RunnerContextBundle, action: "resume" | "retry"): void;
+export declare function readRunningPid(state: RunnerRunState): number | null;
+export declare function assertMatchingProcessIdentity(opts: {
+    task_id: string;
+    run_id: string;
+    state: RunnerRunState;
+    pid: number;
+}): Promise<void>;
+export declare function signalProcess(pid: number, signal: RunnerProcessSignal): boolean;
+export declare function buildSyntheticCancelledState(opts: {
+    state: RunnerRunState;
+    signal: RunnerProcessSignal;
+    updated_at: string;
+}): RunnerRunState;
+export declare function loadExistingRunnerExecution(opts: {
+    ctx?: CommandContext;
+    cwd: string;
+    rootOverride?: string | null;
+    task_id: string;
+    run_id: string;
+    require_task_doing?: boolean;
+}): Promise<LoadedRunnerExecution>;
+//# sourceMappingURL=task-run-lifecycle-shared.d.ts.map

package/dist/runner/usecases/task-run-lifecycle-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-run-lifecycle-shared.d.ts","sourceRoot":"","sources":["../../../src/runner/usecases/task-run-lifecycle-shared.ts"],"names":[],"mappings":"AAGA,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAMhG,OAAO,EAAiC,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACf,MAAM,aAAa,CAAC;AAErB,OAAO,EAEL,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EACjC,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,qBAAqB,GAAG,2BAA2B,GAAG;IAChE,GAAG,EAAE,cAAc,CAAC;IACpB,KAAK,EAAE,cAAc,CAAC;IACtB,UAAU,EAAE,mBAAmB,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,qBAAqB,GAAG;IACjE,eAAe,EAAE,qBAAqB,CAAC;IACvC,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,qBAAqB,GAAG;IAC/D,eAAe,EAAE,qBAAqB,CAAC;IACvC,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,2BAA2B,GAAG;IACrE,GAAG,EAAE,cAAc,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,qBAAqB,CAAC;CACtC,CAAC;AA2BF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO,GAAG,IAAI,CAS/F;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CAEnE;AAuBD,wBAAsB,6BAA6B,CAAC,IAAI,EAAE;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,cAAc,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CAyChB;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAS/E;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,cAAc,CA8BjB;AAED,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAkCjC"}