agentplane 0.3.23 → 0.3.26

package/dist/runner/task-state.js

@@ -1,354 +0,0 @@
-import { ensureDocSections, setMarkdownSection } from "@agentplaneorg/core/tasks";
-import { backendNotSupportedMessage } from "../cli/output.js";
-import { loadTaskFromContext } from "../commands/shared/task-backend.js";
-import { backendIsLocalFileBackend, getTaskStore, setTaskFieldsIntent, setTaskSectionIntent, touchTaskDocMetaIntent, } from "../commands/shared/task-store.js";
-import { extractDocSection, normalizeTaskDocVersion, resolveWritableDocSections, taskObservationSectionName, } from "../commands/task/shared.js";
-import { CliError } from "../shared/errors.js";
-const RUNNER_OUTCOME_BEGIN = "<!-- BEGIN RUNNER OUTCOME -->";
-const RUNNER_OUTCOME_END = "<!-- END RUNNER OUTCOME -->";
-const MAX_TASK_RUNNER_HISTORY = 5;
-function formatRunnerTarget(target) {
-    if (target.kind === "task")
-        return `task ${target.task_id}`;
-    const base = `recipe ${target.recipe_id}:${target.scenario_id}`;
-    return target.task_id ? `${base} -> task ${target.task_id}` : base;
-}
-function normalizeRunnerOutcomeSection(sectionText) {
-    const normalized = (sectionText ?? "").replaceAll("\r\n", "\n").trimEnd();
-    if (!normalized)
-        return [RUNNER_OUTCOME_BEGIN, RUNNER_OUTCOME_END].join("\n");
-    const hasBegin = normalized.includes(RUNNER_OUTCOME_BEGIN);
-    const hasEnd = normalized.includes(RUNNER_OUTCOME_END);
-    if (hasBegin && hasEnd)
-        return normalized;
-    return [normalized, "", RUNNER_OUTCOME_BEGIN, RUNNER_OUTCOME_END].join("\n");
-}
-function replaceRunnerOutcomeSection(sectionText, entryText) {
-    const normalized = normalizeRunnerOutcomeSection(sectionText);
-    const beginIdx = normalized.indexOf(RUNNER_OUTCOME_BEGIN);
-    const endIdx = normalized.indexOf(RUNNER_OUTCOME_END);
-    if (beginIdx === -1 || endIdx === -1 || endIdx <= beginIdx) {
-        throw new Error("Runner outcome markers are malformed");
-    }
-    const beforeBegin = normalized.slice(0, beginIdx).trimEnd();
-    const afterEnd = normalized.slice(endIdx + RUNNER_OUTCOME_END.length).trimStart();
-    const parts = [];
-    if (beforeBegin)
-        parts.push(beforeBegin, "");
-    parts.push(RUNNER_OUTCOME_BEGIN);
-    if (entryText.trim())
-        parts.push("", entryText.trimEnd());
-    parts.push("", RUNNER_OUTCOME_END);
-    if (afterEnd)
-        parts.push("", afterEnd);
-    return parts.join("\n").trimEnd();
-}
-function runArtifactsDirForTask(taskId, runId) {
-    return `.agentplane/tasks/${taskId}/runs/${runId}`;
-}
-function formatRunnerAdapterLabel(adapterId) {
-    const normalized = adapterId.trim();
-    if (!normalized)
-        return "Runner";
-    return normalized.slice(0, 1).toUpperCase() + normalized.slice(1);
-}
-function renderTaskRunnerSummary(opts) {
-    const adapter = formatRunnerAdapterLabel(opts.adapter_id);
-    if (opts.status === "prepared")
-        return `${adapter} runner is prepared.`;
-    if (opts.status === "running")
-        return `${adapter} runner is running.`;
-    if (opts.status === "success")
-        return `${adapter} runner completed successfully.`;
-    if (opts.status === "cancelled")
-        return `${adapter} runner was cancelled.`;
-    return `${adapter} runner failed; inspect run artifacts for details.`;
-}
-function stripRunnerHistory(outcome) {
-    return {
-        run_id: outcome.run_id,
-        status: outcome.status,
-        adapter_id: outcome.adapter_id,
-        mode: outcome.mode,
-        updated_at: outcome.updated_at,
-        ...(outcome.started_at ? { started_at: outcome.started_at } : {}),
-        ...(outcome.ended_at ? { ended_at: outcome.ended_at } : {}),
-        exit_code: outcome.exit_code,
-        target: { ...outcome.target },
-        ...(outcome.summary ? { summary: outcome.summary } : {}),
-        ...(outcome.output_paths?.length ? { output_paths: [...outcome.output_paths] } : {}),
-        ...(outcome.metrics ? { metrics: { ...outcome.metrics } } : {}),
-        ...(outcome.evidence ? { evidence: { ...outcome.evidence } } : {}),
-    };
-}
-function runnerHistoryFromTask(outcome) {
-    if (!outcome)
-        return [];
-    if (outcome.history?.length)
-        return outcome.history.map((entry) => stripRunnerHistory(entry));
-    return [stripRunnerHistory(outcome)];
-}
-function renderRunnerMetrics(metrics) {
-    if (!metrics)
-        return null;
-    const pairs = [];
-    if (typeof metrics.duration_ms === "number")
-        pairs.push(`duration_ms=${metrics.duration_ms}`);
-    if (typeof metrics.stdout_bytes === "number")
-        pairs.push(`stdout_bytes=${metrics.stdout_bytes}`);
-    if (typeof metrics.stderr_bytes === "number")
-        pairs.push(`stderr_bytes=${metrics.stderr_bytes}`);
-    if (metrics.output_last_message_bytes === null ||
-        typeof metrics.output_last_message_bytes === "number") {
-        pairs.push(`output_last_message_bytes=${metrics.output_last_message_bytes ?? "null"}`);
-    }
-    return pairs.length > 0 ? pairs.join(", ") : null;
-}
-function renderVerificationHint(status) {
-    if (status === "success") {
-        return "runner completed successfully; human verification and closure remain explicit lifecycle steps.";
-    }
-    if (status === "failed") {
-        return "runner failed; inspect artifacts before retrying or recording verification evidence.";
-    }
-    if (status === "cancelled") {
-        return "runner was cancelled; verification evidence is incomplete until a later run succeeds.";
-    }
-    if (status === "running") {
-        return "runner is still executing; verification evidence is not complete yet.";
-    }
-    return "runner is prepared but has not produced verification-relevant output yet.";
-}
-function renderRunnerEvidence(evidence) {
-    if (!evidence)
-        return [];
-    const lines = [];
-    if (evidence.evidence_paths?.length) {
-        lines.push(`EvidencePaths: ${evidence.evidence_paths.join(", ")}`);
-    }
-    if (evidence.changed_paths?.length) {
-        lines.push(`ChangedPaths: ${evidence.changed_paths.join(", ")}`);
-    }
-    if (typeof evidence.files_changed_count === "number") {
-        lines.push(`FilesChangedCount: ${evidence.files_changed_count}`);
-    }
-    if (evidence.tests_run?.length) {
-        lines.push(`TestsRun: ${evidence.tests_run.join(" | ")}`);
-    }
-    if (evidence.verification_candidates?.length) {
-        lines.push(`VerificationCandidates: ${evidence.verification_candidates.join(" | ")}`);
-    }
-    return lines;
-}
-function renderRunnerOutcomeEntry(opts) {
-    const summary = opts.entry.summary ??
-        renderTaskRunnerSummary({
-            adapter_id: opts.entry.adapter_id,
-            status: opts.entry.status,
-        });
-    const capabilitiesUsed = opts.projection?.result?.capabilities_used;
-    const entryOutputPaths = opts.entry.output_paths;
-    const entryMetrics = opts.entry.metrics;
-    const entryEvidence = opts.entry.evidence;
-    const lines = [
-        `#### ${opts.entry.updated_at} — RUNNER — ${opts.entry.status}`,
-        "",
-        `RunId: ${opts.entry.run_id}`,
-        "",
-        `Adapter: ${opts.entry.adapter_id}`,
-        "",
-        `Mode: ${opts.entry.mode}`,
-        "",
-        `Target: ${formatRunnerTarget(opts.entry.target)}`,
-        "",
-        `UpdatedAt: ${opts.entry.updated_at}`,
-        "",
-        `RunArtifacts: ${runArtifactsDirForTask(opts.task_id, opts.entry.run_id)}`,
-        "",
-        `ExitCode: ${opts.entry.exit_code ?? "null"}`,
-    ];
-    if (opts.entry.started_at) {
-        lines.push("", `StartedAt: ${opts.entry.started_at}`);
-    }
-    if (opts.entry.ended_at) {
-        lines.push("", `EndedAt: ${opts.entry.ended_at}`);
-    }
-    if (summary) {
-        lines.push("", `Summary: ${summary}`);
-    }
-    if (opts.projection?.result?.artifacts?.length) {
-        lines.push("", `Artifacts: ${opts.projection.result.artifacts
-            .map((artifact) => (artifact.label ? `${artifact.label}=${artifact.path}` : artifact.path))
-            .join(", ")}`);
-    }
-    if (!opts.projection?.result?.artifacts?.length && entryOutputPaths?.length) {
-        lines.push("", `Outputs: ${entryOutputPaths.join(", ")}`);
-    }
-    if (capabilitiesUsed?.length) {
-        lines.push("", `Capabilities: ${capabilitiesUsed.join(", ")}`);
-    }
-    const metrics = renderRunnerMetrics(entryMetrics);
-    if (metrics) {
-        lines.push("", `Metrics: ${metrics}`);
-    }
-    const evidenceLines = renderRunnerEvidence(entryEvidence);
-    if (evidenceLines.length > 0) {
-        lines.push("", ...evidenceLines);
-    }
-    lines.push("", `VerificationHint: ${renderVerificationHint(opts.entry.status)}`);
-    return `${lines.join("\n").trimEnd()}\n`;
-}
-function buildTaskRunnerHistoryEntry(projection) {
-    const { state, result } = projection;
-    const outcome = {
-        run_id: state.run_id,
-        status: state.status,
-        adapter_id: state.adapter_id,
-        mode: state.mode,
-        updated_at: state.updated_at,
-        exit_code: state.result?.exit_code ?? null,
-        target: { ...state.target },
-    };
-    if (result?.started_at)
-        outcome.started_at = result.started_at;
-    if (result?.ended_at)
-        outcome.ended_at = result.ended_at;
-    outcome.summary = renderTaskRunnerSummary({
-        adapter_id: state.adapter_id,
-        status: state.status,
-    });
-    if (result?.output_paths?.length)
-        outcome.output_paths = [...result.output_paths];
-    if (result?.metrics)
-        outcome.metrics = { ...result.metrics };
-    if (result?.evidence)
-        outcome.evidence = { ...result.evidence };
-    return outcome;
-}
-function mergeTaskRunnerHistory(opts) {
-    const merged = [];
-    const seen = new Set();
-    for (const entry of [opts.latest, ...runnerHistoryFromTask(opts.previous)]) {
-        if (seen.has(entry.run_id))
-            continue;
-        seen.add(entry.run_id);
-        merged.push(stripRunnerHistory(entry));
-        if (merged.length >= MAX_TASK_RUNNER_HISTORY)
-            break;
-    }
-    return merged;
-}
-function buildTaskRunnerOutcome(opts) {
-    const latest = buildTaskRunnerHistoryEntry(opts.projection);
-    const history = mergeTaskRunnerHistory({ latest, previous: opts.previous });
-    return history.length > 1 ? { ...latest, history } : latest;
-}
-function renderRunnerOutcomeHistory(opts) {
-    const history = opts.outcome.history?.length
-        ? opts.outcome.history
-        : [stripRunnerHistory(opts.outcome)];
-    const [latest, ...previous] = history;
-    return [
-        renderRunnerOutcomeEntry({
-            task_id: opts.task_id,
-            entry: latest,
-            projection: opts.projection,
-        }),
-        ...previous.map((entry) => renderRunnerOutcomeEntry({ task_id: opts.task_id, entry })),
-    ]
-        .join("\n")
-        .trimEnd();
-}
-function resolveRunnerUpdatedBy(task) {
-    const owner = typeof task.owner === "string" ? task.owner.trim() : "";
-    if (owner)
-        return owner;
-    const docUpdatedBy = typeof task.doc_updated_by === "string" ? task.doc_updated_by.trim() : "";
-    if (docUpdatedBy)
-        return docUpdatedBy;
-    return "agentplane";
-}
-export async function persistRunnerOutcomeToTask(opts) {
-    if (opts.bundle?.execution.mode === "dry_run" || opts.state.mode === "dry_run")
-        return;
-    const backend = opts.ctx.taskBackend;
-    if (!backend.writeTask) {
-        throw new CliError({
-            exitCode: 2,
-            code: "E_USAGE",
-            message: backendNotSupportedMessage("task writes"),
-        });
-    }
-    const useStore = backendIsLocalFileBackend(opts.ctx);
-    if (useStore) {
-        const store = getTaskStore(opts.ctx);
-        await store.mutate(opts.task_id, (current) => {
-            const projection = {
-                state: opts.state,
-                result: opts.state.result ?? null,
-            };
-            const outcome = buildTaskRunnerOutcome({
-                projection,
-                previous: current.runner ?? null,
-            });
-            const docVersion = normalizeTaskDocVersion(current.doc_version);
-            const observationSection = taskObservationSectionName(docVersion);
-            const writableSections = resolveWritableDocSections({
-                allowedSections: opts.ctx.config.tasks.doc.sections,
-                requiredSections: opts.ctx.config.tasks.doc.required_sections,
-                targetSection: observationSection,
-            });
-            const baseDoc = ensureDocSections(String(current.doc ?? ""), writableSections);
-            const currentObservation = extractDocSection(baseDoc, observationSection);
-            const nextObservation = replaceRunnerOutcomeSection(currentObservation, renderRunnerOutcomeHistory({
-                task_id: opts.task_id,
-                outcome,
-                projection,
-            }));
-            return [
-                setTaskFieldsIntent({ runner: outcome }),
-                setTaskSectionIntent({
-                    section: observationSection,
-                    text: nextObservation,
-                    requiredSections: writableSections,
-                }),
-                touchTaskDocMetaIntent({
-                    updatedBy: resolveRunnerUpdatedBy(current),
-                    version: docVersion,
-                }),
-            ];
-        });
-        return;
-    }
-    const task = await loadTaskFromContext({ ctx: opts.ctx, taskId: opts.task_id });
-    const projection = {
-        state: opts.state,
-        result: opts.state.result ?? null,
-    };
-    const outcome = buildTaskRunnerOutcome({
-        projection,
-        previous: task.runner ?? null,
-    });
-    const writableSections = resolveWritableDocSections({
-        allowedSections: opts.ctx.config.tasks.doc.sections,
-        requiredSections: opts.ctx.config.tasks.doc.required_sections,
-        targetSection: taskObservationSectionName(normalizeTaskDocVersion(task.doc_version)),
-    });
-    const baseDoc = ensureDocSections(String(task.doc ?? ""), writableSections);
-    const docVersion = normalizeTaskDocVersion(task.doc_version);
-    const observationSection = taskObservationSectionName(docVersion);
-    const currentObservation = extractDocSection(baseDoc, observationSection);
-    const nextObservation = replaceRunnerOutcomeSection(currentObservation, renderRunnerOutcomeHistory({
-        task_id: opts.task_id,
-        outcome,
-        projection,
-    }));
-    const nextDoc = ensureDocSections(setMarkdownSection(baseDoc, observationSection, nextObservation), writableSections);
-    await backend.writeTask({
-        ...task,
-        runner: outcome,
-        doc: nextDoc,
-        doc_updated_at: opts.state.updated_at,
-        doc_updated_by: resolveRunnerUpdatedBy(task),
-    });
-}

