agentplane 0.2.25 → 0.2.26

package/dist/harness/token-accounting.d.ts

@@ -0,0 +1,19 @@
+export type TokenTotals = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+};
+export type TokenUsageEvent = {
+    threadId: string;
+    payload: Record<string, unknown>;
+};
+export type TokenAccumulator = {
+    byThread: Record<string, TokenTotals>;
+    global: TokenTotals;
+};
+export declare function createTokenAccumulator(): TokenAccumulator;
+export declare function applyTokenUsageEvent(state: TokenAccumulator, event: TokenUsageEvent): {
+    state: TokenAccumulator;
+    accepted: boolean;
+};
+//# sourceMappingURL=token-accounting.d.ts.map

package/dist/harness/token-accounting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-accounting.d.ts","sourceRoot":"","sources":["../../src/harness/token-accounting.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACtC,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAwDF,wBAAgB,sBAAsB,IAAI,gBAAgB,CAKzD;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,eAAe,GACrB;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAuBhD"}

package/dist/harness/token-accounting.js

@@ -0,0 +1,77 @@
+const ZERO_TOTALS = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+};
+function safeInt(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return Math.trunc(value);
+    if (typeof value === "string" && /^\d+$/.test(value))
+        return Number.parseInt(value, 10);
+    return null;
+}
+function extractAbsoluteTotals(payload) {
+    const tokenUsage = payload.tokenUsage;
+    if (tokenUsage && typeof tokenUsage === "object" && !Array.isArray(tokenUsage)) {
+        const total = tokenUsage.total;
+        if (total && typeof total === "object" && !Array.isArray(total)) {
+            const totalObj = total;
+            const input = safeInt(totalObj.inputTokens);
+            const output = safeInt(totalObj.outputTokens);
+            const all = safeInt(totalObj.totalTokens);
+            if (input !== null && output !== null && all !== null) {
+                return { inputTokens: input, outputTokens: output, totalTokens: all };
+            }
+        }
+    }
+    const info = payload.info;
+    if (info && typeof info === "object" && !Array.isArray(info)) {
+        const totalUsage = info.total_token_usage;
+        if (totalUsage && typeof totalUsage === "object" && !Array.isArray(totalUsage)) {
+            const usage = totalUsage;
+            const input = safeInt(usage.input_tokens);
+            const output = safeInt(usage.output_tokens);
+            const all = safeInt(usage.total_tokens);
+            if (input !== null && output !== null && all !== null) {
+                return { inputTokens: input, outputTokens: output, totalTokens: all };
+            }
+        }
+    }
+    return null;
+}
+function mergeGlobal(byThread) {
+    const global = { ...ZERO_TOTALS };
+    for (const totals of Object.values(byThread)) {
+        global.inputTokens += totals.inputTokens;
+        global.outputTokens += totals.outputTokens;
+        global.totalTokens += totals.totalTokens;
+    }
+    return global;
+}
+export function createTokenAccumulator() {
+    return {
+        byThread: {},
+        global: { ...ZERO_TOTALS },
+    };
+}
+export function applyTokenUsageEvent(state, event) {
+    const absolute = extractAbsoluteTotals(event.payload);
+    if (!absolute) {
+        return { state, accepted: false };
+    }
+    const prev = state.byThread[event.threadId] ?? { ...ZERO_TOTALS };
+    if (absolute.totalTokens < prev.totalTokens) {
+        return { state, accepted: false };
+    }
+    const nextByThread = {
+        ...state.byThread,
+        [event.threadId]: absolute,
+    };
+    return {
+        accepted: true,
+        state: {
+            byThread: nextByThread,
+            global: mergeGlobal(nextByThread),
+        },
+    };
+}

package/dist/harness/workspace-safety.d.ts

