agentplane 0.2.24 → 0.2.26

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";

package/dist/harness/reconcile.d.ts

@@ -0,0 +1,37 @@
+import type { OrchestrationState } from "./state-machine.js";
+export type ReconcileRunningEntry = {
+    issueId: string;
+    issueIdentifier: string;
+    state: string;
+    orchestrationState: OrchestrationState;
+    startedAt: Date;
+    lastActivityAt: Date;
+};
+export type ReconcileObservedIssue = {
+    id: string;
+    state: string;
+    assignedToWorker: boolean;
+};
+export type ReconcileConfig = {
+    activeStates: string[];
+    terminalStates: string[];
+    stallTimeoutMs: number;
+};
+export type ReconcileAction = {
+    type: "stop_running";
+    issueId: string;
+    reason: "terminal" | "non_active" | "not_routed";
+} | {
+    type: "restart_stalled";
+    issueId: string;
+    elapsedMs: number;
+} | {
+    type: "keep_running";
+    issueId: string;
+};
+export type ReconcileResult = {
+    nextRunning: ReconcileRunningEntry[];
+    actions: ReconcileAction[];
+};
+export declare function reconcileFirst(running: readonly ReconcileRunningEntry[], observed: readonly ReconcileObservedIssue[], config: ReconcileConfig, now: Date): ReconcileResult;
+//# sourceMappingURL=reconcile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/harness/reconcile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,SAAS,EAAE,IAAI,CAAC;IAChB,cAAc,EAAE,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,YAAY,GAAG,YAAY,CAAA;CAAE,GAC3F;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,qBAAqB,EAAE,CAAC;IACrC,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAWF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,qBAAqB,EAAE,EACzC,QAAQ,EAAE,SAAS,sBAAsB,EAAE,EAC3C,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,IAAI,GACR,eAAe,CA0CjB"}

package/dist/harness/reconcile.js

@@ -0,0 +1,42 @@
+function normalizeState(value) {
+    return value.trim().toLowerCase();
+}
+function isStateInSet(value, set) {
+    const normalized = normalizeState(value);
+    return set.some((item) => normalizeState(item) === normalized);
+}
+export function reconcileFirst(running, observed, config, now) {
+    const observedById = new Map(observed.map((issue) => [issue.id, issue]));
+    const nextRunning = [];
+    const actions = [];
+    for (const entry of running) {
+        const observedIssue = observedById.get(entry.issueId);
+        if (!observedIssue) {
+            actions.push({ type: "stop_running", issueId: entry.issueId, reason: "non_active" });
+            continue;
+        }
+        if (isStateInSet(observedIssue.state, config.terminalStates)) {
+            actions.push({ type: "stop_running", issueId: entry.issueId, reason: "terminal" });
+            continue;
+        }
+        if (!observedIssue.assignedToWorker) {
+            actions.push({ type: "stop_running", issueId: entry.issueId, reason: "not_routed" });
+            continue;
+        }
+        if (!isStateInSet(observedIssue.state, config.activeStates)) {
+            actions.push({ type: "stop_running", issueId: entry.issueId, reason: "non_active" });
+            continue;
+        }
+        const elapsedMs = Math.max(0, now.getTime() - entry.lastActivityAt.getTime());
+        if (config.stallTimeoutMs > 0 && elapsedMs > config.stallTimeoutMs) {
+            actions.push({ type: "restart_stalled", issueId: entry.issueId, elapsedMs });
+            continue;
+        }
+        actions.push({ type: "keep_running", issueId: entry.issueId });
+        nextRunning.push({ ...entry, state: observedIssue.state });
+    }
+    return {
+        nextRunning,
+        actions,
+    };
+}

package/dist/harness/retry-policy.d.ts

@@ -0,0 +1,31 @@
+export type RetryReasonCode = "continuation_needed" | "worker_exit_abnormal" | "worker_spawn_failed" | "stalled_timeout" | "poll_failed" | "no_slots" | "reconcile_conflict";
+export type RetryDelayType = "continuation" | "failure";
+export type RetryPolicy = {
+    continuationDelayMs: number;
+    failureBaseDelayMs: number;
+    maxBackoffMs: number;
+    maxAttempts: number;
+};
+export type RetryEntry = {
+    issueId: string;
+    attempt: number;
+    dueAtMs: number;
+    reasonCode: RetryReasonCode;
+    reasonMessage?: string;
+    delayType: RetryDelayType;
+};
+export declare function computeRetryDelayMs(attempt: number, delayType: RetryDelayType, policy?: RetryPolicy): number;
+export declare function scheduleRetryEntry(opts: {
+    issueId: string;
+    attempt: number;
+    reasonCode: RetryReasonCode;
+    reasonMessage?: string;
+    delayType: RetryDelayType;
+    nowMs: number;
+    policy?: RetryPolicy;
+}): RetryEntry;
+export declare function canRetry(attempt: number, policy?: RetryPolicy): {
+    allowed: boolean;
+    terminal: boolean;
+};
+//# sourceMappingURL=retry-policy.d.ts.map

