@atom-workflow-agent/contracts 0.1.0

package/dist/planner/planner-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-validation.d.ts","sourceRoot":"","sources":["../../src/planner/planner-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,0FAA0F;AAC1F,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0CnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/planner/planner-validation.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { WorkflowAtomReferenceSchema } from "../workflows/spec.js";
+import { WorkflowValidationErrorSchema } from "../workflows/validation.js";
+import { PlannerDraftSchema } from "./planner-draft.js";
+import { CapabilityCoverageResultSchema } from "./planning-capability.js";
+import { PlanningWorkspaceSnapshotSchema } from "./planning-workspace.js";
+const HashSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+/** Durable state for capability preflight followed by transactional Workspace editing. */
+export const PlanningCheckpointSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    phase: z.enum(["capability-coverage", "workspace", "blocked_missing_atom", "blocked_missing_input", "completed"]),
+    catalogIndexHash: HashSchema,
+    selectedAtomKeys: z.array(WorkflowAtomReferenceSchema),
+    planningCatalogHash: HashSchema.optional(),
+    capabilityCoverage: CapabilityCoverageResultSchema.optional(),
+    workspaceSnapshot: PlanningWorkspaceSnapshotSchema.optional(),
+    planningTurnsConsumed: z.number().int().nonnegative(),
+    maxPlanningTurns: z.number().int().min(1).max(256),
+    lastValidationErrors: z.array(WorkflowValidationErrorSchema),
+    lastSubmittedRequestId: z.string().trim().min(1).optional(),
+    acceptedPlannerDraft: PlannerDraftSchema.optional(),
+}).strict().superRefine((checkpoint, context) => {
+    if (checkpoint.planningTurnsConsumed > checkpoint.maxPlanningTurns) {
+        context.addIssue({
+            code: "custom",
+            path: ["planningTurnsConsumed"],
+            message: "Consumed Planning turns cannot exceed maxPlanningTurns",
+        });
+    }
+    if (["workspace", "completed"].includes(checkpoint.phase) && checkpoint.selectedAtomKeys.length === 0) {
+        context.addIssue({
+            code: "custom",
+            path: ["selectedAtomKeys"],
+            message: "Workspace and completed phases require a selected Atom set",
+        });
+    }
+    if (checkpoint.phase === "completed" && !checkpoint.acceptedPlannerDraft) {
+        context.addIssue({
+            code: "custom",
+            path: ["acceptedPlannerDraft"],
+            message: "Completed Planning requires an accepted PlannerDraft",
+        });
+    }
+    if (["workspace", "completed", "blocked_missing_input"].includes(checkpoint.phase) && !checkpoint.workspaceSnapshot) {
+        context.addIssue({
+            code: "custom",
+            path: ["workspaceSnapshot"],
+            message: "Workspace phases require a durable Planning Workspace snapshot",
+        });
+    }
+});
+//# sourceMappingURL=planner-validation.js.map

package/dist/planner/planner-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-validation.js","sourceRoot":"","sources":["../../src/planner/planner-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAE1E,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;AAE7D,0FAA0F;AAC1F,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IAC/B,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,qBAAqB,EAAE,WAAW,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,WAAW,CAAC,CAAC;IACjH,gBAAgB,EAAE,UAAU;IAC5B,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,2BAA2B,CAAC;IACtD,mBAAmB,EAAE,UAAU,CAAC,QAAQ,EAAE;IAC1C,kBAAkB,EAAE,8BAA8B,CAAC,QAAQ,EAAE;IAC7D,iBAAiB,EAAE,+BAA+B,CAAC,QAAQ,EAAE;IAC7D,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACrD,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAClD,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,6BAA6B,CAAC;IAC5D,sBAAsB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAC3D,oBAAoB,EAAE,kBAAkB,CAAC,QAAQ,EAAE;CACpD,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,CAAC,UAAU,EAAE,OAAO,EAAE,EAAE;IAC9C,IAAI,UAAU,CAAC,qBAAqB,GAAG,UAAU,CAAC,gBAAgB,EAAE,CAAC;QACnE,OAAO,CAAC,QAAQ,CAAC;YACf,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,uBAAuB,CAAC;YAC/B,OAAO,EAAE,wDAAwD;SAClE,CAAC,CAAC;IACL,CAAC;IACD,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtG,OAAO,CAAC,QAAQ,CAAC;YACf,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,kBAAkB,CAAC;YAC1B,OAAO,EAAE,4DAA4D;SACtE,CAAC,CAAC;IACL,CAAC;IACD,IAAI,UAAU,CAAC,KAAK,KAAK,WAAW,IAAI,CAAC,UAAU,CAAC,oBAAoB,EAAE,CAAC;QACzE,OAAO,CAAC,QAAQ,CAAC;YACf,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,sBAAsB,CAAC;YAC9B,OAAO,EAAE,sDAAsD;SAChE,CAAC,CAAC;IACL,CAAC;IACD,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,uBAAuB,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,CAAC;QACpH,OAAO,CAAC,QAAQ,CAAC;YACf,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,mBAAmB,CAAC;YAC3B,OAAO,EAAE,gEAAgE;SAC1E,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/planner/planner.d.ts