@@ -0,0 +1,14 @@
+export declare function sanitizeWorkspaceKey(raw: string): string;
+export declare function resolveWorkspacePath(root: string, key: string): string;
+export declare function validateWorkspacePathInvariants(opts: {
+    root: string;
+    workspacePath: string;
+}): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    code: "WORKSPACE_EQUALS_ROOT" | "WORKSPACE_OUTSIDE_ROOT" | "WORKSPACE_SYMLINK_ESCAPE" | "WORKSPACE_PATH_UNREADABLE";
+    path: string;
+    message: string;
+}>;
+//# sourceMappingURL=workspace-safety.d.ts.map

package/dist/harness/workspace-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-safety.d.ts","sourceRoot":"","sources":["../../src/harness/workspace-safety.ts"],"names":[],"mappings":"AAGA,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAIxD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAsB,+BAA+B,CAAC,IAAI,EAAE;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB,GAAG,OAAO,CACP;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GACZ;IACE,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EACA,uBAAuB,GACvB,wBAAwB,GACxB,0BAA0B,GAC1B,2BAA2B,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CACJ,CAqDA"}

package/dist/harness/workspace-safety.js

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export function sanitizeWorkspaceKey(raw) {
+    const normalized = raw.trim();
+    if (normalized.length === 0)
+        return "issue";
+    return normalized.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+}
+export function resolveWorkspacePath(root, key) {
+    return path.join(path.resolve(root), sanitizeWorkspaceKey(key));
+}
+export async function validateWorkspacePathInvariants(opts) {
+    const root = path.resolve(opts.root);
+    const workspace = path.resolve(opts.workspacePath);
+    const rootPrefix = `${root}${path.sep}`;
+    if (workspace === root) {
+        return {
+            ok: false,
+            code: "WORKSPACE_EQUALS_ROOT",
+            path: workspace,
+            message: "Workspace path must not equal workspace root.",
+        };
+    }
+    if (!(workspace === root || workspace.startsWith(rootPrefix))) {
+        return {
+            ok: false,
+            code: "WORKSPACE_OUTSIDE_ROOT",
+            path: workspace,
+            message: "Workspace path escapes configured workspace root.",
+        };
+    }
+    const relative = path.relative(root, workspace);
+    const segments = relative.split(path.sep).filter((s) => s.length > 0);
+    let cursor = root;
+    for (const segment of segments) {
+        cursor = path.join(cursor, segment);
+        try {
+            const stat = await fs.lstat(cursor);
+            if (stat.isSymbolicLink()) {
+                return {
+                    ok: false,
+                    code: "WORKSPACE_SYMLINK_ESCAPE",
+                    path: cursor,
+                    message: "Workspace path contains a symlink component.",
+                };
+            }
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === "ENOENT") {
+                return { ok: true };
+            }
+            return {
+                ok: false,
+                code: "WORKSPACE_PATH_UNREADABLE",
+                path: cursor,
+                message: `Workspace path cannot be validated: ${err.message}`,
+            };
+        }
+    }
+    return { ok: true };
+}

package/dist/recipes/bundled-recipes.d.ts

@@ -4,10 +4,14 @@ export type BundledRecipesCatalog = {
         id: string;
         summary: string;
         description?: string;
+        source_path?: string;
         versions: {
             version: string;
         }[];
     }[];
 };
+export type BundledRecipeEntry = BundledRecipesCatalog["recipes"][number];
 export declare const BUNDLED_RECIPES_CATALOG: BundledRecipesCatalog;
+export declare function resolveBundledRecipeSourcePath(recipeId: string): string | null;
+export declare function getBundledRecipeEntry(recipeId: string): BundledRecipeEntry | null;
 //# sourceMappingURL=bundled-recipes.d.ts.map