package/dist/runner/trace-artifacts.d.ts

@@ -1,14 +0,0 @@
-import type { RunnerResultStatus, RunnerTracePolicy } from "./types.js";
-export type FinalizedTraceArtifact = {
-    artifact_path: string | null;
-    archive_path: string | null;
-};
-export declare function compressedTraceArtifactPath(filePath: string): string;
-export declare function redactTraceText(text: string, patterns: string[] | undefined): string;
-export declare function finalizeTraceArtifact(opts: {
-    file_path: string;
-    policy: RunnerTracePolicy;
-    run_status: RunnerResultStatus;
-}): Promise<FinalizedTraceArtifact>;
-export declare function readTraceArtifactText(filePath: string): Promise<string>;
-//# sourceMappingURL=trace-artifacts.d.ts.map

package/dist/runner/trace-artifacts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace-artifacts.d.ts","sourceRoot":"","sources":["../../src/runner/trace-artifacts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAMxE,MAAM,MAAM,sBAAsB,GAAG;IACnC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAWF,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,CAQpF;AAED,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,kBAAkB,CAAC;CAChC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA+BlC;AAED,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB7E"}

package/dist/runner/trace-artifacts.js

@@ -1,80 +0,0 @@
-import { mkdir, readFile, rm } from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-import { gunzip, gzip } from "node:zlib";
-import { atomicWriteFile } from "@agentplaneorg/core/fs";
-const gzipAsync = promisify(gzip);
-const gunzipAsync = promisify(gunzip);
-const TRACE_REDACTION_TOKEN = "[REDACTED]";
-function shouldRemoveRawTrace(opts) {
-    if (opts.retention === "remove_always")
-        return true;
-    if (opts.retention === "remove_on_success" && opts.run_status === "success")
-        return true;
-    return false;
-}
-export function compressedTraceArtifactPath(filePath) {
-    return `${filePath}.gz`;
-}
-export function redactTraceText(text, patterns) {
-    let redacted = text;
-    for (const pattern of patterns ?? []) {
-        const needle = pattern.trim();
-        if (!needle)
-            continue;
-        redacted = redacted.split(needle).join(TRACE_REDACTION_TOKEN);
-    }
-    return redacted;
-}
-export async function finalizeTraceArtifact(opts) {
-    let rawContent;
-    try {
-        rawContent = await readFile(opts.file_path);
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code === "ENOENT") {
-            return { artifact_path: null, archive_path: null };
-        }
-        throw err;
-    }
-    let archivePath = null;
-    if (opts.policy.compression === "gzip") {
-        archivePath = compressedTraceArtifactPath(opts.file_path);
-        await mkdir(path.dirname(archivePath), { recursive: true });
-        await atomicWriteFile(archivePath, await gzipAsync(rawContent));
-    }
-    if (shouldRemoveRawTrace({ retention: opts.policy.retention, run_status: opts.run_status })) {
-        await rm(opts.file_path, { force: true });
-        return {
-            artifact_path: archivePath,
-            archive_path: null,
-        };
-    }
-    return {
-        artifact_path: opts.file_path,
-        archive_path: archivePath,
-    };
-}
-export async function readTraceArtifactText(filePath) {
-    try {
-        return await readFile(filePath, "utf8");
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code !== "ENOENT")
-            throw err;
-    }
-    const archivePath = compressedTraceArtifactPath(filePath);
-    try {
-        const compressed = await readFile(archivePath);
-        const decompressed = await gunzipAsync(compressed);
-        return decompressed.toString("utf8");
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code === "ENOENT")
-            throw err;
-        throw err;
-    }
-}