@@ -0,0 +1,456 @@
+import { z } from "zod";
+export declare const PlannerAtomCatalogEntrySchema: z.ZodObject<{
+    key: z.ZodString;
+    descriptor: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0">;
+        hash: z.ZodString;
+        key: z.ZodString;
+        title: z.ZodString;
+        purpose: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PlannerAtomCatalogEntry = z.infer<typeof PlannerAtomCatalogEntrySchema>;
+export declare const PlannerAtomCatalogSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    hash: z.ZodString;
+    atoms: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        descriptor: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"1.0">;
+            hash: z.ZodString;
+            key: z.ZodString;
+            title: z.ZodString;
+            purpose: z.ZodString;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            outputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PlannerAtomCatalog = z.infer<typeof PlannerAtomCatalogSchema>;
+export declare const PlannerInputSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    requestId: z.ZodString;
+    goal: z.ZodString;
+    workflowInputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>>;
+    context: z.ZodDefault<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    atomCatalog: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0">;
+        hash: z.ZodString;
+        atoms: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            descriptor: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"1.0">;
+                hash: z.ZodString;
+                key: z.ZodString;
+                title: z.ZodString;
+                purpose: z.ZodString;
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+                outputSchema: z.ZodRecord<z.ZodString, z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    runtimePolicy: z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodLiteral<"1.1">>;
+        maxNodes: z.ZodDefault<z.ZodNumber>;
+        maxDependenciesPerNode: z.ZodDefault<z.ZodNumber>;
+        maxMapItems: z.ZodDefault<z.ZodNumber>;
+        maxEdgeTraversals: z.ZodDefault<z.ZodNumber>;
+        maxWorkflowTransitions: z.ZodDefault<z.ZodNumber>;
+        maxNodeActivations: z.ZodDefault<z.ZodNumber>;
+        maxLifecycleTicks: z.ZodDefault<z.ZodNumber>;
+        maxLifecycleTickTimeoutMs: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        maxAttemptDurationMs: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        maxRetryAttempts: z.ZodDefault<z.ZodNumber>;
+        maxRetryDelayMs: z.ZodDefault<z.ZodNumber>;
+        maxCacheTtlMs: z.ZodDefault<z.ZodNumber>;
+        allowDeprecatedAtoms: z.ZodDefault<z.ZodBoolean>;
+        allowCacheEnableOverride: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+    previousValidationErrors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            WORKFLOW_JSON_INVALID: "WORKFLOW_JSON_INVALID";
+            WORKFLOW_SCHEMA_INVALID: "WORKFLOW_SCHEMA_INVALID";
+            RUNTIME_POLICY_INVALID: "RUNTIME_POLICY_INVALID";
+            ATOM_CATALOG_INVALID: "ATOM_CATALOG_INVALID";
+            ATOM_CATALOG_DUPLICATE: "ATOM_CATALOG_DUPLICATE";
+            NODE_LIMIT_EXCEEDED: "NODE_LIMIT_EXCEEDED";
+            DEPENDENCY_LIMIT_EXCEEDED: "DEPENDENCY_LIMIT_EXCEEDED";
+            ATOM_NOT_FOUND: "ATOM_NOT_FOUND";
+            ATOM_UNAVAILABLE: "ATOM_UNAVAILABLE";
+            DEPRECATED_ATOM_FORBIDDEN: "DEPRECATED_ATOM_FORBIDDEN";
+            ATTEMPT_TIMEOUT_LIMIT_EXCEEDED: "ATTEMPT_TIMEOUT_LIMIT_EXCEEDED";
+            LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED: "LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED";
+            LIFECYCLE_TICK_LIMIT_EXCEEDED: "LIFECYCLE_TICK_LIMIT_EXCEEDED";
+            RETRY_LIMIT_EXCEEDED: "RETRY_LIMIT_EXCEEDED";
+            RETRY_DELAY_LIMIT_EXCEEDED: "RETRY_DELAY_LIMIT_EXCEEDED";
+            RETRY_POLICY_INVALID: "RETRY_POLICY_INVALID";
+            NON_IDEMPOTENT_RETRY_FORBIDDEN: "NON_IDEMPOTENT_RETRY_FORBIDDEN";
+            CACHE_TTL_LIMIT_EXCEEDED: "CACHE_TTL_LIMIT_EXCEEDED";
+            CACHE_ENABLE_OVERRIDE_FORBIDDEN: "CACHE_ENABLE_OVERRIDE_FORBIDDEN";
+            MAP_LIMIT_EXCEEDED: "MAP_LIMIT_EXCEEDED";
+            MAP_GROUP_CONFIG_MISMATCH: "MAP_GROUP_CONFIG_MISMATCH";
+            MAP_COMPLETION_CONFLICT: "MAP_COMPLETION_CONFLICT";
+            AGENT_PROVIDER_FORBIDDEN: "AGENT_PROVIDER_FORBIDDEN";
+            AGENT_MODEL_FORBIDDEN: "AGENT_MODEL_FORBIDDEN";
+            AGENT_FALLBACK_LIMIT_EXCEEDED: "AGENT_FALLBACK_LIMIT_EXCEEDED";
+            AGENT_FALLBACK_DUPLICATE: "AGENT_FALLBACK_DUPLICATE";
+            AGENT_CWD_FORBIDDEN: "AGENT_CWD_FORBIDDEN";
+            DUPLICATE_NODE_ID: "DUPLICATE_NODE_ID";
+            DUPLICATE_DEPENDENCY: "DUPLICATE_DEPENDENCY";
+            SELF_DEPENDENCY: "SELF_DEPENDENCY";
+            DEPENDENCY_NOT_FOUND: "DEPENDENCY_NOT_FOUND";
+            DEPENDENCY_CYCLE: "DEPENDENCY_CYCLE";
+            ENTRY_NODE_NOT_FOUND: "ENTRY_NODE_NOT_FOUND";
+            ENTRY_NODE_DUPLICATE: "ENTRY_NODE_DUPLICATE";
+            ENTRY_DEPENDENCY_INVALID: "ENTRY_DEPENDENCY_INVALID";
+            EDGE_TARGET_NOT_FOUND: "EDGE_TARGET_NOT_FOUND";
+            EDGE_TARGET_DUPLICATE: "EDGE_TARGET_DUPLICATE";
+            EDGE_TERMINAL_WITH_INPUT_FORBIDDEN: "EDGE_TERMINAL_WITH_INPUT_FORBIDDEN";
+            EDGE_BACK_EDGE_UNBOUNDED: "EDGE_BACK_EDGE_UNBOUNDED";
+            EDGE_TRAVERSAL_LIMIT_EXCEEDED: "EDGE_TRAVERSAL_LIMIT_EXCEEDED";
+            DECISION_SELECT_REFERENCE_INVALID: "DECISION_SELECT_REFERENCE_INVALID";
+            DECISION_SELECT_TYPE_MISMATCH: "DECISION_SELECT_TYPE_MISMATCH";
+            DECISION_BRANCH_ENUM_MISMATCH: "DECISION_BRANCH_ENUM_MISMATCH";
+            CONTROL_NODE_UNREACHABLE: "CONTROL_NODE_UNREACHABLE";
+            CONTROL_DEAD_END: "CONTROL_DEAD_END";
+            CONTROL_TERMINAL_UNREACHABLE: "CONTROL_TERMINAL_UNREACHABLE";
+            JOIN_CONTROL_PREDECESSOR_MISSING: "JOIN_CONTROL_PREDECESSOR_MISSING";
+            PARALLEL_FANOUT_NOT_JOINED: "PARALLEL_FANOUT_NOT_JOINED";
+            BRANCH_MERGE_INPUT_MISSING: "BRANCH_MERGE_INPUT_MISSING";
+            BRANCH_MERGE_SOURCE_INVALID: "BRANCH_MERGE_SOURCE_INVALID";
+            REFERENCE_NOT_FOUND: "REFERENCE_NOT_FOUND";
+            REFERENCE_SOURCE_OPTIONAL: "REFERENCE_SOURCE_OPTIONAL";
+            REFERENCE_NOT_DEPENDENCY: "REFERENCE_NOT_DEPENDENCY";
+            MAP_REFERENCE_OUTSIDE_MAP: "MAP_REFERENCE_OUTSIDE_MAP";
+            EDGE_REFERENCE_OUTSIDE_EDGE: "EDGE_REFERENCE_OUTSIDE_EDGE";
+            WORKFLOW_OUTPUT_REFERENCE_INVALID: "WORKFLOW_OUTPUT_REFERENCE_INVALID";
+            REFERENCE_INVALID: "REFERENCE_INVALID";
+            REFERENCE_TYPE_MISMATCH: "REFERENCE_TYPE_MISMATCH";
+            INPUT_SCHEMA_MISMATCH: "INPUT_SCHEMA_MISMATCH";
+            INPUT_REQUIRED_PROPERTY_MISSING: "INPUT_REQUIRED_PROPERTY_MISSING";
+            INPUT_ADDITIONAL_PROPERTY_FORBIDDEN: "INPUT_ADDITIONAL_PROPERTY_FORBIDDEN";
+            MAP_ITEMS_NOT_ARRAY: "MAP_ITEMS_NOT_ARRAY";
+            EDGE_INPUT_SCHEMA_MISMATCH: "EDGE_INPUT_SCHEMA_MISMATCH";
+            AGENT_CWD_TYPE_MISMATCH: "AGENT_CWD_TYPE_MISMATCH";
+            PLANNER_DRAFT_SCHEMA_INVALID: "PLANNER_DRAFT_SCHEMA_INVALID";
+            PLANNER_DRAFT_ATOM_NOT_SELECTED: "PLANNER_DRAFT_ATOM_NOT_SELECTED";
+            PLANNER_DRAFT_ALIAS_DUPLICATE: "PLANNER_DRAFT_ALIAS_DUPLICATE";
+            PLANNER_DRAFT_REFERENCE_INVALID: "PLANNER_DRAFT_REFERENCE_INVALID";
+            PLANNER_DRAFT_REFERENCE_AMBIGUOUS: "PLANNER_DRAFT_REFERENCE_AMBIGUOUS";
+            PLANNER_DRAFT_CONTROL_INVALID: "PLANNER_DRAFT_CONTROL_INVALID";
+            PLANNER_DRAFT_NORMALIZATION_FAILED: "PLANNER_DRAFT_NORMALIZATION_FAILED";
+            PLANNER_TURN_LIMIT_EXCEEDED: "PLANNER_TURN_LIMIT_EXCEEDED";
+            PLANNER_CAPABILITY_SCHEMA_INVALID: "PLANNER_CAPABILITY_SCHEMA_INVALID";
+            PLANNING_WORKSPACE_ACTION_INVALID: "PLANNING_WORKSPACE_ACTION_INVALID";
+            PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+            PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+            PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+            PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED: "PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED";
+            PLANNING_REQUIRED_INPUT_UNAVAILABLE: "PLANNING_REQUIRED_INPUT_UNAVAILABLE";
+            PLANNING_BINDING_SOURCE_OPTIONAL: "PLANNING_BINDING_SOURCE_OPTIONAL";
+            PLANNING_BINDING_AMBIGUOUS: "PLANNING_BINDING_AMBIGUOUS";
+            PLANNING_BRANCH_RESULT_REQUIRED: "PLANNING_BRANCH_RESULT_REQUIRED";
+            PLANNING_BRANCH_RESULT_MISMATCH: "PLANNING_BRANCH_RESULT_MISMATCH";
+            PLANNING_DECISION_NO_EFFECT: "PLANNING_DECISION_NO_EFFECT";
+            PLANNING_DRAFT_EMPTY: "PLANNING_DRAFT_EMPTY";
+            PLANNING_TRANSACTION_INVALID: "PLANNING_TRANSACTION_INVALID";
+            PLANNING_TRANSACTION_LIMIT_EXCEEDED: "PLANNING_TRANSACTION_LIMIT_EXCEEDED";
+            PLANNING_TRANSACTION_VALIDATION_FAILED: "PLANNING_TRANSACTION_VALIDATION_FAILED";
+            PLANNING_REVISION_CONFLICT: "PLANNING_REVISION_CONFLICT";
+            PLANNING_REVISION_LIMIT_EXCEEDED: "PLANNING_REVISION_LIMIT_EXCEEDED";
+            PLANNING_NODE_LIMIT_EXCEEDED: "PLANNING_NODE_LIMIT_EXCEEDED";
+            PLANNING_OPERATION_CONFLICT: "PLANNING_OPERATION_CONFLICT";
+            PLANNING_BLOCK_DUPLICATE: "PLANNING_BLOCK_DUPLICATE";
+            PLANNING_BLOCK_NOT_FOUND: "PLANNING_BLOCK_NOT_FOUND";
+            PLANNING_FINALIZE_CONFLICT: "PLANNING_FINALIZE_CONFLICT";
+            PLANNING_WORKSPACE_NOT_EDITABLE: "PLANNING_WORKSPACE_NOT_EDITABLE";
+            PLANNING_WORKSPACE_NOT_FINALIZABLE: "PLANNING_WORKSPACE_NOT_FINALIZABLE";
+            PLANNING_ATOM_UNAVAILABLE: "PLANNING_ATOM_UNAVAILABLE";
+            PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED: "PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED";
+            PLANNING_FINAL_VALIDATION_FAILED: "PLANNING_FINAL_VALIDATION_FAILED";
+            PLANNING_WORKFLOW_OUTPUT_REQUIRED: "PLANNING_WORKFLOW_OUTPUT_REQUIRED";
+            PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED: "PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED";
+            PLANNING_FINALIZED_REVISION_MISSING: "PLANNING_FINALIZED_REVISION_MISSING";
+        }>;
+        stage: z.ZodOptional<z.ZodEnum<{
+            "json-extract": "json-extract";
+            "capability-schema": "capability-schema";
+            "capability-resolution": "capability-resolution";
+            "draft-schema": "draft-schema";
+            "atom-resolution": "atom-resolution";
+            "draft-normalization": "draft-normalization";
+            "workflow-schema": "workflow-schema";
+            "data-link": "data-link";
+            "control-graph": "control-graph";
+            "runtime-policy": "runtime-policy";
+        }>>;
+        path: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+        atomId: z.ZodOptional<z.ZodString>;
+        expected: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        received: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type PlannerInput = z.infer<typeof PlannerInputSchema>;
+export declare const PlannerTurnPhaseSchema: z.ZodEnum<{
+    "capability-coverage": "capability-coverage";
+    workspace: "workspace";
+}>;
+export type PlannerTurnPhase = z.infer<typeof PlannerTurnPhaseSchema>;
+/** Provider-neutral prompt turn. Workflow semantics remain in workflow-planner. */
+export declare const PlannerTurnInputSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    requestId: z.ZodString;
+    phase: z.ZodEnum<{
+        "capability-coverage": "capability-coverage";
+        workspace: "workspace";
+    }>;
+    payload: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+    previousValidationErrors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            WORKFLOW_JSON_INVALID: "WORKFLOW_JSON_INVALID";
+            WORKFLOW_SCHEMA_INVALID: "WORKFLOW_SCHEMA_INVALID";
+            RUNTIME_POLICY_INVALID: "RUNTIME_POLICY_INVALID";
+            ATOM_CATALOG_INVALID: "ATOM_CATALOG_INVALID";
+            ATOM_CATALOG_DUPLICATE: "ATOM_CATALOG_DUPLICATE";
+            NODE_LIMIT_EXCEEDED: "NODE_LIMIT_EXCEEDED";
+            DEPENDENCY_LIMIT_EXCEEDED: "DEPENDENCY_LIMIT_EXCEEDED";
+            ATOM_NOT_FOUND: "ATOM_NOT_FOUND";
+            ATOM_UNAVAILABLE: "ATOM_UNAVAILABLE";
+            DEPRECATED_ATOM_FORBIDDEN: "DEPRECATED_ATOM_FORBIDDEN";
+            ATTEMPT_TIMEOUT_LIMIT_EXCEEDED: "ATTEMPT_TIMEOUT_LIMIT_EXCEEDED";
+            LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED: "LIFECYCLE_TICK_TIMEOUT_LIMIT_EXCEEDED";
+            LIFECYCLE_TICK_LIMIT_EXCEEDED: "LIFECYCLE_TICK_LIMIT_EXCEEDED";
+            RETRY_LIMIT_EXCEEDED: "RETRY_LIMIT_EXCEEDED";
+            RETRY_DELAY_LIMIT_EXCEEDED: "RETRY_DELAY_LIMIT_EXCEEDED";
+            RETRY_POLICY_INVALID: "RETRY_POLICY_INVALID";
+            NON_IDEMPOTENT_RETRY_FORBIDDEN: "NON_IDEMPOTENT_RETRY_FORBIDDEN";
+            CACHE_TTL_LIMIT_EXCEEDED: "CACHE_TTL_LIMIT_EXCEEDED";
+            CACHE_ENABLE_OVERRIDE_FORBIDDEN: "CACHE_ENABLE_OVERRIDE_FORBIDDEN";
+            MAP_LIMIT_EXCEEDED: "MAP_LIMIT_EXCEEDED";
+            MAP_GROUP_CONFIG_MISMATCH: "MAP_GROUP_CONFIG_MISMATCH";
+            MAP_COMPLETION_CONFLICT: "MAP_COMPLETION_CONFLICT";
+            AGENT_PROVIDER_FORBIDDEN: "AGENT_PROVIDER_FORBIDDEN";
+            AGENT_MODEL_FORBIDDEN: "AGENT_MODEL_FORBIDDEN";
+            AGENT_FALLBACK_LIMIT_EXCEEDED: "AGENT_FALLBACK_LIMIT_EXCEEDED";
+            AGENT_FALLBACK_DUPLICATE: "AGENT_FALLBACK_DUPLICATE";
+            AGENT_CWD_FORBIDDEN: "AGENT_CWD_FORBIDDEN";
+            DUPLICATE_NODE_ID: "DUPLICATE_NODE_ID";
+            DUPLICATE_DEPENDENCY: "DUPLICATE_DEPENDENCY";
+            SELF_DEPENDENCY: "SELF_DEPENDENCY";
+            DEPENDENCY_NOT_FOUND: "DEPENDENCY_NOT_FOUND";
+            DEPENDENCY_CYCLE: "DEPENDENCY_CYCLE";
+            ENTRY_NODE_NOT_FOUND: "ENTRY_NODE_NOT_FOUND";
+            ENTRY_NODE_DUPLICATE: "ENTRY_NODE_DUPLICATE";
+            ENTRY_DEPENDENCY_INVALID: "ENTRY_DEPENDENCY_INVALID";
+            EDGE_TARGET_NOT_FOUND: "EDGE_TARGET_NOT_FOUND";
+            EDGE_TARGET_DUPLICATE: "EDGE_TARGET_DUPLICATE";
+            EDGE_TERMINAL_WITH_INPUT_FORBIDDEN: "EDGE_TERMINAL_WITH_INPUT_FORBIDDEN";
+            EDGE_BACK_EDGE_UNBOUNDED: "EDGE_BACK_EDGE_UNBOUNDED";
+            EDGE_TRAVERSAL_LIMIT_EXCEEDED: "EDGE_TRAVERSAL_LIMIT_EXCEEDED";
+            DECISION_SELECT_REFERENCE_INVALID: "DECISION_SELECT_REFERENCE_INVALID";
+            DECISION_SELECT_TYPE_MISMATCH: "DECISION_SELECT_TYPE_MISMATCH";
+            DECISION_BRANCH_ENUM_MISMATCH: "DECISION_BRANCH_ENUM_MISMATCH";
+            CONTROL_NODE_UNREACHABLE: "CONTROL_NODE_UNREACHABLE";
+            CONTROL_DEAD_END: "CONTROL_DEAD_END";
+            CONTROL_TERMINAL_UNREACHABLE: "CONTROL_TERMINAL_UNREACHABLE";
+            JOIN_CONTROL_PREDECESSOR_MISSING: "JOIN_CONTROL_PREDECESSOR_MISSING";
+            PARALLEL_FANOUT_NOT_JOINED: "PARALLEL_FANOUT_NOT_JOINED";
+            BRANCH_MERGE_INPUT_MISSING: "BRANCH_MERGE_INPUT_MISSING";
+            BRANCH_MERGE_SOURCE_INVALID: "BRANCH_MERGE_SOURCE_INVALID";
+            REFERENCE_NOT_FOUND: "REFERENCE_NOT_FOUND";
+            REFERENCE_SOURCE_OPTIONAL: "REFERENCE_SOURCE_OPTIONAL";
+            REFERENCE_NOT_DEPENDENCY: "REFERENCE_NOT_DEPENDENCY";
+            MAP_REFERENCE_OUTSIDE_MAP: "MAP_REFERENCE_OUTSIDE_MAP";
+            EDGE_REFERENCE_OUTSIDE_EDGE: "EDGE_REFERENCE_OUTSIDE_EDGE";
+            WORKFLOW_OUTPUT_REFERENCE_INVALID: "WORKFLOW_OUTPUT_REFERENCE_INVALID";
+            REFERENCE_INVALID: "REFERENCE_INVALID";
+            REFERENCE_TYPE_MISMATCH: "REFERENCE_TYPE_MISMATCH";
+            INPUT_SCHEMA_MISMATCH: "INPUT_SCHEMA_MISMATCH";
+            INPUT_REQUIRED_PROPERTY_MISSING: "INPUT_REQUIRED_PROPERTY_MISSING";
+            INPUT_ADDITIONAL_PROPERTY_FORBIDDEN: "INPUT_ADDITIONAL_PROPERTY_FORBIDDEN";
+            MAP_ITEMS_NOT_ARRAY: "MAP_ITEMS_NOT_ARRAY";
+            EDGE_INPUT_SCHEMA_MISMATCH: "EDGE_INPUT_SCHEMA_MISMATCH";
+            AGENT_CWD_TYPE_MISMATCH: "AGENT_CWD_TYPE_MISMATCH";
+            PLANNER_DRAFT_SCHEMA_INVALID: "PLANNER_DRAFT_SCHEMA_INVALID";
+            PLANNER_DRAFT_ATOM_NOT_SELECTED: "PLANNER_DRAFT_ATOM_NOT_SELECTED";
+            PLANNER_DRAFT_ALIAS_DUPLICATE: "PLANNER_DRAFT_ALIAS_DUPLICATE";
+            PLANNER_DRAFT_REFERENCE_INVALID: "PLANNER_DRAFT_REFERENCE_INVALID";
+            PLANNER_DRAFT_REFERENCE_AMBIGUOUS: "PLANNER_DRAFT_REFERENCE_AMBIGUOUS";
+            PLANNER_DRAFT_CONTROL_INVALID: "PLANNER_DRAFT_CONTROL_INVALID";
+            PLANNER_DRAFT_NORMALIZATION_FAILED: "PLANNER_DRAFT_NORMALIZATION_FAILED";
+            PLANNER_TURN_LIMIT_EXCEEDED: "PLANNER_TURN_LIMIT_EXCEEDED";
+            PLANNER_CAPABILITY_SCHEMA_INVALID: "PLANNER_CAPABILITY_SCHEMA_INVALID";
+            PLANNING_WORKSPACE_ACTION_INVALID: "PLANNING_WORKSPACE_ACTION_INVALID";
+            PLANNING_CAPABILITY_UNAVAILABLE: "PLANNING_CAPABILITY_UNAVAILABLE";
+            PLANNING_CAPABILITY_ATOM_UNKNOWN: "PLANNING_CAPABILITY_ATOM_UNKNOWN";
+            PLANNING_CAPABILITY_SCHEMA_MISMATCH: "PLANNING_CAPABILITY_SCHEMA_MISMATCH";
+            PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED: "PLANNING_SELECTED_ATOM_LIMIT_EXCEEDED";
+            PLANNING_REQUIRED_INPUT_UNAVAILABLE: "PLANNING_REQUIRED_INPUT_UNAVAILABLE";
+            PLANNING_BINDING_SOURCE_OPTIONAL: "PLANNING_BINDING_SOURCE_OPTIONAL";
+            PLANNING_BINDING_AMBIGUOUS: "PLANNING_BINDING_AMBIGUOUS";
+            PLANNING_BRANCH_RESULT_REQUIRED: "PLANNING_BRANCH_RESULT_REQUIRED";
+            PLANNING_BRANCH_RESULT_MISMATCH: "PLANNING_BRANCH_RESULT_MISMATCH";
+            PLANNING_DECISION_NO_EFFECT: "PLANNING_DECISION_NO_EFFECT";
+            PLANNING_DRAFT_EMPTY: "PLANNING_DRAFT_EMPTY";
+            PLANNING_TRANSACTION_INVALID: "PLANNING_TRANSACTION_INVALID";
+            PLANNING_TRANSACTION_LIMIT_EXCEEDED: "PLANNING_TRANSACTION_LIMIT_EXCEEDED";
+            PLANNING_TRANSACTION_VALIDATION_FAILED: "PLANNING_TRANSACTION_VALIDATION_FAILED";
+            PLANNING_REVISION_CONFLICT: "PLANNING_REVISION_CONFLICT";
+            PLANNING_REVISION_LIMIT_EXCEEDED: "PLANNING_REVISION_LIMIT_EXCEEDED";
+            PLANNING_NODE_LIMIT_EXCEEDED: "PLANNING_NODE_LIMIT_EXCEEDED";
+            PLANNING_OPERATION_CONFLICT: "PLANNING_OPERATION_CONFLICT";
+            PLANNING_BLOCK_DUPLICATE: "PLANNING_BLOCK_DUPLICATE";
+            PLANNING_BLOCK_NOT_FOUND: "PLANNING_BLOCK_NOT_FOUND";
+            PLANNING_FINALIZE_CONFLICT: "PLANNING_FINALIZE_CONFLICT";
+            PLANNING_WORKSPACE_NOT_EDITABLE: "PLANNING_WORKSPACE_NOT_EDITABLE";
+            PLANNING_WORKSPACE_NOT_FINALIZABLE: "PLANNING_WORKSPACE_NOT_FINALIZABLE";
+            PLANNING_ATOM_UNAVAILABLE: "PLANNING_ATOM_UNAVAILABLE";
+            PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED: "PLANNING_ATOM_SCHEMA_DESCRIPTION_REQUIRED";
+            PLANNING_FINAL_VALIDATION_FAILED: "PLANNING_FINAL_VALIDATION_FAILED";
+            PLANNING_WORKFLOW_OUTPUT_REQUIRED: "PLANNING_WORKFLOW_OUTPUT_REQUIRED";
+            PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED: "PLANNING_REQUIRED_CAPABILITY_NOT_REALIZED";
+            PLANNING_FINALIZED_REVISION_MISSING: "PLANNING_FINALIZED_REVISION_MISSING";
+        }>;
+        stage: z.ZodOptional<z.ZodEnum<{
+            "json-extract": "json-extract";
+            "capability-schema": "capability-schema";
+            "capability-resolution": "capability-resolution";
+            "draft-schema": "draft-schema";
+            "atom-resolution": "atom-resolution";
+            "draft-normalization": "draft-normalization";
+            "workflow-schema": "workflow-schema";
+            "data-link": "data-link";
+            "control-graph": "control-graph";
+            "runtime-policy": "runtime-policy";
+        }>>;
+        path: z.ZodString;
+        message: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+        atomId: z.ZodOptional<z.ZodString>;
+        expected: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+        received: z.ZodOptional<z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type PlannerTurnInput = z.infer<typeof PlannerTurnInputSchema>;
+export declare const PlannerStreamEventSchema: z.ZodObject<{
+    sequence: z.ZodNumber;
+    timestamp: z.ZodString;
+    type: z.ZodString;
+    data: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+}, z.core.$strict>;
+export type PlannerStreamEvent = z.infer<typeof PlannerStreamEventSchema>;
+export declare const PlannerAttemptStatusSchema: z.ZodEnum<{
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    cancelled: "cancelled";
+}>;
+export declare const PlannerTokenUsageSchema: z.ZodObject<{
+    totalTokens: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    thoughtTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cachedReadTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    cachedWriteTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+export type PlannerTokenUsage = z.infer<typeof PlannerTokenUsageSchema>;
+export declare const PlannerAttemptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    attemptId: z.ZodString;
+    requestId: z.ZodString;
+    providerId: z.ZodString;
+    model: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    startedAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    stopReason: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        end_turn: "end_turn";
+        max_tokens: "max_tokens";
+        max_turn_requests: "max_turn_requests";
+        refusal: "refusal";
+    }>>;
+    usage: z.ZodOptional<z.ZodObject<{
+        totalTokens: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        thoughtTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cachedReadTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        cachedWriteTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>;
+    events: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        sequence: z.ZodNumber;
+        timestamp: z.ZodString;
+        type: z.ZodString;
+        data: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+    }, z.core.$strict>>>;
+    rawOutputRef: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PlannerAttempt = z.infer<typeof PlannerAttemptSchema>;
+export declare const PlannerResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"1.0">;
+    attempt: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"1.0">;
+        attemptId: z.ZodString;
+        requestId: z.ZodString;
+        providerId: z.ZodString;
+        model: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        startedAt: z.ZodString;
+        endedAt: z.ZodOptional<z.ZodString>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        stopReason: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            end_turn: "end_turn";
+            max_tokens: "max_tokens";
+            max_turn_requests: "max_turn_requests";
+            refusal: "refusal";
+        }>>;
+        usage: z.ZodOptional<z.ZodObject<{
+            totalTokens: z.ZodNumber;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            thoughtTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cachedReadTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cachedWriteTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>>;
+        events: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            sequence: z.ZodNumber;
+            timestamp: z.ZodString;
+            type: z.ZodString;
+            data: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+        }, z.core.$strict>>>;
+        rawOutputRef: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    document: z.ZodType<import("../atoms/manifest.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../atoms/manifest.js").JsonValue, unknown>>;
+    rawOutput: z.ZodString;
+}, z.core.$strict>;
+export type PlannerResult = z.infer<typeof PlannerResultSchema>;
+//# sourceMappingURL=planner.d.ts.map

