agentplane 0.2.25 → 0.3.1

package/dist/commands/workflow-build.command.d.ts

@@ -0,0 +1,8 @@
+import type { CommandHandler, CommandSpec } from "../cli/spec/spec.js";
+export type WorkflowBuildParsed = {
+    validate: boolean;
+    dryRun: boolean;
+};
+export declare const workflowBuildSpec: CommandSpec<WorkflowBuildParsed>;
+export declare const runWorkflowBuild: CommandHandler<WorkflowBuildParsed>;
+//# sourceMappingURL=workflow-build.command.d.ts.map

package/dist/commands/workflow-build.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-build.command.d.ts","sourceRoot":"","sources":["../../src/commands/workflow-build.command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAWvE,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,mBAAmB,CAgC9D,CAAC;AAWF,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,mBAAmB,CA2EhE,CAAC"}

package/dist/commands/workflow-build.command.js

@@ -0,0 +1,103 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadConfig, resolveProject } from "@agentplaneorg/core";
+import { successMessage, warnMessage } from "../cli/output.js";
+import { DEFAULT_WORKFLOW_TEMPLATE, buildWorkflowFromTemplates, diagnosticsSummary, publishWorkflowCandidate, resolveWorkflowPaths, validateWorkflowText, } from "../workflow-runtime/index.js";
+export const workflowBuildSpec = {
+    id: ["workflow", "build"],
+    group: "Workflow",
+    summary: "Build WORKFLOW.md from template layers with strict rendering checks.",
+    options: [
+        {
+            kind: "boolean",
+            name: "validate",
+            default: false,
+            description: "Validate built workflow and fail on errors.",
+        },
+        {
+            kind: "boolean",
+            name: "dry-run",
+            default: false,
+            description: "Do not publish; print candidate and diagnostics only.",
+        },
+    ],
+    examples: [
+        {
+            cmd: "agentplane workflow build --validate --dry-run",
+            why: "Build and validate candidate workflow without publishing.",
+        },
+        {
+            cmd: "agentplane workflow build --validate",
+            why: "Build, validate, and atomically publish workflow.",
+        },
+    ],
+    parse: (raw) => ({
+        validate: raw.opts.validate === true,
+        dryRun: raw.opts["dry-run"] === true,
+    }),
+};
+async function maybeReadOverride(paths) {
+    const overridePath = path.join(paths.workflowDir, "template.override.md");
+    try {
+        return await fs.readFile(overridePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export const runWorkflowBuild = async (ctx, flags) => {
+    const resolved = await resolveProject({ cwd: ctx.cwd, rootOverride: ctx.rootOverride ?? null });
+    const configLoaded = await loadConfig(resolved.agentplaneDir);
+    const workflowPaths = resolveWorkflowPaths(resolved.gitRoot);
+    const configApprovals = configLoaded.config.agents?.approvals;
+    const runtimeContext = {
+        workflow: {
+            mode: configLoaded.config.workflow_mode,
+            version: 1,
+            approvals: {
+                require_plan: configApprovals?.require_plan ?? true,
+                require_verify: configApprovals?.require_verify ?? true,
+                require_network: configApprovals?.require_network ?? true,
+            },
+        },
+        runtime: {
+            repo_name: path.basename(resolved.gitRoot),
+            repo_root: resolved.gitRoot,
+            timestamp: new Date().toISOString(),
+        },
+    };
+    const overrideTemplate = await maybeReadOverride(workflowPaths);
+    const built = buildWorkflowFromTemplates({
+        baseTemplate: DEFAULT_WORKFLOW_TEMPLATE,
+        projectOverrideTemplate: overrideTemplate,
+        runtimeContext,
+    });
+    if (flags.dryRun) {
+        process.stdout.write(`${built.text}\n`);
+    }
+    let diagnostics = [...built.diagnostics];
+    if (flags.validate || flags.dryRun) {
+        const validation = await validateWorkflowText(resolved.gitRoot, built.text);
+        diagnostics = [...diagnostics, ...validation.diagnostics];
+    }
+    const hasError = diagnostics.some((d) => d.severity === "ERROR");
+    if (diagnostics.length > 0) {
+        process.stderr.write(`${warnMessage(`workflow diagnostics: ${diagnosticsSummary(diagnostics)}`)}\n`);
+        for (const diagnostic of diagnostics) {
+            process.stderr.write(`- [${diagnostic.severity}] ${diagnostic.code} ${diagnostic.path}: ${diagnostic.message}\n`);
+        }
+    }
+    if (flags.dryRun) {
+        return hasError ? 1 : 0;
+    }
+    const publish = await publishWorkflowCandidate(resolved.gitRoot, built.text);
+    if (!publish.ok) {
+        process.stderr.write(warnMessage("workflow publish failed") + "\n");
+        for (const diagnostic of publish.diagnostics) {
+            process.stderr.write(`- [${diagnostic.severity}] ${diagnostic.code} ${diagnostic.path}: ${diagnostic.message}\n`);
+        }
+        return 1;
+    }
+    process.stdout.write(successMessage("workflow build", undefined, `Published ${path.relative(resolved.gitRoot, workflowPaths.workflowPath)}`) + "\n");
+    return hasError && flags.validate ? 1 : 0;
+};

package/dist/commands/workflow-playbook.command.d.ts

@@ -0,0 +1,10 @@
+import { type CommandHandler, type CommandSpec } from "../cli/spec/spec.js";
+type WorkflowPlaybookParsed = Record<string, never>;
+export declare const workflowDebugSpec: CommandSpec<WorkflowPlaybookParsed>;
+export declare const workflowSyncSpec: CommandSpec<WorkflowPlaybookParsed>;
+export declare const workflowLandSpec: CommandSpec<WorkflowPlaybookParsed>;
+export declare const runWorkflowDebug: CommandHandler<WorkflowPlaybookParsed>;
+export declare const runWorkflowSync: CommandHandler<WorkflowPlaybookParsed>;
+export declare const runWorkflowLand: CommandHandler<WorkflowPlaybookParsed>;
+export {};
+//# sourceMappingURL=workflow-playbook.command.d.ts.map

package/dist/commands/workflow-playbook.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-playbook.command.d.ts","sourceRoot":"","sources":["../../src/commands/workflow-playbook.command.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAoC5E,KAAK,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AA0JpD,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,sBAAsB,CAMjE,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,sBAAsB,CAMhE,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,sBAAsB,CAMhE,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,sBAAsB,CAEnE,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,sBAAsB,CAElE,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,sBAAsB,CAElE,CAAC"}

package/dist/commands/workflow-playbook.command.js

@@ -0,0 +1,173 @@
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { atomicWriteFile, resolveProject } from "@agentplaneorg/core";
+import { mapCoreError } from "../cli/error-map.js";
+const execFileAsync = promisify(execFile);
+const AGENTPLANE_BIN = fileURLToPath(new URL("../../bin/agentplane.js", import.meta.url));
+const MAX_LOG_CHARS = 8000;
+function truncate(text) {
+    if (text.length <= MAX_LOG_CHARS)
+        return text;
+    const rest = text.length - MAX_LOG_CHARS;
+    return `${text.slice(0, MAX_LOG_CHARS)}\n...[truncated ${rest} chars]`;
+}
+function toSafeToken(value) {
+    return value.replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+}
+function buildEvidencePath(repoRoot, mode, startedAt) {
+    const token = toSafeToken(startedAt);
+    return path.join(repoRoot, ".agentplane", "workflows", "evidence", `${mode}-${token}.json`);
+}
+function buildPlaybookCommands(opts) {
+    const ap = (...args) => ({
+        kind: "agentplane",
+        args: [...args, "--root", opts.repoRoot],
+    });
+    if (opts.mode === "debug") {
+        return [
+            ap("preflight", "--json", "--mode", "quick"),
+            ap("doctor"),
+            { kind: "git", args: ["status", "--short", "--untracked-files=no"] },
+        ];
+    }
+    if (opts.mode === "sync") {
+        return [
+            ap("task", "list"),
+            ap("task", "export"),
+            { kind: "git", args: ["status", "--short", "--untracked-files=no"] },
+        ];
+    }
+    return [
+        ap("preflight", "--json", "--mode", "full"),
+        ap("doctor"),
+        { kind: "git", args: ["status", "--short", "--untracked-files=no"] },
+    ];
+}
+async function runWorkflowPlaybookCommand(opts) {
+    const startedMs = Date.now();
+    const startedAt = new Date(startedMs).toISOString();
+    let command = "";
+    let args = [];
+    if (opts.command.kind === "agentplane") {
+        command = process.execPath;
+        args = [AGENTPLANE_BIN, ...opts.command.args];
+    }
+    else {
+        command = "git";
+        args = [...opts.command.args];
+    }
+    let exitCode = 0;
+    let stdout = "";
+    let stderr = "";
+    try {
+        const result = await execFileAsync(command, args, {
+            cwd: opts.repoRoot,
+            env: {
+                ...process.env,
+                AGENTPLANE_NO_UPDATE_CHECK: process.env.AGENTPLANE_NO_UPDATE_CHECK ?? "1",
+            },
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        stdout = String(result.stdout ?? "");
+        stderr = String(result.stderr ?? "");
+    }
+    catch (err) {
+        const failed = err;
+        exitCode = typeof failed.code === "number" ? failed.code : 1;
+        stdout = typeof failed.stdout === "string" ? failed.stdout : "";
+        stderr = typeof failed.stderr === "string" ? failed.stderr : "";
+        if (!stderr && typeof failed.code === "string") {
+            stderr = failed.code;
+        }
+    }
+    const endedMs = Date.now();
+    return {
+        display: `${command} ${args.join(" ")}`.trim(),
+        started_at: startedAt,
+        ended_at: new Date(endedMs).toISOString(),
+        duration_ms: Math.max(0, endedMs - startedMs),
+        exit_code: exitCode,
+        stdout_tail: truncate(stdout),
+        stderr_tail: truncate(stderr),
+    };
+}
+async function runWorkflowPlaybook(opts) {
+    try {
+        const resolved = await resolveProject({
+            cwd: opts.cwd,
+            rootOverride: opts.rootOverride ?? null,
+        });
+        const startedAt = new Date().toISOString();
+        const evidencePath = buildEvidencePath(resolved.gitRoot, opts.mode, startedAt);
+        const commands = buildPlaybookCommands({ mode: opts.mode, repoRoot: resolved.gitRoot });
+        const results = [];
+        let failed = false;
+        for (const command of commands) {
+            const result = await runWorkflowPlaybookCommand({
+                command,
+                repoRoot: resolved.gitRoot,
+            });
+            results.push(result);
+            if (result.stdout_tail)
+                process.stdout.write(`${result.stdout_tail}\n`);
+            if (result.stderr_tail)
+                process.stderr.write(`${result.stderr_tail}\n`);
+            if (result.exit_code !== 0)
+                failed = true;
+        }
+        await mkdir(path.dirname(evidencePath), { recursive: true });
+        const evidence = {
+            schema_version: 1,
+            mode: opts.mode,
+            status: failed ? "failed" : "success",
+            started_at: startedAt,
+            ended_at: new Date().toISOString(),
+            repo_root: resolved.gitRoot,
+            evidence_path: evidencePath,
+            commands: results,
+        };
+        await atomicWriteFile(evidencePath, `${JSON.stringify(evidence, null, 2)}\n`);
+        process.stdout.write(`Evidence: ${path.relative(resolved.gitRoot, evidencePath)}\n`);
+        return failed ? 1 : 0;
+    }
+    catch (err) {
+        throw mapCoreError(err, {
+            command: `workflow ${opts.mode}`,
+            root: opts.rootOverride ?? null,
+        });
+    }
+}
+export const workflowDebugSpec = {
+    id: ["workflow", "debug"],
+    group: "Workflow",
+    summary: "Run built-in debug checks and capture workflow evidence.",
+    parse: () => ({}),
+    examples: [{ cmd: "agentplane workflow debug", why: "Collect debug readiness evidence." }],
+};
+export const workflowSyncSpec = {
+    id: ["workflow", "sync"],
+    group: "Workflow",
+    summary: "Run built-in sync checks and capture workflow evidence.",
+    parse: () => ({}),
+    examples: [{ cmd: "agentplane workflow sync", why: "Collect sync-state evidence." }],
+};
+export const workflowLandSpec = {
+    id: ["workflow", "land"],
+    group: "Workflow",
+    summary: "Run built-in pre-land checks and capture workflow evidence.",
+    parse: () => ({}),
+    examples: [{ cmd: "agentplane workflow land", why: "Collect land-readiness evidence." }],
+};
+export const runWorkflowDebug = async (ctx) => {
+    return await runWorkflowPlaybook({ cwd: ctx.cwd, rootOverride: ctx.rootOverride, mode: "debug" });
+};
+export const runWorkflowSync = async (ctx) => {
+    return await runWorkflowPlaybook({ cwd: ctx.cwd, rootOverride: ctx.rootOverride, mode: "sync" });
+};
+export const runWorkflowLand = async (ctx) => {
+    return await runWorkflowPlaybook({ cwd: ctx.cwd, rootOverride: ctx.rootOverride, mode: "land" });
+};

package/dist/commands/workflow-restore.command.d.ts

@@ -0,0 +1,5 @@
+import type { CommandHandler, CommandSpec } from "../cli/spec/spec.js";
+export type WorkflowRestoreParsed = Record<string, never>;
+export declare const workflowRestoreSpec: CommandSpec<WorkflowRestoreParsed>;
+export declare const runWorkflowRestore: CommandHandler<WorkflowRestoreParsed>;
+//# sourceMappingURL=workflow-restore.command.d.ts.map

package/dist/commands/workflow-restore.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-restore.command.d.ts","sourceRoot":"","sources":["../../src/commands/workflow-restore.command.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAOvE,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAE1D,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,qBAAqB,CAWlE,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,qBAAqB,CAuBpE,CAAC"}

package/dist/commands/workflow-restore.command.js

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { resolveProject } from "@agentplaneorg/core";
+import { successMessage, warnMessage } from "../cli/output.js";
+import { resolveWorkflowPaths, restoreWorkflowFromLastKnownGood, } from "../workflow-runtime/index.js";
+export const workflowRestoreSpec = {
+    id: ["workflow", "restore"],
+    group: "Workflow",
+    summary: "Restore WORKFLOW.md from last-known-good snapshot.",
+    parse: () => ({}),
+    examples: [
+        {
+            cmd: "agentplane workflow restore",
+            why: "Restore active workflow from .agentplane/workflows/last-known-good.md.",
+        },
+    ],
+};
+export const runWorkflowRestore = async (ctx) => {
+    const resolved = await resolveProject({ cwd: ctx.cwd, rootOverride: ctx.rootOverride ?? null });
+    const workflowPaths = resolveWorkflowPaths(resolved.gitRoot);
+    const result = await restoreWorkflowFromLastKnownGood(resolved.gitRoot);
+    if (!result.ok) {
+        process.stderr.write(warnMessage("workflow restore failed") + "\n");
+        for (const diagnostic of result.diagnostics) {
+            process.stderr.write(`- [${diagnostic.severity}] ${diagnostic.code} ${diagnostic.path}: ${diagnostic.message}\n`);
+        }
+        return 1;
+    }
+    process.stdout.write(successMessage("workflow restore", undefined, `Restored ${path.relative(resolved.gitRoot, workflowPaths.workflowPath)} from snapshot.`) + "\n");
+    return 0;
+};

package/dist/commands/workflow.command.d.ts

@@ -0,0 +1,6 @@
+import type { CommandHandler, CommandSpec } from "../cli/spec/spec.js";
+type WorkflowParsed = Record<string, never>;
+export declare const workflowSpec: CommandSpec<WorkflowParsed>;
+export declare const runWorkflow: CommandHandler<WorkflowParsed>;
+export {};
+//# sourceMappingURL=workflow.command.d.ts.map

package/dist/commands/workflow.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.command.d.ts","sourceRoot":"","sources":["../../src/commands/workflow.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAInF,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAI5C,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,cAAc,CAyBpD,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,cAAc,CAMtD,CAAC"}

package/dist/commands/workflow.command.js

@@ -0,0 +1,36 @@
+import { usageError } from "../cli/spec/errors.js";
+import { suggestOne } from "../cli/spec/suggest.js";
+const WORKFLOW_SUBCOMMANDS = ["build", "restore", "debug", "sync", "land"];
+export const workflowSpec = {
+    id: ["workflow"],
+    group: "Workflow",
+    summary: "Workflow contract commands.",
+    synopsis: ["agentplane workflow <subcommand> [options]"],
+    args: [{ name: "subcommand", required: false, variadic: true, valueHint: "<subcommand>" }],
+    parse: () => ({}),
+    validateRaw: (raw) => {
+        const rest = Array.isArray(raw.args.subcommand) ? raw.args.subcommand : [];
+        const sub = rest[0];
+        if (!sub) {
+            throw usageError({
+                spec: workflowSpec,
+                command: "workflow",
+                message: "Missing workflow subcommand.",
+            });
+        }
+        const suggestion = suggestOne(String(sub), [...WORKFLOW_SUBCOMMANDS]);
+        const suffix = suggestion ? ` Did you mean: ${suggestion}?` : "";
+        throw usageError({
+            spec: workflowSpec,
+            command: "workflow",
+            message: `Unknown workflow subcommand: ${String(sub)}.${suffix}`,
+        });
+    },
+};
+export const runWorkflow = (_ctx) => {
+    throw usageError({
+        spec: workflowSpec,
+        command: "workflow",
+        message: "Missing workflow subcommand.",
+    });
+};

package/dist/harness/dynamic-tool-contract.d.ts

@@ -0,0 +1,29 @@
+export type DynamicToolInputSchema = {
+    required?: string[];
+    properties?: Record<string, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+    }>;
+    additionalProperties?: boolean;
+};
+export type DynamicToolSpec = {
+    name: string;
+    description: string;
+    inputSchema: DynamicToolInputSchema;
+};
+export type DynamicToolRegistry = Record<string, DynamicToolSpec>;
+export type DynamicToolResponse = {
+    success: boolean;
+    code: "TOOL_OK" | "TOOL_UNSUPPORTED" | "TOOL_INVALID_ARGS" | "TOOL_EXECUTION_FAILED";
+    data?: unknown;
+    error?: {
+        message: string;
+        reason?: string;
+    };
+};
+export declare function executeDynamicTool(opts: {
+    registry: DynamicToolRegistry;
+    handlers: Record<string, (args: Record<string, unknown>) => unknown>;
+    toolName: string;
+    args: unknown;
+}): Promise<DynamicToolResponse>;
+//# sourceMappingURL=dynamic-tool-contract.d.ts.map

package/dist/harness/dynamic-tool-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-tool-contract.d.ts","sourceRoot":"","sources":["../../src/harness/dynamic-tool-contract.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;KAAE,CAAC,CAAC;IAC5F,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,sBAAsB,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AAElE,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,SAAS,GAAG,kBAAkB,GAAG,mBAAmB,GAAG,uBAAuB,CAAC;IACrF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH,CAAC;AA+CF,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAAC;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAiD/B"}

package/dist/harness/dynamic-tool-contract.js

@@ -0,0 +1,86 @@
+function isObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function matchesType(value, type) {
+    if (type === "array")
+        return Array.isArray(value);
+    if (type === "object")
+        return isObject(value);
+    return typeof value === type;
+}
+function validateInput(schema, args) {
+    if (!isObject(args)) {
+        return { ok: false, message: "Tool arguments must be an object." };
+    }
+    const required = schema.required ?? [];
+    for (const key of required) {
+        if (!(key in args)) {
+            return { ok: false, message: `Missing required field: ${key}` };
+        }
+    }
+    const properties = schema.properties ?? {};
+    for (const [key, value] of Object.entries(args)) {
+        const propSchema = properties[key];
+        if (!propSchema) {
+            if (schema.additionalProperties === false) {
+                return { ok: false, message: `Unknown argument: ${key}` };
+            }
+            continue;
+        }
+        if (!matchesType(value, propSchema.type)) {
+            return {
+                ok: false,
+                message: `Invalid type for ${key}: expected ${propSchema.type}`,
+            };
+        }
+    }
+    return { ok: true };
+}
+export async function executeDynamicTool(opts) {
+    const spec = opts.registry[opts.toolName];
+    if (!spec) {
+        return {
+            success: false,
+            code: "TOOL_UNSUPPORTED",
+            error: {
+                message: `Unsupported tool: ${opts.toolName}`,
+            },
+        };
+    }
+    const valid = validateInput(spec.inputSchema, opts.args);
+    if (!valid.ok) {
+        return {
+            success: false,
+            code: "TOOL_INVALID_ARGS",
+            error: {
+                message: valid.message ?? "Invalid tool arguments.",
+            },
+        };
+    }
+    const handler = opts.handlers[opts.toolName];
+    if (!handler) {
+        return {
+            success: false,
+            code: "TOOL_UNSUPPORTED",
+            error: { message: `No handler registered for tool: ${opts.toolName}` },
+        };
+    }
+    try {
+        const data = await handler(opts.args);
+        return {
+            success: true,
+            code: "TOOL_OK",
+            data,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            code: "TOOL_EXECUTION_FAILED",
+            error: {
+                message: "Tool execution failed.",
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+}

package/dist/harness/hooks-lifecycle.d.ts

@@ -0,0 +1,27 @@
+export type HookName = "after_create" | "before_run" | "after_run" | "before_remove";
+export type HookPolicy = {
+    command?: string;
+    timeoutMs: number;
+    blocking: boolean;
+};
+export type HookResult = {
+    ok: boolean;
+    hook: HookName;
+    exitCode: number | null;
+    timedOut: boolean;
+    output: string;
+};
+export declare function runLifecycleHook(opts: {
+    hook: HookName;
+    policy: HookPolicy;
+    cwd: string;
+}): Promise<HookResult>;
+export declare function runLifecycleHooks(opts: {
+    cwd: string;
+    hooks: Partial<Record<HookName, HookPolicy>>;
+    order: HookName[];
+}): Promise<{
+    ok: boolean;
+    results: HookResult[];
+}>;
+//# sourceMappingURL=hooks-lifecycle.d.ts.map

package/dist/harness/hooks-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks-lifecycle.d.ts","sourceRoot":"","sources":["../../src/harness/hooks-lifecycle.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,eAAe,CAAC;AAErF,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,IAAI,EAAE;IAC3C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,UAAU,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,UAAU,CAAC,CAyDtB;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;IAC7C,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC,CAclD"}

package/dist/harness/hooks-lifecycle.js

@@ -0,0 +1,67 @@
+import { spawn } from "node:child_process";
+export async function runLifecycleHook(opts) {
+    if (!opts.policy.command || opts.policy.command.trim().length === 0) {
+        return {
+            ok: true,
+            hook: opts.hook,
+            exitCode: 0,
+            timedOut: false,
+            output: "",
+        };
+    }
+    return await new Promise((resolve) => {
+        const child = spawn("sh", ["-lc", opts.policy.command], {
+            cwd: opts.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        let finished = false;
+        const timer = setTimeout(() => {
+            if (finished)
+                return;
+            finished = true;
+            child.kill("SIGKILL");
+            resolve({
+                ok: !opts.policy.blocking,
+                hook: opts.hook,
+                exitCode: null,
+                timedOut: true,
+                output,
+            });
+        }, Math.max(1, opts.policy.timeoutMs));
+        child.stdout.on("data", (chunk) => {
+            output += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            output += String(chunk);
+        });
+        child.on("close", (code) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            const success = code === 0;
+            resolve({
+                ok: success || !opts.policy.blocking,
+                hook: opts.hook,
+                exitCode: code,
+                timedOut: false,
+                output,
+            });
+        });
+    });
+}
+export async function runLifecycleHooks(opts) {
+    const results = [];
+    for (const hook of opts.order) {
+        const policy = opts.hooks[hook];
+        if (!policy)
+            continue;
+        const result = await runLifecycleHook({ hook, policy, cwd: opts.cwd });
+        results.push(result);
+        if (!result.ok && policy.blocking) {
+            return { ok: false, results };
+        }
+    }
+    return { ok: true, results };
+}

package/dist/harness/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./state-machine.js";
+export * from "./scheduler.js";
+export * from "./reconcile.js";
+export * from "./retry-policy.js";
+export * from "./workspace-safety.js";
+export * from "./hooks-lifecycle.js";
+export * from "./dynamic-tool-contract.js";
+export * from "./token-accounting.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/harness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/harness/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC"}

package/dist/harness/index.js

@@ -0,0 +1,8 @@
+export * from "./state-machine.js";
+export * from "./scheduler.js";
+export * from "./reconcile.js";
+export * from "./retry-policy.js";
+export * from "./workspace-safety.js";
+export * from "./hooks-lifecycle.js";
+export * from "./dynamic-tool-contract.js";
+export * from "./token-accounting.js";