package/dist/harness/retry-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-policy.d.ts","sourceRoot":"","sources":["../../src/harness/retry-policy.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GACvB,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,GACrB,iBAAiB,GACjB,aAAa,GACb,UAAU,GACV,oBAAoB,CAAC;AAEzB,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,SAAS,CAAC;AAExD,MAAM,MAAM,WAAW,GAAG;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,eAAe,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,cAAc,CAAC;CAC3B,CAAC;AASF,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,cAAc,EACzB,MAAM,GAAE,WAA4B,GACnC,MAAM,CAOR;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,eAAe,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,cAAc,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GAAG,UAAU,CAYb;AAED,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,WAA4B,GACnC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAKzC"}

package/dist/harness/retry-policy.js

@@ -0,0 +1,33 @@
+const DEFAULT_POLICY = {
+    continuationDelayMs: 1000,
+    failureBaseDelayMs: 10_000,
+    maxBackoffMs: 300_000,
+    maxAttempts: 5,
+};
+export function computeRetryDelayMs(attempt, delayType, policy = DEFAULT_POLICY) {
+    if (delayType === "continuation" && attempt <= 1) {
+        return policy.continuationDelayMs;
+    }
+    const power = Math.max(0, Math.min(attempt - 1, 10));
+    const delayed = policy.failureBaseDelayMs * 2 ** power;
+    return Math.min(delayed, policy.maxBackoffMs);
+}
+export function scheduleRetryEntry(opts) {
+    const policy = opts.policy ?? DEFAULT_POLICY;
+    const safeAttempt = Math.max(1, opts.attempt);
+    const delayMs = computeRetryDelayMs(safeAttempt, opts.delayType, policy);
+    return {
+        issueId: opts.issueId,
+        attempt: safeAttempt,
+        dueAtMs: opts.nowMs + delayMs,
+        reasonCode: opts.reasonCode,
+        reasonMessage: opts.reasonMessage,
+        delayType: opts.delayType,
+    };
+}
+export function canRetry(attempt, policy = DEFAULT_POLICY) {
+    if (attempt < policy.maxAttempts) {
+        return { allowed: true, terminal: false };
+    }
+    return { allowed: false, terminal: true };
+}

package/dist/harness/scheduler.d.ts

@@ -0,0 +1,18 @@
+export type SchedulerIssue = {
+    id: string;
+    state: string;
+    priority?: number | null;
+    createdAt?: string | null;
+};
+export type SchedulerEntry = {
+    issue: SchedulerIssue;
+    workerId: string;
+};
+export type SchedulerLimits = {
+    maxConcurrent: number;
+    maxConcurrentByState?: Record<string, number>;
+};
+export declare function sortIssuesForDispatch(issues: readonly SchedulerIssue[]): SchedulerIssue[];
+export declare function canDispatchIssue(issue: SchedulerIssue, running: readonly SchedulerEntry[], limits: SchedulerLimits): boolean;
+export declare function planDispatch(candidates: readonly SchedulerIssue[], running: readonly SchedulerEntry[], limits: SchedulerLimits): SchedulerIssue[];
+//# sourceMappingURL=scheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/harness/scheduler.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,cAAc,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/C,CAAC;AAoBF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,cAAc,EAAE,CAYzF;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,MAAM,EAAE,eAAe,GACtB,OAAO,CAaT;AAED,wBAAgB,YAAY,CAC1B,UAAU,EAAE,SAAS,cAAc,EAAE,EACrC,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,MAAM,EAAE,eAAe,GACtB,cAAc,EAAE,CAYlB"}

package/dist/harness/scheduler.js