package/dist/runner/trace.d.ts

@@ -1,10 +0,0 @@
-import { type RunnerTraceEvent, type RunnerTraceStream } from "./types.js";
-export declare function createRunnerTraceEvent(opts: {
-    ts?: string;
-    seq: number;
-    stream: RunnerTraceStream;
-    adapter_id: string;
-    raw: string;
-}): RunnerTraceEvent;
-export declare function serializeRunnerTraceEvent(event: RunnerTraceEvent): string;
-//# sourceMappingURL=trace.d.ts.map

package/dist/runner/trace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/runner/trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AAqBpB,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,gBAAgB,CAanB;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAEzE"}

package/dist/runner/trace.js

@@ -1,37 +0,0 @@
-import { RUNNER_TRACE_SCHEMA_VERSION, } from "./types.js";
-function normalizeRawLine(raw) {
-    const normalized = raw.replaceAll("\r\n", "\n");
-    return normalized.endsWith("\n") ? normalized.slice(0, -1) : normalized;
-}
-function parseTracePayload(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed)
-        return undefined;
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    }
-    catch {
-        // leave as plain text
-    }
-    return undefined;
-}
-export function createRunnerTraceEvent(opts) {
-    const normalizedRaw = normalizeRawLine(opts.raw);
-    const parsed = parseTracePayload(normalizedRaw);
-    return {
-        schema_version: RUNNER_TRACE_SCHEMA_VERSION,
-        ts: opts.ts ?? new Date().toISOString(),
-        seq: opts.seq,
-        stream: opts.stream,
-        adapter_id: opts.adapter_id,
-        kind: parsed ? "json_event" : "text",
-        raw: normalizedRaw,
-        ...(parsed ? { parsed } : {}),
-    };
-}
-export function serializeRunnerTraceEvent(event) {
-    return `${JSON.stringify(event)}\n`;
-}