package/dist/planner/planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/planner/planner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;kBAOxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;kBASnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASpB,CAAC;AACZ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,sBAAsB;;;EAA+C,CAAC;AACnF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,mFAAmF;AACnF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMxB,CAAC;AACZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,wBAAwB;;;;;kBAK1B,CAAC;AACZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,0BAA0B;;;;;EAA0D,CAAC;AAClG,eAAO,MAAM,uBAAuB;;;;;;;kBAOzB,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgBtB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKrB,CAAC;AACZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/planner/planner.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { JsonValueSchema } from "../atoms/manifest.js";
+import { PlannerAtomDescriptorSchema } from "../atoms/descriptors.js";
+import { RuntimePolicySchema } from "../workflows/policy.js";
+import { WorkflowValidationErrorSchema } from "../workflows/validation.js";
+const ProviderIdSchema = z.string().regex(/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/);
+const ModelIdSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/);
+const HashSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+const TimestampSchema = z.string().datetime({ offset: true });
+export const PlannerAtomCatalogEntrySchema = z.object({
+    key: z.string().trim().min(1),
+    descriptor: PlannerAtomDescriptorSchema,
+}).strict().superRefine((entry, context) => {
+    if (entry.key !== entry.descriptor.key) {
+        context.addIssue({ code: "custom", path: ["key"], message: "Catalog key must match the exact Atom id and version" });
+    }
+});
+export const PlannerAtomCatalogSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    hash: HashSchema,
+    atoms: z.array(PlannerAtomCatalogEntrySchema),
+}).strict().superRefine((catalog, context) => {
+    const keys = catalog.atoms.map((entry) => entry.key);
+    if (new Set(keys).size !== keys.length) {
+        context.addIssue({ code: "custom", path: ["atoms"], message: "Planner catalog cannot contain duplicate Atom versions" });
+    }
+});
+export const PlannerInputSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    requestId: z.string().trim().min(1),
+    goal: z.string().trim().min(1),
+    workflowInputs: z.record(z.string(), JsonValueSchema).default({}),
+    context: JsonValueSchema.default({}),
+    atomCatalog: PlannerAtomCatalogSchema,
+    runtimePolicy: RuntimePolicySchema,
+    previousValidationErrors: z.array(WorkflowValidationErrorSchema).optional(),
+}).strict();
+export const PlannerTurnPhaseSchema = z.enum(["capability-coverage", "workspace"]);
+/** Provider-neutral prompt turn. Workflow semantics remain in workflow-planner. */
+export const PlannerTurnInputSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    requestId: z.string().trim().min(1),
+    phase: PlannerTurnPhaseSchema,
+    payload: JsonValueSchema,
+    previousValidationErrors: z.array(WorkflowValidationErrorSchema).optional(),
+}).strict();
+export const PlannerStreamEventSchema = z.object({
+    sequence: z.number().int().nonnegative(),
+    timestamp: TimestampSchema,
+    type: z.string().trim().min(1),
+    data: JsonValueSchema,
+}).strict();
+export const PlannerAttemptStatusSchema = z.enum(["running", "succeeded", "failed", "cancelled"]);
+export const PlannerTokenUsageSchema = z.object({
+    totalTokens: z.number().int().nonnegative(),
+    inputTokens: z.number().int().nonnegative(),
+    outputTokens: z.number().int().nonnegative(),
+    thoughtTokens: z.number().int().nonnegative().nullable().optional(),
+    cachedReadTokens: z.number().int().nonnegative().nullable().optional(),
+    cachedWriteTokens: z.number().int().nonnegative().nullable().optional(),
+}).strict();
+export const PlannerAttemptSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    attemptId: z.string().trim().min(1),
+    requestId: z.string().trim().min(1),
+    providerId: ProviderIdSchema,
+    model: ModelIdSchema,
+    sessionId: z.string().trim().min(1).optional(),
+    status: PlannerAttemptStatusSchema,
+    startedAt: TimestampSchema,
+    endedAt: TimestampSchema.optional(),
+    durationMs: z.number().int().nonnegative().optional(),
+    stopReason: z.enum(["end_turn", "max_tokens", "max_turn_requests", "refusal", "cancelled"]).optional(),
+    usage: PlannerTokenUsageSchema.optional(),
+    events: z.array(PlannerStreamEventSchema).default([]),
+    rawOutputRef: HashSchema.optional(),
+    error: z.object({ code: z.string().trim().min(1), message: z.string().trim().min(1), retryable: z.boolean() }).strict().optional(),
+}).strict();
+export const PlannerResultSchema = z.object({
+    schemaVersion: z.literal("1.0"),
+    attempt: PlannerAttemptSchema,
+    document: JsonValueSchema,
+    rawOutput: z.string(),
+}).strict();
+//# sourceMappingURL=planner.js.map

package/dist/planner/planner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.js","sourceRoot":"","sources":["../../src/planner/planner.ts"],"names":[],"mappings":"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"}