@@ -0,0 +1,55 @@
+function normalizeState(value) {
+    return value.trim().toLowerCase();
+}
+function createdAtMicros(value) {
+    if (!value)
+        return Number.MAX_SAFE_INTEGER;
+    const parsed = Date.parse(value);
+    if (Number.isNaN(parsed))
+        return Number.MAX_SAFE_INTEGER;
+    return parsed * 1000;
+}
+function priorityRank(priority) {
+    if (typeof priority !== "number")
+        return 5;
+    if (!Number.isInteger(priority))
+        return 5;
+    if (priority < 1 || priority > 4)
+        return 5;
+    return priority;
+}
+export function sortIssuesForDispatch(issues) {
+    return issues.toSorted((a, b) => {
+        const aPriority = priorityRank(a.priority);
+        const bPriority = priorityRank(b.priority);
+        if (aPriority !== bPriority)
+            return aPriority - bPriority;
+        const aCreated = createdAtMicros(a.createdAt);
+        const bCreated = createdAtMicros(b.createdAt);
+        if (aCreated !== bCreated)
+            return aCreated - bCreated;
+        return a.id.localeCompare(b.id);
+    });
+}
+export function canDispatchIssue(issue, running, limits) {
+    const totalRunning = running.length;
+    if (totalRunning >= limits.maxConcurrent)
+        return false;
+    const stateKey = normalizeState(issue.state);
+    const stateLimitRaw = limits.maxConcurrentByState?.[stateKey];
+    const stateLimit = typeof stateLimitRaw === "number" && stateLimitRaw > 0 ? stateLimitRaw : limits.maxConcurrent;
+    const stateUsed = running.filter((entry) => normalizeState(entry.issue.state) === stateKey).length;
+    return stateUsed < stateLimit;
+}
+export function planDispatch(candidates, running, limits) {
+    const ordered = sortIssuesForDispatch(candidates);
+    const accepted = [];
+    const shadowRunning = [...running];
+    for (const issue of ordered) {
+        if (!canDispatchIssue(issue, shadowRunning, limits))
+            continue;
+        accepted.push(issue);
+        shadowRunning.push({ issue, workerId: `planned:${issue.id}` });
+    }
+    return accepted;
+}

package/dist/harness/state-machine.d.ts

@@ -0,0 +1,17 @@
+export type OrchestrationState = "unclaimed" | "claimed" | "running" | "retry_queued" | "released";
+export type OrchestrationEvent = "claim" | "start" | "queue_retry" | "release" | "mark_released" | "reset";
+export type TransitionResult = {
+    ok: true;
+    next: OrchestrationState;
+} | {
+    ok: false;
+    code: "ORCH_INVALID_TRANSITION";
+    message: string;
+    current: OrchestrationState;
+    event: OrchestrationEvent;
+};
+export declare function transitionOrchestrationState(current: OrchestrationState, event: OrchestrationEvent, opts?: {
+    strict?: boolean;
+}): TransitionResult;
+export declare function assertTransitionOrThrow(current: OrchestrationState, event: OrchestrationEvent): OrchestrationState;
+//# sourceMappingURL=state-machine.d.ts.map

package/dist/harness/state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.d.ts","sourceRoot":"","sources":["../../src/harness/state-machine.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,cAAc,GAAG,UAAU,CAAC;AAEnG,MAAM,MAAM,kBAAkB,GAC1B,OAAO,GACP,OAAO,GACP,aAAa,GACb,SAAS,GACT,eAAe,GACf,OAAO,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GACtC;IACE,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,KAAK,EAAE,kBAAkB,CAAC;CAC3B,CAAC;AAqDN,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,kBAAkB,EACzB,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAC1B,gBAAgB,CAalB;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,kBAAkB,GACxB,kBAAkB,CAMpB"}

package/dist/harness/state-machine.js

@@ -0,0 +1,70 @@
+const TRANSITIONS = {
+    unclaimed: {
+        claim: "claimed",
+        start: "unclaimed",
+        queue_retry: "unclaimed",
+        release: "released",
+        mark_released: "released",
+        reset: "unclaimed",
+    },
+    claimed: {
+        claim: "claimed",
+        start: "running",
+        queue_retry: "retry_queued",
+        release: "released",
+        mark_released: "released",
+        reset: "unclaimed",
+    },
+    running: {
+        claim: "running",
+        start: "running",
+        queue_retry: "retry_queued",
+        release: "released",
+        mark_released: "released",
+        reset: "unclaimed",
+    },
+    retry_queued: {
+        claim: "claimed",
+        start: "running",
+        queue_retry: "retry_queued",
+        release: "released",
+        mark_released: "released",
+        reset: "unclaimed",
+    },
+    released: {
+        claim: "claimed",
+        start: "released",
+        queue_retry: "released",
+        release: "released",
+        mark_released: "released",
+        reset: "unclaimed",
+    },
+};
+const STRICT_ALLOWED = {
+    unclaimed: ["claim", "mark_released", "reset"],
+    claimed: ["start", "queue_retry", "release", "reset"],
+    running: ["queue_retry", "release", "reset"],
+    retry_queued: ["claim", "start", "release", "reset"],
+    released: ["claim", "reset"],
+};
+export function transitionOrchestrationState(current, event, opts) {
+    const strict = opts?.strict ?? true;
+    if (strict && !STRICT_ALLOWED[current].includes(event)) {
+        return {
+            ok: false,
+            code: "ORCH_INVALID_TRANSITION",
+            message: `Invalid transition: ${current} --${event}--> ?`,
+            current,
+            event,
+        };
+    }
+    const next = TRANSITIONS[current][event];
+    return { ok: true, next };
+}
+export function assertTransitionOrThrow(current, event) {
+    const result = transitionOrchestrationState(current, event, { strict: true });
+    if (!result.ok) {
+        throw new Error(`${result.code}: ${result.message}`);
+    }
+    return result.next;
+}