agentplane 0.1.8 → 0.1.9

package/dist/commands/scenario.js

@@ -0,0 +1,501 @@
+import { execFile } from "node:child_process";
+import { mkdir, readdir } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { atomicWriteFile, resolveProject } from "@agentplaneorg/core";
+import { mapCoreError } from "../cli/error-map.js";
+import { fileExists, getPathKind } from "../cli/fs-utils.js";
+import { emptyStateMessage, usageMessage } from "../cli/output.js";
+import { CliError } from "../shared/errors.js";
+import { dedupeStrings } from "../shared/strings.js";
+import { RECIPES_DIR_NAME, RECIPES_SCENARIOS_DIR_NAME, RECIPES_SCENARIOS_INDEX_NAME, normalizeScenarioToolStep, readInstalledRecipesFile, readRecipeManifest, readScenarioDefinition, readScenarioIndex, resolveInstalledRecipeDir, resolveInstalledRecipesPath, resolveProjectRecipesCacheDir, } from "./recipes.js";
+const execFileAsync = promisify(execFile);
+const SCENARIO_USAGE = "Usage: agentplane scenario <list|info|run> [args]";
+const SCENARIO_USAGE_EXAMPLE = "agentplane scenario list";
+const SCENARIO_INFO_USAGE = "Usage: agentplane scenario info <recipe:scenario>";
+const SCENARIO_INFO_USAGE_EXAMPLE = "agentplane scenario info viewer:demo";
+const SCENARIO_RUN_USAGE = "Usage: agentplane scenario run <recipe:scenario>";
+const SCENARIO_RUN_USAGE_EXAMPLE = "agentplane scenario run viewer:demo";
+const SCENARIO_REPORT_NAME = "report.json";
+const SENSITIVE_ARG_FLAGS = new Set([
+    "--token",
+    "--secret",
+    "--password",
+    "--api-key",
+    "--apikey",
+    "--access-key",
+    "--client-secret",
+    "--auth",
+    "--authorization",
+    "--bearer",
+]);
+function redactArgs(args) {
+    const out = [...args];
+    for (let i = 0; i < out.length; i++) {
+        const arg = out[i];
+        if (!arg)
+            continue;
+        const eqIndex = arg.indexOf("=");
+        const flag = eqIndex === -1 ? arg : arg.slice(0, eqIndex);
+        if (!SENSITIVE_ARG_FLAGS.has(flag))
+            continue;
+        if (eqIndex !== -1) {
+            out[i] = `${flag}=<redacted>`;
+            continue;
+        }
+        out[i] = flag;
+        if (i + 1 < out.length && !out[i + 1]?.startsWith("-")) {
+            out[i + 1] = "<redacted>";
+            i += 1;
+        }
+    }
+    return out;
+}
+function isNotGitRepoError(err) {
+    if (err instanceof Error) {
+        return err.message.startsWith("Not a git repository");
+    }
+    return false;
+}
+async function getGitDiffSummary(cwd) {
+    try {
+        const [diff, staged, status] = await Promise.all([
+            execFileAsync("git", ["diff", "--stat"], { cwd }),
+            execFileAsync("git", ["diff", "--stat", "--staged"], { cwd }),
+            execFileAsync("git", ["status", "--porcelain"], { cwd }),
+        ]);
+        const diffStat = String(diff.stdout).trim();
+        const stagedStat = String(staged.stdout).trim();
+        const statusLines = String(status.stdout).trim();
+        return {
+            diff_stat: diffStat || undefined,
+            staged_stat: stagedStat || undefined,
+            status: statusLines
+                ? statusLines
+                    .split("\n")
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                : [],
+        };
+    }
+    catch (err) {
+        if (isNotGitRepoError(err))
+            return undefined;
+        return undefined;
+    }
+}
+function collectScenarioEnvKeys(stepEnv) {
+    return dedupeStrings([
+        ...Object.keys(stepEnv ?? {}),
+        "AGENTPLANE_RUN_DIR",
+        "AGENTPLANE_STEP_DIR",
+        "AGENTPLANE_RECIPES_CACHE_DIR",
+        "AGENTPLANE_RECIPE_ID",
+        "AGENTPLANE_SCENARIO_ID",
+        "AGENTPLANE_TOOL_ID",
+    ]);
+}
+async function writeScenarioReport(opts) {
+    const report = {
+        schema_version: 1,
+        recipe: opts.recipeId,
+        scenario: opts.scenarioId,
+        run_id: opts.runId,
+        started_at: opts.startedAt,
+        ended_at: new Date().toISOString(),
+        status: opts.status,
+        steps: opts.steps,
+        git: opts.gitSummary,
+    };
+    await atomicWriteFile(path.join(opts.runDir, SCENARIO_REPORT_NAME), `${JSON.stringify(report, null, 2)}\n`, "utf8");
+}
+async function cmdScenarioList(opts) {
+    try {
+        const installed = await readInstalledRecipesFile(resolveInstalledRecipesPath());
+        const entries = [];
+        for (const recipe of installed.recipes) {
+            const recipeDir = resolveInstalledRecipeDir(recipe);
+            const scenariosDir = path.join(recipeDir, RECIPES_SCENARIOS_DIR_NAME);
+            if ((await getPathKind(scenariosDir)) === "dir") {
+                const files = await readdir(scenariosDir);
+                const jsonFiles = files.filter((entry) => entry.toLowerCase().endsWith(".json")).toSorted();
+                for (const file of jsonFiles) {
+                    const scenario = await readScenarioDefinition(path.join(scenariosDir, file));
+                    entries.push({ recipeId: recipe.id, scenarioId: scenario.id, summary: scenario.summary });
+                }
+                continue;
+            }
+            const scenariosIndexPath = path.join(recipeDir, RECIPES_SCENARIOS_INDEX_NAME);
+            if (await fileExists(scenariosIndexPath)) {
+                const index = await readScenarioIndex(scenariosIndexPath);
+                for (const scenario of index.scenarios) {
+                    entries.push({
+                        recipeId: recipe.id,
+                        scenarioId: scenario.id,
+                        summary: scenario.summary,
+                    });
+                }
+            }
+        }
+        if (entries.length === 0) {
+            process.stdout.write(`${emptyStateMessage("scenarios", "Install a recipe to add scenarios.")}\n`);
+            return 0;
+        }
+        const sorted = entries.toSorted((a, b) => {
+            const byRecipe = a.recipeId.localeCompare(b.recipeId);
+            if (byRecipe !== 0)
+                return byRecipe;
+            return a.scenarioId.localeCompare(b.scenarioId);
+        });
+        for (const entry of sorted) {
+            process.stdout.write(`${entry.recipeId}:${entry.scenarioId} - ${entry.summary ?? "No summary"}\n`);
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapCoreError(err, { command: "scenario list", root: opts.rootOverride ?? null });
+    }
+}
+async function cmdScenarioInfo(opts) {
+    try {
+        const [recipeId, scenarioId] = opts.id.split(":");
+        if (!recipeId || !scenarioId) {
+            throw new CliError({
+                exitCode: 2,
+                code: "E_USAGE",
+                message: usageMessage(SCENARIO_INFO_USAGE, SCENARIO_INFO_USAGE_EXAMPLE),
+            });
+        }
+        const installed = await readInstalledRecipesFile(resolveInstalledRecipesPath());
+        const entry = installed.recipes.find((recipe) => recipe.id === recipeId);
+        if (!entry) {
+            throw new CliError({
+                exitCode: 5,
+                code: "E_IO",
+                message: `Recipe not installed: ${recipeId}`,
+            });
+        }
+        const recipeDir = resolveInstalledRecipeDir(entry);
+        const scenariosDir = path.join(recipeDir, RECIPES_SCENARIOS_DIR_NAME);
+        let scenario = null;
+        if ((await getPathKind(scenariosDir)) === "dir") {
+            const files = await readdir(scenariosDir);
+            const jsonFiles = files.filter((file) => file.toLowerCase().endsWith(".json")).toSorted();
+            for (const file of jsonFiles) {
+                const candidate = await readScenarioDefinition(path.join(scenariosDir, file));
+                if (candidate.id === scenarioId) {
+                    scenario = candidate;
+                    break;
+                }
+            }
+        }
+        let summary;
+        if (!scenario) {
+            const scenariosIndexPath = path.join(recipeDir, RECIPES_SCENARIOS_INDEX_NAME);
+            if (await fileExists(scenariosIndexPath)) {
+                const index = await readScenarioIndex(scenariosIndexPath);
+                const entrySummary = index.scenarios.find((item) => item.id === scenarioId);
+                summary = entrySummary?.summary;
+            }
+        }
+        if (!scenario && !summary) {
+            throw new CliError({
+                exitCode: 5,
+                code: "E_IO",
+                message: `Scenario not found: ${recipeId}:${scenarioId}`,
+            });
+        }
+        process.stdout.write(`Scenario: ${recipeId}:${scenarioId}\n`);
+        if (summary)
+            process.stdout.write(`Summary: ${summary}\n`);
+        if (!scenario) {
+            process.stdout.write("Details: Scenario definition not found in recipe.\n");
+            return 0;
+        }
+        if (scenario.summary)
+            process.stdout.write(`Summary: ${scenario.summary}\n`);
+        if (scenario.description)
+            process.stdout.write(`Description: ${scenario.description}\n`);
+        process.stdout.write(`Goal: ${scenario.goal}\n`);
+        process.stdout.write(`Inputs: ${JSON.stringify(scenario.inputs, null, 2)}\n`);
+        process.stdout.write(`Outputs: ${JSON.stringify(scenario.outputs, null, 2)}\n`);
+        process.stdout.write("Steps:\n");
+        let stepIndex = 1;
+        for (const step of scenario.steps) {
+            process.stdout.write(`  ${stepIndex}. ${JSON.stringify(step)}\n`);
+            stepIndex += 1;
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapCoreError(err, { command: "scenario info", root: opts.rootOverride ?? null });
+    }
+}
+async function executeRecipeTool(opts) {
+    try {
+        const command = opts.runtime === "node" ? "node" : "bash";
+        const { stdout, stderr } = await execFileAsync(command, [opts.entrypoint, ...opts.args], {
+            cwd: opts.cwd,
+            env: opts.env,
+        });
+        return { exitCode: 0, stdout: String(stdout), stderr: String(stderr) };
+    }
+    catch (err) {
+        let execErr = null;
+        if (err && typeof err === "object") {
+            execErr = err;
+        }
+        const exitCode = typeof execErr?.code === "number" ? execErr.code : 1;
+        return {
+            exitCode,
+            stdout: String(execErr?.stdout ?? ""),
+            stderr: String(execErr?.stderr ?? ""),
+        };
+    }
+}
+function sanitizeRunId(value) {
+    return value.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+}
+async function cmdScenarioRun(opts) {
+    try {
+        const resolved = await resolveProject({
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride ?? null,
+        });
+        const [recipeId, scenarioId] = opts.id.split(":");
+        if (!recipeId || !scenarioId) {
+            throw new CliError({
+                exitCode: 2,
+                code: "E_USAGE",
+                message: usageMessage(SCENARIO_RUN_USAGE, SCENARIO_RUN_USAGE_EXAMPLE),
+            });
+        }
+        const installed = await readInstalledRecipesFile(resolveInstalledRecipesPath());
+        const entry = installed.recipes.find((recipe) => recipe.id === recipeId);
+        if (!entry) {
+            throw new CliError({
+                exitCode: 5,
+                code: "E_IO",
+                message: `Recipe not installed: ${recipeId}`,
+            });
+        }
+        const recipeDir = resolveInstalledRecipeDir(entry);
+        const manifestPath = path.join(recipeDir, "manifest.json");
+        const manifest = await readRecipeManifest(manifestPath);
+        const scenariosDir = path.join(recipeDir, RECIPES_SCENARIOS_DIR_NAME);
+        if ((await getPathKind(scenariosDir)) !== "dir") {
+            throw new CliError({
+                exitCode: 5,
+                code: "E_IO",
+                message: `Scenario definitions not found for recipe: ${recipeId}`,
+            });
+        }
+        let scenario = null;
+        const files = await readdir(scenariosDir);
+        const jsonFiles = files.filter((file) => file.toLowerCase().endsWith(".json")).toSorted();
+        for (const file of jsonFiles) {
+            const candidate = await readScenarioDefinition(path.join(scenariosDir, file));
+            if (candidate.id === scenarioId) {
+                scenario = candidate;
+                break;
+            }
+        }
+        if (!scenario) {
+            throw new CliError({
+                exitCode: 5,
+                code: "E_IO",
+                message: `Scenario not found: ${recipeId}:${scenarioId}`,
+            });
+        }
+        const runsRoot = path.join(resolved.agentplaneDir, RECIPES_DIR_NAME, recipeId, "runs");
+        await mkdir(runsRoot, { recursive: true });
+        const recipesCacheDir = resolveProjectRecipesCacheDir(resolved);
+        await mkdir(recipesCacheDir, { recursive: true });
+        const runStartedAt = new Date().toISOString();
+        const runId = `${new Date()
+            .toISOString()
+            .replaceAll(":", "-")
+            .replaceAll(".", "-")}-${sanitizeRunId(scenarioId)}`;
+        const runDir = path.join(runsRoot, runId);
+        await mkdir(runDir, { recursive: true });
+        const stepsMeta = [];
+        const stepsReport = [];
+        for (let index = 0; index < scenario.steps.length; index++) {
+            const step = normalizeScenarioToolStep(scenario.steps[index], `${recipeId}:${scenarioId}`);
+            const toolEntry = manifest.tools?.find((tool) => tool?.id === step.tool);
+            if (!toolEntry) {
+                throw new CliError({
+                    exitCode: 5,
+                    code: "E_IO",
+                    message: `Tool not found in recipe manifest: ${step.tool}`,
+                });
+            }
+            const runtime = toolEntry.runtime === "node" || toolEntry.runtime === "bash" ? toolEntry.runtime : "";
+            const entrypoint = typeof toolEntry.entrypoint === "string" ? toolEntry.entrypoint : "";
+            if (!runtime || !entrypoint) {
+                throw new CliError({
+                    exitCode: 3,
+                    code: "E_VALIDATION",
+                    message: `Tool entry is missing runtime/entrypoint: ${step.tool}`,
+                });
+            }
+            if (Array.isArray(toolEntry.permissions) && toolEntry.permissions.length > 0) {
+                process.stdout.write(`Warning: tool ${toolEntry.id} declares permissions: ${toolEntry.permissions.join(", ")}\n`);
+            }
+            const entrypointPath = path.join(recipeDir, entrypoint);
+            if (!(await fileExists(entrypointPath))) {
+                throw new CliError({
+                    exitCode: 5,
+                    code: "E_IO",
+                    message: `Tool entrypoint not found: ${entrypoint}`,
+                });
+            }
+            const stepDir = path.join(runDir, `step-${index + 1}-${sanitizeRunId(step.tool)}`);
+            await mkdir(stepDir, { recursive: true });
+            const stepEnvKeys = collectScenarioEnvKeys(step.env);
+            const env = {
+                ...process.env,
+                ...step.env,
+                AGENTPLANE_RUN_DIR: runDir,
+                AGENTPLANE_STEP_DIR: stepDir,
+                AGENTPLANE_RECIPES_CACHE_DIR: recipesCacheDir,
+                AGENTPLANE_RECIPE_ID: recipeId,
+                AGENTPLANE_SCENARIO_ID: scenarioId,
+                AGENTPLANE_TOOL_ID: step.tool,
+            };
+            const startedAt = Date.now();
+            const result = await executeRecipeTool({
+                runtime,
+                entrypoint: entrypointPath,
+                args: step.args,
+                cwd: recipeDir,
+                env,
+            });
+            const durationMs = Date.now() - startedAt;
+            await atomicWriteFile(path.join(stepDir, "stdout.log"), result.stdout, "utf8");
+            await atomicWriteFile(path.join(stepDir, "stderr.log"), result.stderr, "utf8");
+            stepsMeta.push({
+                tool: step.tool,
+                runtime,
+                entrypoint,
+                exitCode: result.exitCode,
+                duration_ms: durationMs,
+            });
+            stepsReport.push({
+                step: index + 1,
+                tool: step.tool,
+                runtime,
+                entrypoint,
+                args: redactArgs(step.args),
+                env_keys: stepEnvKeys,
+                exit_code: result.exitCode,
+                duration_ms: durationMs,
+            });
+            if (result.exitCode !== 0) {
+                const gitSummary = await getGitDiffSummary(resolved.gitRoot);
+                await writeScenarioReport({
+                    runDir,
+                    recipeId,
+                    scenarioId,
+                    runId,
+                    startedAt: runStartedAt,
+                    status: "failed",
+                    steps: stepsReport,
+                    gitSummary,
+                });
+                await atomicWriteFile(path.join(runDir, "meta.json"), `${JSON.stringify({
+                    recipe: recipeId,
+                    scenario: scenarioId,
+                    run_id: runId,
+                    steps: stepsMeta,
+                }, null, 2)}\n`, "utf8");
+                throw new CliError({
+                    exitCode: result.exitCode,
+                    code: "E_INTERNAL",
+                    message: `Scenario step failed: ${step.tool}`,
+                });
+            }
+        }
+        const gitSummary = await getGitDiffSummary(resolved.gitRoot);
+        await writeScenarioReport({
+            runDir,
+            recipeId,
+            scenarioId,
+            runId,
+            startedAt: runStartedAt,
+            status: "success",
+            steps: stepsReport,
+            gitSummary,
+        });
+        await atomicWriteFile(path.join(runDir, "meta.json"), `${JSON.stringify({
+            recipe: recipeId,
+            scenario: scenarioId,
+            run_id: runId,
+            steps: stepsMeta,
+        }, null, 2)}\n`, "utf8");
+        process.stdout.write(`Run artifacts: ${path.relative(resolved.gitRoot, runDir)}\n`);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        throw mapCoreError(err, { command: "scenario run", root: opts.rootOverride ?? null });
+    }
+}
+export async function cmdScenario(opts) {
+    const sub = opts.command;
+    if (!sub) {
+        throw new CliError({
+            exitCode: 2,
+            code: "E_USAGE",
+            message: usageMessage(SCENARIO_USAGE, SCENARIO_USAGE_EXAMPLE),
+        });
+    }
+    if (sub === "list") {
+        if (opts.args.length > 0) {
+            throw new CliError({
+                exitCode: 2,
+                code: "E_USAGE",
+                message: usageMessage(SCENARIO_USAGE, SCENARIO_USAGE_EXAMPLE),
+            });
+        }
+        return await cmdScenarioList({ cwd: opts.cwd, rootOverride: opts.rootOverride });
+    }
+    if (sub === "info") {
+        if (opts.args.length !== 1) {
+            throw new CliError({
+                exitCode: 2,
+                code: "E_USAGE",
+                message: usageMessage(SCENARIO_INFO_USAGE, SCENARIO_INFO_USAGE_EXAMPLE),
+            });
+        }
+        return await cmdScenarioInfo({
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            id: opts.args[0],
+        });
+    }
+    if (sub === "run") {
+        if (opts.args.length !== 1) {
+            throw new CliError({
+                exitCode: 2,
+                code: "E_USAGE",
+                message: usageMessage(SCENARIO_RUN_USAGE, SCENARIO_RUN_USAGE_EXAMPLE),
+            });
+        }
+        return await cmdScenarioRun({
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride,
+            id: opts.args[0],
+        });
+    }
+    throw new CliError({
+        exitCode: 2,
+        code: "E_USAGE",
+        message: usageMessage(SCENARIO_USAGE, SCENARIO_USAGE_EXAMPLE),
+    });
+}

package/dist/commands/shared/task-backend.d.ts

@@ -1,15 +1,31 @@
 import { loadTaskBackend, type TaskData } from "../../backends/task-backend.js";
+export type CommandContext = {
+    backend: Awaited<ReturnType<typeof loadTaskBackend>>["backend"];
+    backendId: string;
+    backendConfigPath: string;
+    resolved: Awaited<ReturnType<typeof loadTaskBackend>>["resolved"];
+    config: Awaited<ReturnType<typeof loadTaskBackend>>["config"];
+};
 export declare function resolveDocUpdatedBy(task: TaskData, author?: string): string;
 export declare function taskDataToFrontmatter(task: TaskData): Record<string, unknown>;
+export declare function loadCommandContext(opts: {
+    cwd: string;
+    rootOverride?: string | null;
+}): Promise<CommandContext>;
+export declare function loadTaskFromContext(opts: {
+    ctx: CommandContext;
+    taskId: string;
+}): Promise<TaskData>;
 export declare function loadBackendTask(opts: {
     cwd: string;
     rootOverride?: string | null;
     taskId: string;
 }): Promise<{
-    backend: Awaited<ReturnType<typeof loadTaskBackend>>["backend"];
+    backend: CommandContext["backend"];
     backendId: string;
-    resolved: Awaited<ReturnType<typeof loadTaskBackend>>["resolved"];
-    config: Awaited<ReturnType<typeof loadTaskBackend>>["config"];
+    backendConfigPath: string;
+    resolved: CommandContext["resolved"];
+    config: CommandContext["config"];
     task: TaskData;
 }>;
 //# sourceMappingURL=task-backend.d.ts.map

package/dist/commands/shared/task-backend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-backend.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/task-backend.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAShF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ3E;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyB7E;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IACV,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAClE,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC9D,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC,CAgBD"}
+{"version":3,"file":"task-backend.d.ts","sourceRoot":"","sources":["../../../src/commands/shared/task-backend.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAEhF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAClE,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;CAC/D,CAAC;AASF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ3E;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyB7E;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,GAAG,OAAO,CAAC,cAAc,CAAC,CAM1B;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC9C,GAAG,EAAE,cAAc,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAYpB;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IACV,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACrC,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IACjC,IAAI,EAAE,QAAQ,CAAC;CAChB,CAAC,CAID"}

package/dist/commands/shared/task-backend.js

@@ -42,14 +42,17 @@ export function taskDataToFrontmatter(task) {
         description: task.description ?? "",
     };
 }
-export async function loadBackendTask(opts) {
-    const { backend, backendId, resolved, config } = await loadTaskBackend({
+export async function loadCommandContext(opts) {
+    const { backend, backendId, backendConfigPath, resolved, config } = await loadTaskBackend({
         cwd: opts.cwd,
         rootOverride: opts.rootOverride ?? null,
     });
-    const task = await backend.getTask(opts.taskId);
+    return { backend, backendId, backendConfigPath, resolved, config };
+}
+export async function loadTaskFromContext(opts) {
+    const task = await opts.ctx.backend.getTask(opts.taskId);
     if (!task) {
-        const tasksDir = path.join(resolved.gitRoot, config.paths.workflow_dir);
+        const tasksDir = path.join(opts.ctx.resolved.gitRoot, opts.ctx.config.paths.workflow_dir);
         const readmePath = path.join(tasksDir, opts.taskId, "README.md");
         throw new CliError({
             exitCode: 4,
@@ -57,5 +60,10 @@ export async function loadBackendTask(opts) {
             message: `ENOENT: no such file or directory, open '${readmePath}'`,
         });
     }
-    return { backend, backendId, resolved, config, task };
+    return task;
+}
+export async function loadBackendTask(opts) {
+    const ctx = await loadCommandContext({ cwd: opts.cwd, rootOverride: opts.rootOverride ?? null });
+    const task = await loadTaskFromContext({ ctx, taskId: opts.taskId });
+    return { ...ctx, task };
 }

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

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

package/dist/commands/task/block.js

@@ -1,35 +1,29 @@
-import { loadConfig, resolveProject } from "@agentplaneorg/core";
 import { mapBackendError } from "../../cli/error-map.js";
 import { successMessage } from "../../cli/output.js";
 import { formatCommentBodyForCommit } from "../../shared/comment-format.js";
 import { CliError } from "../../shared/errors.js";
 import { commitFromComment } from "../guard/index.js";
-import { loadBackendTask } from "../shared/task-backend.js";
-import { defaultCommitEmojiForStatus, enforceStatusCommitPolicy, isTransitionAllowed, nowIso, requireStructuredComment, } from "./shared.js";
+import { loadCommandContext, loadTaskFromContext } from "../shared/task-backend.js";
+import { appendTaskEvent, defaultCommitEmojiForStatus, enforceStatusCommitPolicy, isTransitionAllowed, nowIso, requireStructuredComment, } from "./shared.js";
 export const BLOCK_USAGE = "Usage: agentplane block <task-id> --author <id> --body <text> [flags]";
 export const BLOCK_USAGE_EXAMPLE = 'agentplane block 202602030608-F1Q8AB --author CODER --body "Blocked: ..."';
 export async function cmdBlock(opts) {
     try {
-        const resolved = await resolveProject({
+        const ctx = await loadCommandContext({
             cwd: opts.cwd,
             rootOverride: opts.rootOverride ?? null,
         });
-        const loaded = await loadConfig(resolved.agentplaneDir);
         if (opts.commitFromComment) {
             enforceStatusCommitPolicy({
-                policy: loaded.config.status_commit_policy,
+                policy: ctx.config.status_commit_policy,
                 action: "block",
                 confirmed: opts.confirmStatusCommit,
                 quiet: opts.quiet,
             });
         }
-        const { prefix, min_chars: minChars } = loaded.config.tasks.comments.blocked;
+        const { prefix, min_chars: minChars } = ctx.config.tasks.comments.blocked;
         requireStructuredComment(opts.body, prefix, minChars);
-        const { backend, task } = await loadBackendTask({
-            cwd: opts.cwd,
-            rootOverride: opts.rootOverride,
-            taskId: opts.taskId,
-        });
+        const task = await loadTaskFromContext({ ctx, taskId: opts.taskId });
         const currentStatus = String(task.status || "TODO").toUpperCase();
         if (!opts.force && !isTransitionAllowed(currentStatus, "BLOCKED")) {
             throw new CliError({
@@ -39,28 +33,40 @@ export async function cmdBlock(opts) {
             });
         }
         const formattedComment = opts.commitFromComment
-            ? formatCommentBodyForCommit(opts.body, loaded.config)
+            ? formatCommentBodyForCommit(opts.body, ctx.config)
             : null;
         const commentBody = formattedComment ?? opts.body;
         const existingComments = Array.isArray(task.comments)
             ? task.comments.filter((item) => !!item && typeof item.author === "string" && typeof item.body === "string")
             : [];
         const commentsValue = [...existingComments, { author: opts.author, body: commentBody }];
+        const at = nowIso();
         const nextTask = {
             ...task,
             status: "BLOCKED",
             comments: commentsValue,
+            events: appendTaskEvent(task, {
+                type: "status",
+                at,
+                author: opts.author,
+                from: currentStatus,
+                to: "BLOCKED",
+                note: commentBody,
+            }),
             doc_version: 2,
-            doc_updated_at: nowIso(),
+            doc_updated_at: at,
             doc_updated_by: opts.author,
         };
-        await backend.writeTask(nextTask);
+        await ctx.backend.writeTask(nextTask);
         let commitInfo = null;
         if (opts.commitFromComment) {
             commitInfo = await commitFromComment({
                 cwd: opts.cwd,
                 rootOverride: opts.rootOverride,
                 taskId: opts.taskId,
+                author: opts.author,
+                statusFrom: currentStatus,
+                statusTo: "BLOCKED",
                 commentBody: opts.body,
                 formattedComment,
                 emoji: opts.commitEmoji ?? defaultCommitEmojiForStatus("BLOCKED"),
@@ -69,7 +75,7 @@ export async function cmdBlock(opts) {
                 allowTasks: opts.commitAllowTasks,
                 requireClean: opts.commitRequireClean,
                 quiet: opts.quiet,
-                config: loaded.config,
+                config: ctx.config,
             });
         }
         if (!opts.quiet) {