package/dist/recipes/bundled-recipes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundled-recipes.d.ts","sourceRoot":"","sources":["../../src/recipes/bundled-recipes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG;IAClC,cAAc,EAAE,CAAC,CAAC;IAClB,OAAO,EAAE;QACP,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KACjC,EAAE,CAAC;CACL,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,qBAGrC,CAAC"}
+{"version":3,"file":"bundled-recipes.d.ts","sourceRoot":"","sources":["../../src/recipes/bundled-recipes.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,qBAAqB,GAAG;IAClC,cAAc,EAAE,CAAC,CAAC;IAClB,OAAO,EAAE;QACP,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;KACjC,EAAE,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB,EAAE,qBAGrC,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK9E;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAEjF"}

package/dist/recipes/bundled-recipes.js

@@ -1,4 +1,15 @@
+import { fileURLToPath } from "node:url";
 export const BUNDLED_RECIPES_CATALOG = {
     schema_version: 1,
     recipes: [],
 };
+export function resolveBundledRecipeSourcePath(recipeId) {
+    const entry = getBundledRecipeEntry(recipeId);
+    const sourcePath = entry?.source_path?.trim();
+    if (!sourcePath)
+        return null;
+    return fileURLToPath(new URL(`../../assets/${sourcePath.replace(/^\/+/, "")}`, import.meta.url));
+}
+export function getBundledRecipeEntry(recipeId) {
+    return BUNDLED_RECIPES_CATALOG.recipes.find((recipe) => recipe.id === recipeId) ?? null;
+}

package/dist/shared/errors.d.ts

@@ -17,6 +17,12 @@ export type JsonErrorGuidance = {
         reason: string;
         reasonCode?: string;
     };
+    reasonDecode?: {
+        code: string;
+        category: string;
+        summary: string;
+        action: string;
+    };
 };
 export declare function formatJsonError(err: CliError, guidance?: JsonErrorGuidance): string;
 //# sourceMappingURL=errors.d.ts.map

package/dist/shared/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/shared/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,cAAc,GACd,MAAM,GACN,OAAO,GACP,WAAW,GACX,WAAW,GACX,YAAY,CAAC;AAEjB,qBAAa,QAAS,SAAQ,KAAK;IACjC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,SAAS,CAAC;IAChC,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEtC,IAAI,EAAE;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,SAAS,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC;CAMF;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAAC;AAEF,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAcnF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/shared/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,cAAc,GACd,MAAM,GACN,OAAO,GACP,WAAW,GACX,WAAW,GACX,YAAY,CAAC;AAEjB,qBAAa,QAAS,SAAQ,KAAK;IACjC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,SAAS,CAAC;IAChC,SAAgB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEtC,IAAI,EAAE;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,SAAS,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACnC;CAMF;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,YAAY,CAAC,EAAE;QACb,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH,CAAC;AAEF,wBAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAenF"}

package/dist/shared/errors.js

@@ -17,6 +17,7 @@ export function formatJsonError(err, guidance) {
             context: err.context ?? undefined,
             hint: guidance?.hint,
             next_action: guidance?.nextAction,
+            reason_decode: guidance?.reasonDecode,
         },
     }, null, 2);
 }

package/dist/workflow-runtime/build.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowBuildInput, WorkflowBuildOutput } from "./types.js";
+export declare function buildWorkflowFromTemplates(input: WorkflowBuildInput): WorkflowBuildOutput;
+export declare const DEFAULT_WORKFLOW_TEMPLATE = "---\nversion: 1\nmode: direct\nowners:\n  orchestrator: ORCHESTRATOR\napprovals:\n  require_plan: true\n  require_verify: true\n  require_network: true\nretry_policy:\n  normal_exit_continuation: true\n  abnormal_backoff: exponential\n  max_attempts: 5\ntimeouts:\n  stall_seconds: 900\nin_scope_paths:\n  - packages/**\n---\n\n## Prompt Template\nRepository root: {{ runtime.repo_root }}\nWorkflow mode: {{ workflow.mode }}\n\n## Checks\n- preflight\n- verify\n- finish\n\n## Fallback\nlast_known_good: .agentplane/workflows/last-known-good.md\n";
+//# sourceMappingURL=build.d.ts.map

package/dist/workflow-runtime/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/workflow-runtime/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAsB,MAAM,YAAY,CAAC;AAqC9F,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CA8DzF;AAED,eAAO,MAAM,yBAAyB,uiBA8BrC,CAAC"}

package/dist/workflow-runtime/build.js

@@ -0,0 +1,114 @@
+import { parseWorkflowMarkdown, serializeWorkflowMarkdown } from "./markdown.js";
+import { emitWorkflowEvent } from "./observability.js";
+import { renderTemplateStrict, validateTemplateStrict } from "./template.js";
+import { validateWorkflowDocument } from "./validate.js";
+function mergeRecord(baseValue, overrideValue) {
+    const out = { ...baseValue };
+    for (const [key, value] of Object.entries(overrideValue)) {
+        if (value &&
+            typeof value === "object" &&
+            !Array.isArray(value) &&
+            out[key] &&
+            typeof out[key] === "object" &&
+            !Array.isArray(out[key])) {
+            out[key] = mergeRecord(out[key], value);
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+}
+function mergeSections(baseSections, overrideSections) {
+    const out = { ...baseSections };
+    for (const [key, value] of Object.entries(overrideSections)) {
+        if (value.trim().length === 0)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+export function buildWorkflowFromTemplates(input) {
+    emitWorkflowEvent({ event: "workflow_build_started" });
+    const diagnostics = [];
+    const base = parseWorkflowMarkdown(input.baseTemplate);
+    diagnostics.push(...base.diagnostics);
+    const override = input.projectOverrideTemplate
+        ? parseWorkflowMarkdown(input.projectOverrideTemplate)
+        : null;
+    if (override)
+        diagnostics.push(...override.diagnostics);
+    const mergedFrontMatter = mergeRecord(base.document.frontMatterRaw, override?.document.frontMatterRaw ?? {});
+    const runtimeWorkflow = input.runtimeContext.workflow;
+    if (runtimeWorkflow && typeof runtimeWorkflow === "object" && !Array.isArray(runtimeWorkflow)) {
+        const runtimeMode = runtimeWorkflow.mode;
+        if (runtimeMode === "direct" || runtimeMode === "branch_pr") {
+            mergedFrontMatter.mode = runtimeMode;
+        }
+    }
+    const mergedSections = mergeSections(base.document.sections, override?.document.sections ?? {});
+    const promptTemplate = mergedSections["Prompt Template"] ?? "";
+    const strict = validateTemplateStrict(promptTemplate, input.runtimeContext, {
+        strictVariables: true,
+        strictFilters: true,
+    });
+    diagnostics.push(...strict.diagnostics);
+    const renderedPrompt = renderTemplateStrict(promptTemplate, input.runtimeContext, {
+        strictVariables: true,
+        strictFilters: true,
+    });
+    diagnostics.push(...renderedPrompt.diagnostics);
+    mergedSections["Prompt Template"] = renderedPrompt.text;
+    const renderedText = serializeWorkflowMarkdown(mergedFrontMatter, mergedSections);
+    const parsedRendered = parseWorkflowMarkdown(renderedText);
+    diagnostics.push(...parsedRendered.diagnostics);
+    const schema = validateWorkflowDocument(parsedRendered.document);
+    diagnostics.push(...schema.diagnostics);
+    const hasError = diagnostics.some((d) => d.severity === "ERROR");
+    if (hasError) {
+        emitWorkflowEvent({
+            event: "workflow_build_failed",
+            details: { diagnostics: diagnostics.length },
+        });
+    }
+    else {
+        emitWorkflowEvent({
+            event: "workflow_build_completed",
+            details: { diagnostics: diagnostics.length },
+        });
+    }
+    return {
+        text: renderedText,
+        diagnostics,
+    };
+}
+export const DEFAULT_WORKFLOW_TEMPLATE = `---
+version: 1
+mode: direct
+owners:
+  orchestrator: ORCHESTRATOR
+approvals:
+  require_plan: true
+  require_verify: true
+  require_network: true
+retry_policy:
+  normal_exit_continuation: true
+  abnormal_backoff: exponential
+  max_attempts: 5
+timeouts:
+  stall_seconds: 900
+in_scope_paths:
+  - packages/**
+---
+
+## Prompt Template
+Repository root: {{ runtime.repo_root }}
+Workflow mode: {{ workflow.mode }}
+
+## Checks
+- preflight
+- verify
+- finish
+
+## Fallback
+last_known_good: .agentplane/workflows/last-known-good.md
+`;

package/dist/workflow-runtime/enforcement.d.ts

@@ -0,0 +1,3 @@
+export declare function isWorkflowEnforcementDisabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function workflowEnforcementEnvHint(): string;
+//# sourceMappingURL=enforcement.d.ts.map

package/dist/workflow-runtime/enforcement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforcement.d.ts","sourceRoot":"","sources":["../../src/workflow-runtime/enforcement.ts"],"names":[],"mappings":"AAEA,wBAAgB,6BAA6B,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAI3F;AAED,wBAAgB,0BAA0B,IAAI,MAAM,CAEnD"}

package/dist/workflow-runtime/enforcement.js

@@ -0,0 +1,10 @@
+const DISABLED_VALUES = new Set(["0", "false", "off", "disabled"]);
+export function isWorkflowEnforcementDisabled(env = process.env) {
+    const raw = env.AGENTPLANE_WORKFLOW_ENFORCEMENT ?? env.AGENTPLANE_WORKFLOW_CONTRACT;
+    if (typeof raw !== "string")
+        return false;
+    return DISABLED_VALUES.has(raw.trim().toLowerCase());
+}
+export function workflowEnforcementEnvHint() {
+    return "AGENTPLANE_WORKFLOW_ENFORCEMENT";
+}

package/dist/workflow-runtime/file-ops.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowDiagnostic, WorkflowDocument, WorkflowValidationResult } from "./types.js";
+export declare function readWorkflowDocument(repoRoot: string, absPath?: string): Promise<{
+    document: WorkflowDocument | null;
+    diagnostics: WorkflowDiagnostic[];
+    path: string;
+}>;
+export declare function validateWorkflowAtPath(repoRoot: string, absPath?: string): Promise<WorkflowValidationResult>;
+export declare function validateWorkflowText(repoRoot: string, workflowText: string): Promise<WorkflowValidationResult>;
+export declare function publishWorkflowCandidate(repoRoot: string, candidateText: string): Promise<WorkflowValidationResult>;
+export declare function restoreWorkflowFromLastKnownGood(repoRoot: string): Promise<WorkflowValidationResult>;
+//# sourceMappingURL=file-ops.d.ts.map

package/dist/workflow-runtime/file-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-ops.d.ts","sourceRoot":"","sources":["../../src/workflow-runtime/file-ops.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAiDjG,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC;IAAE,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAAC,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA0BjG;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,wBAAwB,CAAC,CAuBnC;AAED,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,wBAAwB,CAAC,CAanC;AAED,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,wBAAwB,CAAC,CA0DnC;AAED,wBAAsB,gCAAgC,CACpD,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,wBAAwB,CAAC,CA6EnC"}

package/dist/workflow-runtime/file-ops.js

@@ -0,0 +1,248 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig } from "@agentplaneorg/core";
+import { parseWorkflowMarkdown } from "./markdown.js";
+import { emitWorkflowEvent } from "./observability.js";
+import { resolveWorkflowPaths } from "./paths.js";
+import { validateWorkflowDocument } from "./validate.js";
+async function pathExists(absPath) {
+    try {
+        await fs.access(absPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveWorkflowReadPath(paths) {
+    if (await pathExists(paths.workflowPath))
+        return paths.workflowPath;
+    if (await pathExists(paths.legacyWorkflowPath))
+        return paths.legacyWorkflowPath;
+    return paths.workflowPath;
+}
+async function removeLegacyWorkflowIfPresent(paths) {
+    if (paths.workflowPath === paths.legacyWorkflowPath)
+        return;
+    try {
+        await fs.rm(paths.legacyWorkflowPath, { force: true });
+    }
+    catch {
+        // best effort cleanup
+    }
+}
+async function listAgentIds(agentplaneDir) {
+    const ids = new Set();
+    const dir = path.join(agentplaneDir, "agents");
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const ent of entries) {
+            if (ent.isFile() && ent.name.endsWith(".json")) {
+                ids.add(ent.name.replace(/\.json$/i, ""));
+            }
+        }
+    }
+    catch {
+        // best effort
+    }
+    return ids;
+}
+export async function readWorkflowDocument(repoRoot, absPath) {
+    const paths = resolveWorkflowPaths(repoRoot);
+    const targetPath = absPath ?? (await resolveWorkflowReadPath(paths));
+    try {
+        const content = await fs.readFile(targetPath, "utf8");
+        const parsed = parseWorkflowMarkdown(content, targetPath);
+        return {
+            document: parsed.document,
+            diagnostics: parsed.diagnostics,
+            path: targetPath,
+        };
+    }
+    catch (error) {
+        return {
+            document: null,
+            diagnostics: [
+                {
+                    code: (await pathExists(targetPath)) ? "WF_READ_FAILED" : "WF_MISSING_FILE",
+                    severity: "ERROR",
+                    path: "file",
+                    message: `Cannot read workflow file ${targetPath}: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            path: targetPath,
+        };
+    }
+}
+export async function validateWorkflowAtPath(repoRoot, absPath) {
+    const read = await readWorkflowDocument(repoRoot, absPath);
+    const diagnostics = [...read.diagnostics];
+    if (!read.document) {
+        return {
+            ok: false,
+            diagnostics,
+        };
+    }
+    const loaded = await loadConfig(path.join(repoRoot, ".agentplane"));
+    const knownAgentIds = await listAgentIds(path.join(repoRoot, ".agentplane"));
+    const validated = validateWorkflowDocument(read.document, {
+        repoRoot,
+        knownAgentIds,
+        config: loaded.config,
+    });
+    diagnostics.push(...validated.diagnostics);
+    return {
+        ok: diagnostics.every((d) => d.severity !== "ERROR"),
+        diagnostics,
+    };
+}
+export async function validateWorkflowText(repoRoot, workflowText) {
+    const parsed = parseWorkflowMarkdown(workflowText);
+    const loaded = await loadConfig(path.join(repoRoot, ".agentplane"));
+    const knownAgentIds = await listAgentIds(path.join(repoRoot, ".agentplane"));
+    const validated = validateWorkflowDocument(parsed.document, {
+        repoRoot,
+        knownAgentIds,
+        config: loaded.config,
+    });
+    return {
+        ok: [...parsed.diagnostics, ...validated.diagnostics].every((d) => d.severity !== "ERROR"),
+        diagnostics: [...parsed.diagnostics, ...validated.diagnostics],
+    };
+}
+export async function publishWorkflowCandidate(repoRoot, candidateText) {
+    const paths = resolveWorkflowPaths(repoRoot);
+    const tempPath = `${paths.workflowPath}.tmp.${Date.now()}`;
+    const parsed = parseWorkflowMarkdown(candidateText, paths.workflowPath);
+    const configLoaded = await loadConfig(path.join(repoRoot, ".agentplane"));
+    const validation = validateWorkflowDocument(parsed.document, {
+        repoRoot,
+        knownAgentIds: await listAgentIds(path.join(repoRoot, ".agentplane")),
+        config: configLoaded.config,
+    });
+    const diagnostics = [...parsed.diagnostics, ...validation.diagnostics];
+    if (diagnostics.some((d) => d.severity === "ERROR")) {
+        emitWorkflowEvent({
+            event: "workflow_publish_failed",
+            code: "WF_PARSE_ERROR",
+            details: { reason: "validation failed before publish", diagnostics: diagnostics.length },
+        });
+        return { ok: false, diagnostics };
+    }
+    try {
+        await fs.mkdir(path.dirname(paths.workflowPath), { recursive: true });
+        await fs.mkdir(paths.workflowDir, { recursive: true });
+        await fs.writeFile(tempPath, candidateText, "utf8");
+        await fs.rename(tempPath, paths.workflowPath);
+        await removeLegacyWorkflowIfPresent(paths);
+        await fs.copyFile(paths.workflowPath, paths.lastKnownGoodPath);
+        emitWorkflowEvent({
+            event: "workflow_publish_completed",
+            details: { workflowPath: paths.workflowPath, lastKnownGoodPath: paths.lastKnownGoodPath },
+        });
+        return { ok: true, diagnostics };
+    }
+    catch (error) {
+        try {
+            await fs.rm(tempPath, { force: true });
+        }
+        catch {
+            // best effort cleanup
+        }
+        emitWorkflowEvent({
+            event: "workflow_publish_failed",
+            code: "WF_READ_FAILED",
+            details: { reason: error instanceof Error ? error.message : String(error) },
+        });
+        return {
+            ok: false,
+            diagnostics: [
+                ...diagnostics,
+                {
+                    code: "WF_READ_FAILED",
+                    severity: "ERROR",
+                    path: "file",
+                    message: `Failed to atomically publish workflow: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+        };
+    }
+}
+export async function restoreWorkflowFromLastKnownGood(repoRoot) {
+    const paths = resolveWorkflowPaths(repoRoot);
+    const tempPath = `${paths.workflowPath}.restore.tmp.${Date.now()}`;
+    let lkgText = "";
+    try {
+        lkgText = await fs.readFile(paths.lastKnownGoodPath, "utf8");
+    }
+    catch (error) {
+        emitWorkflowEvent({
+            event: "workflow_restore_failed",
+            code: "WF_MISSING_FILE",
+            details: { reason: error instanceof Error ? error.message : String(error) },
+        });
+        return {
+            ok: false,
+            diagnostics: [
+                {
+                    code: "WF_MISSING_FILE",
+                    severity: "ERROR",
+                    path: "file",
+                    message: `Missing last-known-good workflow snapshot at ${paths.lastKnownGoodPath}`,
+                },
+            ],
+        };
+    }
+    const parsed = parseWorkflowMarkdown(lkgText, paths.lastKnownGoodPath);
+    const configLoaded = await loadConfig(path.join(repoRoot, ".agentplane"));
+    const validated = validateWorkflowDocument(parsed.document, {
+        repoRoot,
+        knownAgentIds: await listAgentIds(path.join(repoRoot, ".agentplane")),
+        config: configLoaded.config,
+    });
+    const diagnostics = [...parsed.diagnostics, ...validated.diagnostics];
+    if (diagnostics.some((d) => d.severity === "ERROR")) {
+        emitWorkflowEvent({
+            event: "workflow_restore_failed",
+            code: "WF_PARSE_ERROR",
+            details: { reason: "last-known-good validation failed" },
+        });
+        return { ok: false, diagnostics };
+    }
+    try {
+        await fs.mkdir(path.dirname(paths.workflowPath), { recursive: true });
+        await fs.writeFile(tempPath, lkgText, "utf8");
+        await fs.rename(tempPath, paths.workflowPath);
+        await removeLegacyWorkflowIfPresent(paths);
+        emitWorkflowEvent({
+            event: "workflow_restore_completed",
+            details: { workflowPath: paths.workflowPath, from: paths.lastKnownGoodPath },
+        });
+        return { ok: true, diagnostics };
+    }
+    catch (error) {
+        try {
+            await fs.rm(tempPath, { force: true });
+        }
+        catch {
+            // best effort cleanup
+        }
+        emitWorkflowEvent({
+            event: "workflow_restore_failed",
+            code: "WF_READ_FAILED",
+            details: { reason: error instanceof Error ? error.message : String(error) },
+        });
+        return {
+            ok: false,
+            diagnostics: [
+                ...diagnostics,
+                {
+                    code: "WF_READ_FAILED",
+                    severity: "ERROR",
+                    path: "file",
+                    message: `Failed to restore workflow from snapshot: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+        };
+    }
+}

package/dist/workflow-runtime/fix.d.ts

@@ -0,0 +1,9 @@
+import type { WorkflowDiagnostic } from "./types.js";
+type WorkflowFixResult = {
+    changed: boolean;
+    text: string;
+    diagnostics: WorkflowDiagnostic[];
+};
+export declare function safeAutofixWorkflowText(text: string): WorkflowFixResult;
+export {};
+//# sourceMappingURL=fix.d.ts.map