omnius 1.0.813 → 1.0.816

package/dist/library.js

@@ -55,10 +55,1878 @@ var init_jetson_monitor = __esm({
   }
 });
 
-// packages/execution/dist/gpu-selection.js
+// packages/schemas/dist/gpu-selection.js
 var init_gpu_selection = __esm({
+  "packages/schemas/dist/gpu-selection.js"() {
+    "use strict";
+  }
+});
+
+// packages/schemas/dist/feature-workflow.js
+import { z } from "zod";
+var FEATURE_WORKFLOW_PLAN_SCHEMA, FEATURE_WORKFLOW_PHASES, FeatureWorkflowPhaseSchema, id, text, FeatureWorkflowArtifactReferenceSchema, path, FeatureWorkflowCardSchema, FeatureWorkflowPlanSchema, FeatureWorkflowChildReportSchema, FeatureWorkflowToolInputSchema, FeatureWorkflowToolJsonSchema;
+var init_feature_workflow = __esm({
+  "packages/schemas/dist/feature-workflow.js"() {
+    "use strict";
+    FEATURE_WORKFLOW_PLAN_SCHEMA = "omnius.feature-workflow-plan.v1";
+    FEATURE_WORKFLOW_PHASES = [
+      "research",
+      "specification",
+      "implementation",
+      "integration",
+      "acceptance",
+      "handoff"
+    ];
+    FeatureWorkflowPhaseSchema = z.enum(FEATURE_WORKFLOW_PHASES);
+    id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,119}$/);
+    text = z.string().trim().min(1).max(4e3);
+    FeatureWorkflowArtifactReferenceSchema = z.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
+    path = z.string().trim().min(1).max(1e3);
+    FeatureWorkflowCardSchema = z.object({
+      id,
+      title: text,
+      phase: FeatureWorkflowPhaseSchema,
+      role: z.enum([
+        "researcher",
+        "author",
+        "reviewer",
+        "implementer",
+        "integrator",
+        "verifier",
+        "synthesizer"
+      ]),
+      dependsOn: z.array(id).max(128).default([]),
+      sourceIds: z.array(id).max(256).default([]),
+      inputSlots: z.array(id).max(256).default([]),
+      reviewSlots: z.array(id).max(32).default([]),
+      ownedFiles: z.array(path).max(128).default([]),
+      acceptanceIds: z.array(id).max(256).default([]),
+      verifier: z.object({
+        command: z.string().trim().min(1).max(4e3),
+        cwd: path.optional(),
+        targetPaths: z.array(path).min(1).max(128)
+      }).strict().optional()
+    }).strict();
+    FeatureWorkflowPlanSchema = z.object({
+      schema: z.literal(FEATURE_WORKFLOW_PLAN_SCHEMA),
+      id,
+      revision: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
+      objective: text,
+      requirements: z.array(z.object({ id, description: text }).strict()).min(1).max(256),
+      sources: z.array(z.object({ id, reference: FeatureWorkflowArtifactReferenceSchema }).strict()).max(256).default([]),
+      slots: z.array(z.object({
+        id,
+        kind: z.enum([
+          "research",
+          "specification",
+          "implementation",
+          "integration",
+          "review",
+          "handoff"
+        ]),
+        cardId: id,
+        requiresReview: z.boolean().default(false)
+      }).strict()).min(4).max(256),
+      cards: z.array(FeatureWorkflowCardSchema).min(6).max(128)
+    }).strict().superRefine((plan, ctx) => {
+      const fail = (message) => ctx.addIssue({ code: "custom", message });
+      const unique = (values, label) => {
+        if (new Set(values).size !== values.length)
+          fail(`duplicate ${label}`);
+      };
+      unique(plan.cards.map((c) => c.id), "card id");
+      unique(plan.slots.map((s) => s.id), "slot id");
+      unique(plan.sources.map((s) => s.id), "source id");
+      unique(plan.requirements.map((r) => r.id), "requirement id");
+      const cards = new Map(plan.cards.map((c) => [c.id, c]));
+      const slots = new Map(plan.slots.map((s) => [s.id, s]));
+      const sources = new Set(plan.sources.map((s) => s.id));
+      const assertions = new Map(plan.requirements.map((r) => [r.id, 0]));
+      for (const phase of FEATURE_WORKFLOW_PHASES)
+        if (!plan.cards.some((c) => c.phase === phase))
+          fail(`missing phase ${phase}`);
+      for (const slot of plan.slots) {
+        if (slot.id.startsWith("source:"))
+          fail(`reserved source namespace ${slot.id}`);
+        const producer = cards.get(slot.cardId);
+        if (!producer)
+          fail(`unknown producer ${slot.cardId}`);
+        if (slot.requiresReview && !plan.cards.some((c) => c.role === "reviewer" && c.reviewSlots.includes(slot.id)))
+          fail(`missing independent review for ${slot.id}`);
+        if (slot.requiresReview && producer && plan.cards.some((c) => c.reviewSlots.includes(slot.id) && c.phase !== producer.phase))
+          fail(`review must occur in producer phase ${slot.id}`);
+      }
+      for (const kind of [
+        "research",
+        "specification",
+        "integration",
+        "handoff"
+      ]) {
+        if (!plan.slots.some((s) => s.kind === kind && cards.get(s.cardId)?.phase === kind))
+          fail(`missing ${kind} artifact`);
+      }
+      if (!plan.slots.some((s) => s.kind === "specification" && s.requiresReview))
+        fail("specification requires independent review");
+      for (const card of plan.cards) {
+        if (card.role !== "reviewer" && card.role !== "verifier" && !plan.slots.some((slot) => slot.cardId === card.id))
+          fail(`work card requires an artifact slot ${card.id}`);
+        for (const [label, values] of Object.entries({
+          dependency: card.dependsOn,
+          source: card.sourceIds,
+          input: card.inputSlots,
+          review: card.reviewSlots,
+          acceptance: card.acceptanceIds
+        }))
+          unique(values, `${label} in ${card.id}`);
+        for (const dep of card.dependsOn)
+          if (!cards.has(dep))
+            fail(`unknown dependency ${dep}`);
+        for (const source of card.sourceIds)
+          if (!sources.has(source))
+            fail(`unknown source ${source}`);
+        for (const slotId of [...card.inputSlots, ...card.reviewSlots]) {
+          const slot = slots.get(slotId);
+          if (!slot) {
+            fail(`unknown slot ${slotId}`);
+            continue;
+          }
+          const producer = cards.get(slot.cardId);
+          if (slot.cardId === card.id)
+            fail(`self-dependent slot ${slotId}`);
+          if (producer && FEATURE_WORKFLOW_PHASES.indexOf(producer.phase) > FEATURE_WORKFLOW_PHASES.indexOf(card.phase))
+            fail(`future slot ${slotId}`);
+        }
+        for (const dep of card.dependsOn) {
+          const source = cards.get(dep);
+          if (source && FEATURE_WORKFLOW_PHASES.indexOf(source.phase) > FEATURE_WORKFLOW_PHASES.indexOf(card.phase))
+            fail(`future dependency ${dep}`);
+        }
+        if (card.role === "reviewer" !== card.reviewSlots.length > 0)
+          fail(`review role/slots mismatch ${card.id}`);
+        if (card.phase === "acceptance" && (card.role !== "verifier" || !card.verifier || card.acceptanceIds.length === 0))
+          fail(`acceptance needs explicit verifier ${card.id}`);
+        if (card.phase !== "acceptance" && (card.verifier || card.acceptanceIds.length))
+          fail(`acceptance authority outside acceptance phase ${card.id}`);
+        if (card.phase === "implementation" && card.role !== "reviewer" && (card.role !== "implementer" || card.ownedFiles.length === 0))
+          fail(`implementation needs owned files ${card.id}`);
+        for (const assertion of card.acceptanceIds) {
+          if (!assertions.has(assertion))
+            fail(`unknown acceptance ${assertion}`);
+          else
+            assertions.set(assertion, assertions.get(assertion) + 1);
+        }
+      }
+      for (const [assertion, count] of assertions)
+        if (count !== 1)
+          fail(`acceptance ${assertion} must have exactly one owner`);
+      const visiting = /* @__PURE__ */ new Set();
+      const visited = /* @__PURE__ */ new Set();
+      const visit = (cardId) => {
+        if (visiting.has(cardId)) {
+          fail(`dependency cycle ${cardId}`);
+          return;
+        }
+        if (visited.has(cardId))
+          return;
+        const card = cards.get(cardId);
+        if (!card)
+          return;
+        visiting.add(cardId);
+        for (const dependency of [
+          ...card.dependsOn,
+          ...[...card.inputSlots, ...card.reviewSlots].map((s) => slots.get(s)?.cardId).filter((s) => !!s)
+        ])
+          visit(dependency);
+        visiting.delete(cardId);
+        visited.add(cardId);
+      };
+      for (const card of plan.cards)
+        visit(card.id);
+    });
+    FeatureWorkflowChildReportSchema = z.object({
+      schema: z.literal("omnius.feature-workflow-child-report.v1"),
+      cardId: id,
+      status: z.enum(["completed", "partial", "blocked", "failed"]),
+      inputSlots: z.record(z.string().min(1).max(256), FeatureWorkflowArtifactReferenceSchema),
+      artifacts: z.array(z.object({ slotId: id, content: z.string().min(1).max(1e5) }).strict()).max(32).default([]),
+      review: z.object({
+        disposition: z.enum(["approved", "changes_requested"]),
+        reviewedSlots: z.record(id, FeatureWorkflowArtifactReferenceSchema),
+        findings: z.array(z.object({
+          id,
+          severity: z.enum(["info", "blocking"]),
+          detail: text
+        }).strict()).max(64)
+      }).strict().optional(),
+      blockers: z.array(text).max(32),
+      unresolvedQuestions: z.array(text).max(32)
+    }).strict();
+    FeatureWorkflowToolInputSchema = z.discriminatedUnion("action", [
+      z.object({
+        action: z.enum(["create", "revise"]),
+        plan: FeatureWorkflowPlanSchema
+      }).strict(),
+      z.object({ action: z.literal("status") }).strict(),
+      z.object({ action: z.literal("discover") }).strict(),
+      z.object({
+        action: z.literal("resume"),
+        runId: id,
+        planReference: FeatureWorkflowArtifactReferenceSchema,
+        objectiveId: id
+      }).strict(),
+      z.object({
+        action: z.literal("repair"),
+        cardId: id,
+        failedCardId: id,
+        reason: text
+      }).strict(),
+      z.object({
+        action: z.literal("record_artifact"),
+        cardId: id,
+        slotId: id,
+        path
+      }).strict()
+    ]);
+    FeatureWorkflowToolJsonSchema = z.toJSONSchema(FeatureWorkflowToolInputSchema, { reused: "ref", unrepresentable: "any" });
+  }
+});
+
+// packages/schemas/dist/messages.js
+import { z as z2 } from "zod";
+var AgentMessageSchema;
+var init_messages = __esm({
+  "packages/schemas/dist/messages.js"() {
+    "use strict";
+    AgentMessageSchema = z2.object({
+      id: z2.string().uuid(),
+      sessionId: z2.string().uuid(),
+      role: z2.enum(["user", "assistant", "system", "tool"]),
+      content: z2.string(),
+      timestamp: z2.string().datetime(),
+      metadata: z2.record(z2.string(), z2.unknown()).optional()
+    });
+  }
+});
+
+// packages/schemas/dist/tools.js
+import { z as z3 } from "zod";
+var ToolCallSchema;
+var init_tools = __esm({
+  "packages/schemas/dist/tools.js"() {
+    "use strict";
+    ToolCallSchema = z3.object({
+      id: z3.string().uuid(),
+      name: z3.string(),
+      arguments: z3.record(z3.string(), z3.unknown()),
+      result: z3.unknown().optional(),
+      status: z3.enum(["pending", "running", "completed", "failed"]),
+      startedAt: z3.string().datetime().optional(),
+      completedAt: z3.string().datetime().optional()
+    });
+  }
+});
+
+// packages/schemas/dist/session.js
+import { z as z4 } from "zod";
+var SessionSchema;
+var init_session = __esm({
+  "packages/schemas/dist/session.js"() {
+    "use strict";
+    SessionSchema = z4.object({
+      id: z4.string().uuid(),
+      projectRoot: z4.string(),
+      model: z4.string(),
+      createdAt: z4.string().datetime(),
+      updatedAt: z4.string().datetime(),
+      status: z4.enum(["active", "paused", "completed", "error"]),
+      config: z4.record(z4.string(), z4.unknown()).optional()
+    });
+  }
+});
+
+// packages/schemas/dist/task.js
+import { z as z5 } from "zod";
+var TaskClassSchema, UrgencySchema, NormalizedTaskSchema, TaskStatusSchema;
+var init_task = __esm({
+  "packages/schemas/dist/task.js"() {
+    "use strict";
+    TaskClassSchema = z5.enum([
+      "bugfix",
+      "feature",
+      "refactor",
+      "migration",
+      "dependency-upgrade",
+      "test",
+      "docs",
+      "infra"
+    ]);
+    UrgencySchema = z5.enum(["low", "medium", "high", "critical"]);
+    NormalizedTaskSchema = z5.object({
+      /** Stable unique identifier for this task instance */
+      id: z5.string(),
+      /** Human-readable goal description */
+      goal: z5.string().min(1),
+      /** Constraints the solution must satisfy */
+      constraints: z5.array(z5.string()),
+      /** Criteria that must pass for the task to be considered done */
+      successCriteria: z5.array(z5.string()),
+      /** Absolute path to the repo root */
+      repoRoot: z5.string(),
+      urgency: UrgencySchema,
+      taskClass: TaskClassSchema,
+      /** Original raw user request before normalization */
+      rawRequest: z5.string().optional(),
+      /** Timestamp when the task was created (ISO-8601) */
+      createdAt: z5.string().datetime()
+    });
+    TaskStatusSchema = z5.enum([
+      "pending",
+      "dispatched",
+      "in_progress",
+      "success",
+      "partial_success",
+      "needs_human_decision",
+      "blocked_missing_context",
+      "rollback_required",
+      "failed"
+    ]);
+  }
+});
+
+// packages/schemas/dist/plan.js
+import { z as z6 } from "zod";
+var SubtaskKindSchema, SubtaskSchema, PlanSchema;
+var init_plan = __esm({
+  "packages/schemas/dist/plan.js"() {
+    "use strict";
+    SubtaskKindSchema = z6.enum([
+      "inspect",
+      "patch",
+      "test",
+      "migrate",
+      "verify",
+      "merge"
+    ]);
+    SubtaskSchema = z6.object({
+      /** Stable identifier used for dependency references */
+      id: z6.string().min(1),
+      kind: SubtaskKindSchema,
+      /** File paths or symbol names that this subtask targets */
+      targets: z6.array(z6.string()),
+      /** IDs of subtasks that must complete before this one starts */
+      dependsOn: z6.array(z6.string()).optional(),
+      /** Why this subtask is necessary */
+      reason: z6.string().min(1),
+      /** Shell commands or assertions that confirm success */
+      validation: z6.array(z6.string())
+    });
+    PlanSchema = z6.object({
+      goal: z6.string().min(1),
+      subtasks: z6.array(SubtaskSchema),
+      /** Files/modules at elevated risk of breakage */
+      riskAreas: z6.array(z6.string()),
+      /** Aspects of the codebase that are unclear or ambiguous */
+      unknowns: z6.array(z6.string())
+    });
+  }
+});
+
+// packages/schemas/dist/patch.js
+import { z as z7 } from "zod";
+var EditOperationSchema, FileEditSchema, NeedsMoreContextSchema, PatchProposalSchema;
+var init_patch = __esm({
+  "packages/schemas/dist/patch.js"() {
+    "use strict";
+    EditOperationSchema = z7.enum([
+      "diff",
+      "rewrite",
+      "append",
+      "create"
+    ]);
+    FileEditSchema = z7.object({
+      /** Repo-relative or absolute path to the file being edited */
+      file: z7.string().min(1),
+      operation: EditOperationSchema,
+      /** Unified diff, full file content, appended text, or new file content */
+      content: z7.string()
+    });
+    NeedsMoreContextSchema = z7.object({
+      reason: z7.string().min(1),
+      requestedPaths: z7.array(z7.string()).optional(),
+      requestedSymbols: z7.array(z7.string()).optional()
+    });
+    PatchProposalSchema = z7.object({
+      /** One-paragraph description of what changed and why */
+      summary: z7.string().min(1),
+      edits: z7.array(FileEditSchema),
+      /** Test commands or test file paths that should be executed to validate */
+      testsToRun: z7.array(z7.string()),
+      /** Assumptions the editor made that the verifier should check */
+      assumptions: z7.array(z7.string()),
+      /** Known risks introduced by this patch */
+      risks: z7.array(z7.string()),
+      /**
+       * When the editor cannot safely produce a patch without more information.
+       * The presence of this field indicates the patch is incomplete.
+       */
+      needsMoreContext: NeedsMoreContextSchema.optional()
+    });
+  }
+});
+
+// packages/schemas/dist/verification.js
+import { z as z8 } from "zod";
+var VerificationStatusSchema, VerificationNextActionSchema, VerificationDecisionSchema;
+var init_verification = __esm({
+  "packages/schemas/dist/verification.js"() {
+    "use strict";
+    VerificationStatusSchema = z8.enum(["pass", "fail", "partial"]);
+    VerificationNextActionSchema = z8.enum([
+      "finish",
+      "retry",
+      "rollback",
+      "inspect_more"
+    ]);
+    VerificationDecisionSchema = z8.object({
+      status: VerificationStatusSchema,
+      /** Concrete evidence lines from logs, test output, or type-checker output */
+      evidence: z8.array(z8.string()),
+      nextAction: VerificationNextActionSchema,
+      /** Files that should be prioritised in the next retrieval/editing round */
+      focusFiles: z8.array(z8.string()),
+      /**
+       * Short fingerprint string identifying the failure category.
+       * Used to detect repeat failure loops. Only present when status !== "pass".
+       */
+      failureFingerprint: z8.string().optional()
+    });
+  }
+});
+
+// packages/schemas/dist/repoProfile.js
+import { z as z9 } from "zod";
+var LanguageSchema, PackageManagerSchema, BuildSystemSchema, MigrationSystemSchema, RepoProfileSchema;
+var init_repoProfile = __esm({
+  "packages/schemas/dist/repoProfile.js"() {
+    "use strict";
+    LanguageSchema = z9.enum([
+      "typescript",
+      "javascript",
+      "python",
+      "go",
+      "rust",
+      "java",
+      "csharp",
+      "sql",
+      "other"
+    ]);
+    PackageManagerSchema = z9.enum([
+      "npm",
+      "pnpm",
+      "yarn",
+      "bun",
+      "pip",
+      "poetry",
+      "cargo",
+      "go-modules",
+      "maven",
+      "gradle",
+      "other"
+    ]);
+    BuildSystemSchema = z9.enum([
+      "tsc",
+      "vite",
+      "webpack",
+      "esbuild",
+      "turbo",
+      "nx",
+      "make",
+      "cmake",
+      "cargo",
+      "gradle",
+      "maven",
+      "other"
+    ]);
+    MigrationSystemSchema = z9.enum([
+      "prisma",
+      "drizzle",
+      "knex",
+      "alembic",
+      "flyway",
+      "liquibase",
+      "typeorm",
+      "sequelize",
+      "other",
+      "none"
+    ]);
+    RepoProfileSchema = z9.object({
+      /** Languages present in the repo, ordered by prevalence */
+      languages: z9.array(LanguageSchema),
+      /** Frameworks detected (e.g. "nextjs", "fastapi", "express") */
+      frameworks: z9.array(z9.string()),
+      packageManager: PackageManagerSchema.optional(),
+      buildSystem: BuildSystemSchema.optional(),
+      /** Shell commands known to run the test suite */
+      testCommands: z9.array(z9.string()),
+      /** Shell commands known to run the linter */
+      lintCommands: z9.array(z9.string()),
+      migrationSystem: MigrationSystemSchema.optional(),
+      /** Runtime assumptions such as Node version, Python version, etc. */
+      runtimeAssumptions: z9.array(z9.string()),
+      /** Names of environment variables the repo consumes */
+      envVarNames: z9.array(z9.string()),
+      /** Deployment-related notes (e.g. Docker, Kubernetes, serverless) */
+      deploymentNotes: z9.array(z9.string()),
+      /** Absolute path to the repo root on the agent's filesystem */
+      repoRoot: z9.string(),
+      /** ISO-8601 timestamp of the last profile update */
+      lastIndexed: z9.string().datetime()
+    });
+  }
+});
+
+// packages/schemas/dist/retrieval.js
+import { z as z10 } from "zod";
+var RetrievalRequestSchema, SnippetSchema, RetrievalPacketSchema;
+var init_retrieval = __esm({
+  "packages/schemas/dist/retrieval.js"() {
+    "use strict";
+    RetrievalRequestSchema = z10.object({
+      /** Natural language description of what information is needed */
+      query: z10.string().min(1),
+      /** File path hints that the retrieval system should prioritise */
+      pathsHint: z10.array(z10.string()),
+      /** Symbol names (functions, classes, types) to look up */
+      symbolHint: z10.array(z10.string()),
+      /** Error message fragments to search for in logs and source */
+      errorHint: z10.array(z10.string()),
+      /** Maximum number of files to include in the retrieval packet */
+      maxFiles: z10.number().int().positive(),
+      /** Maximum number of code snippets to include */
+      maxSnippets: z10.number().int().positive(),
+      /** Whether test files should be included in results */
+      includeTests: z10.boolean(),
+      /** Whether config files (tsconfig, package.json, .env.example …) should be included */
+      includeConfigs: z10.boolean()
+    });
+    SnippetSchema = z10.object({
+      /** Repo-relative path of the source file */
+      file: z10.string(),
+      /** 1-based start line */
+      startLine: z10.number().int().positive(),
+      /** 1-based end line (inclusive) */
+      endLine: z10.number().int().positive(),
+      /** The actual source text */
+      content: z10.string(),
+      /** Why this snippet was selected */
+      relevanceNote: z10.string().optional()
+    });
+    RetrievalPacketSchema = z10.object({
+      /** Echo of the original request that produced this packet */
+      request: RetrievalRequestSchema,
+      /** Full file contents or extracts, keyed by repo-relative path */
+      files: z10.record(z10.string(), z10.string()),
+      snippets: z10.array(SnippetSchema),
+      /** One-line architecture note for orientation */
+      architectureNote: z10.string().optional(),
+      /** Note summarising relevant prior attempts at related tasks */
+      priorAttemptNote: z10.string().optional(),
+      /** ISO-8601 timestamp when the packet was assembled */
+      assembledAt: z10.string().datetime()
+    });
+  }
+});
+
+// packages/schemas/dist/dispatch.js
+import { z as z11 } from "zod";
+var DispatchModeSchema, TaskComplexitySchema, AgentRoleSchema, BudgetsSchema, DispatchDecisionSchema;
+var init_dispatch = __esm({
+  "packages/schemas/dist/dispatch.js"() {
+    "use strict";
+    DispatchModeSchema = z11.enum([
+      "single_pass",
+      "multi_agent",
+      "hybrid"
+    ]);
+    TaskComplexitySchema = z11.enum(["low", "medium", "high"]);
+    AgentRoleSchema = z11.enum([
+      "planner",
+      "scout",
+      "editor",
+      "verifier",
+      "researcher"
+    ]);
+    BudgetsSchema = z11.object({
+      /** Maximum prompt tokens across all model calls for this task */
+      promptTokens: z11.number().int().positive(),
+      /** Maximum number of retry cycles allowed per subtask */
+      retries: z11.number().int().nonnegative(),
+      /** Maximum wall-clock seconds before the task is considered timed out */
+      wallClockSec: z11.number().positive()
+    });
+    DispatchDecisionSchema = z11.object({
+      mode: DispatchModeSchema,
+      taskComplexity: TaskComplexitySchema,
+      splitRecommended: z11.boolean(),
+      /** Agent roles that should be spun up for the first wave of execution */
+      initialAgents: z11.array(AgentRoleSchema),
+      budgets: BudgetsSchema
+    });
+  }
+});
+
+// packages/schemas/dist/memory.js
+import { z as z12 } from "zod";
+var RiskLevelSchema, FileSummarySchema, FailureCategorySchema, FailureFingerprintSchema, TaskMemorySchema;
+var init_memory = __esm({
+  "packages/schemas/dist/memory.js"() {
+    "use strict";
+    RiskLevelSchema = z12.enum(["low", "medium", "high", "critical"]);
+    FileSummarySchema = z12.object({
+      /** Repo-relative path of the file */
+      path: z12.string().min(1),
+      /** One-sentence description of the file's role */
+      purpose: z12.string(),
+      /** Primary exported symbols (functions, classes, constants) */
+      mainExports: z12.array(z12.string()),
+      /** Key import paths this file depends on */
+      keyImports: z12.array(z12.string()),
+      /** Logical ownership area (e.g. "auth", "api", "db", "frontend") */
+      ownershipDomain: z12.string(),
+      riskLevel: RiskLevelSchema,
+      /** Paths of test files that cover this file */
+      relatedTests: z12.array(z12.string()),
+      /** SHA-256 or similar hash of the file content at last index time */
+      summaryHash: z12.string(),
+      /** ISO-8601 timestamp of the last indexing pass */
+      lastIndexed: z12.string().datetime()
+    });
+    FailureCategorySchema = z12.enum([
+      "ts_type_drift",
+      "import_path_mismatch",
+      "route_not_registered",
+      "env_var_absent",
+      "schema_runtime_mismatch",
+      "migration_missing",
+      "circular_dependency",
+      "stale_snapshot",
+      "build_error",
+      "test_error",
+      "other"
+    ]);
+    FailureFingerprintSchema = z12.object({
+      /** Short stable identifier (e.g. "ts_type_drift:UserSchema") */
+      fingerprint: z12.string().min(1),
+      category: FailureCategorySchema,
+      /** Human-readable summary of what went wrong */
+      description: z12.string(),
+      /** Files involved in or triggering the failure */
+      affectedFiles: z12.array(z12.string()),
+      /** How many times this fingerprint has been seen */
+      occurrenceCount: z12.number().int().nonnegative(),
+      /** ISO-8601 timestamp of first occurrence */
+      firstSeen: z12.string().datetime(),
+      /** ISO-8601 timestamp of most recent occurrence */
+      lastSeen: z12.string().datetime()
+    });
+    TaskMemorySchema = z12.object({
+      taskId: z12.string().min(1),
+      goal: z12.string(),
+      /** Normalised constraints carried into the task */
+      normalizedConstraints: z12.array(z12.string()),
+      /** Files that were read or modified during the task */
+      filesTouched: z12.array(z12.string()),
+      /** Summary of patches applied (not the full diff) */
+      patchesApplied: z12.array(z12.string()),
+      /** Final validation outcome ("pass" | "fail" | "partial") */
+      validationOutcome: z12.enum(["pass", "fail", "partial"]),
+      /** Human-readable reasons for any failures */
+      failureReasons: z12.array(z12.string()),
+      /** Follow-up tasks or open questions left behind */
+      followUpTodos: z12.array(z12.string()),
+      /**
+       * Subjective quality score 0–100 assigned by the verifier
+       * (100 = perfect, 0 = complete failure)
+       */
+      qualityScore: z12.number().int().min(0).max(100),
+      /** ISO-8601 timestamp when the task completed */
+      completedAt: z12.string().datetime()
+    });
+  }
+});
+
+// packages/schemas/dist/backend.js
+import { z as z13 } from "zod";
+var MessageRoleSchema, ChatMessageSchema, CompletionRequestSchema, TokenUsageSchema, CompletionResponseSchema, StructuredCompletionRequestSchema, BackendHealthSchema, BackendMetricsSchema;
+var init_backend = __esm({
+  "packages/schemas/dist/backend.js"() {
+    "use strict";
+    MessageRoleSchema = z13.enum([
+      "system",
+      "user",
+      "assistant",
+      "tool"
+    ]);
+    ChatMessageSchema = z13.object({
+      role: MessageRoleSchema,
+      content: z13.string(),
+      /** Tool call ID, required when role === "tool" */
+      toolCallId: z13.string().optional(),
+      /** Tool name, required when role === "tool" */
+      name: z13.string().optional()
+    });
+    CompletionRequestSchema = z13.object({
+      messages: z13.array(ChatMessageSchema),
+      /** Override the model used by the backend for this request */
+      model: z13.string().optional(),
+      maxTokens: z13.number().int().positive().optional(),
+      temperature: z13.number().min(0).max(2).optional(),
+      /** Request class for queue routing */
+      queueClass: z13.string().optional(),
+      /** Prefix hash for cache-aware routing */
+      prefixHash: z13.string().optional(),
+      stopSequences: z13.array(z13.string()).optional()
+    });
+    TokenUsageSchema = z13.object({
+      promptTokens: z13.number().int().nonnegative(),
+      completionTokens: z13.number().int().nonnegative(),
+      totalTokens: z13.number().int().nonnegative(),
+      cacheCreationInputTokens: z13.number().int().nonnegative().optional(),
+      cacheReadInputTokens: z13.number().int().nonnegative().optional(),
+      promptEvalCount: z13.number().int().nonnegative().optional()
+    });
+    CompletionResponseSchema = z13.object({
+      content: z13.string(),
+      usage: TokenUsageSchema.optional(),
+      /** Which model actually served the request */
+      model: z13.string().optional(),
+      finishReason: z13.enum(["stop", "length", "tool_calls", "content_filter", "error"]).optional()
+    });
+    StructuredCompletionRequestSchema = CompletionRequestSchema.extend({
+      /**
+       * The Zod schema used to constrain and validate the output.
+       * Stored as unknown here because Zod schemas are not themselves
+       * serialisable — callers pass the live schema object.
+       */
+      outputSchema: z13.unknown(),
+      /** Human-readable label used in prompt injection for the schema */
+      schemaLabel: z13.string().optional()
+    });
+    BackendHealthSchema = z13.object({
+      status: z13.enum(["ok", "degraded", "down"]),
+      latencyMs: z13.number().nonnegative().optional(),
+      /** Fraction of GPU memory currently in use (0–1) */
+      gpuMemoryUsed: z13.number().min(0).max(1).optional(),
+      /** Fraction of KV cache currently in use (0–1) */
+      kvCacheUsed: z13.number().min(0).max(1).optional(),
+      /** Number of requests currently waiting in the queue */
+      queueDepth: z13.number().int().nonnegative().optional(),
+      /** Human-readable note about any degraded state */
+      note: z13.string().optional()
+    });
+    BackendMetricsSchema = z13.object({
+      /** Total requests handled since startup */
+      totalRequests: z13.number().int().nonnegative(),
+      /** Requests that completed successfully */
+      successfulRequests: z13.number().int().nonnegative(),
+      /** Requests that failed */
+      failedRequests: z13.number().int().nonnegative(),
+      /** Average time-to-first-token across recent requests (ms) */
+      avgTtftMs: z13.number().nonnegative().optional(),
+      /** Average end-to-end latency across recent requests (ms) */
+      avgLatencyMs: z13.number().nonnegative().optional(),
+      /** Approximate prefix cache hit rate (0–1) */
+      prefixCacheHitRate: z13.number().min(0).max(1).optional(),
+      /** Number of sleep/wake cycles since startup */
+      sleepWakeCycles: z13.number().int().nonnegative().optional(),
+      /** Number of OOM / preemption / offload events */
+      oomEvents: z13.number().int().nonnegative().optional(),
+      /** ISO-8601 timestamp of when the backend service started */
+      uptimeSince: z13.string().datetime().optional()
+    });
+  }
+});
+
+// packages/schemas/dist/config.js
+import { z as z14 } from "zod";
+var AgentConfigSchema;
+var init_config = __esm({
+  "packages/schemas/dist/config.js"() {
+    "use strict";
+    AgentConfigSchema = z14.object({
+      // -----------------------------------------------------------------------
+      // Model / backend
+      // -----------------------------------------------------------------------
+      /** HuggingFace model ID, e.g. "Qwen/Qwen3.5-122B-A10B" */
+      MODEL_ID: z14.string().min(1),
+      /** Base URL of the primary vLLM OpenAI-compatible endpoint */
+      VLLM_BASE_URL: z14.string().url(),
+      /** API key sent to the vLLM service (often the literal string "EMPTY") */
+      VLLM_API_KEY: z14.string().default("EMPTY"),
+      // -----------------------------------------------------------------------
+      // Context / memory tuning
+      // -----------------------------------------------------------------------
+      /**
+       * Maximum context length for the model.
+       * Should be discovered by startup probing rather than hard-coded.
+       */
+      AGENT_MAX_MODEL_LEN: z14.string().transform((v) => parseInt(v, 10)).pipe(z14.number().int().positive()).default(65536),
+      /** Enable vLLM automatic prefix caching (1 = enabled) */
+      AGENT_ENABLE_PREFIX_CACHING: z14.string().transform((v) => v === "1" || v.toLowerCase() === "true").pipe(z14.boolean()).default(true),
+      /** Enable vLLM sleep mode when idle (1 = enabled) */
+      AGENT_ENABLE_SLEEP_MODE: z14.string().transform((v) => v === "1" || v.toLowerCase() === "true").pipe(z14.boolean()).default(true),
+      // -----------------------------------------------------------------------
+      // Agent behaviour
+      // -----------------------------------------------------------------------
+      /** Maximum retry cycles per subtask */
+      AGENT_MAX_RETRIES: z14.string().transform((v) => parseInt(v, 10)).pipe(z14.number().int().nonnegative()).default(3),
+      /** Maximum number of parallel subagents that may run simultaneously */
+      AGENT_MAX_PARALLEL_SUBAGENTS: z14.string().transform((v) => parseInt(v, 10)).pipe(z14.number().int().positive()).default(4),
+      // -----------------------------------------------------------------------
+      // Retrieval limits
+      // -----------------------------------------------------------------------
+      /** Maximum files included in a single retrieval packet */
+      AGENT_RETRIEVAL_MAX_FILES: z14.string().transform((v) => parseInt(v, 10)).pipe(z14.number().int().positive()).default(8),
+      /** Maximum snippets included in a single retrieval packet */
+      AGENT_RETRIEVAL_MAX_SNIPPETS: z14.string().transform((v) => parseInt(v, 10)).pipe(z14.number().int().positive()).default(16),
+      // -----------------------------------------------------------------------
+      // File paths
+      // -----------------------------------------------------------------------
+      /** Directory where agent working trees and artefacts are written */
+      AGENT_WORK_ROOT: z14.string().min(1),
+      /** Directory where the indexer stores its indexes and embeddings */
+      AGENT_INDEX_ROOT: z14.string().min(1),
+      // -----------------------------------------------------------------------
+      // Optional models
+      // -----------------------------------------------------------------------
+      /** Model ID or endpoint for the embedding model (optional) */
+      AGENT_EMBEDDING_MODEL: z14.string().optional(),
+      /**
+       * Optional smaller local model for triage/summarisation tasks.
+       * When set, used in Profile C (hybrid mode).
+       */
+      AGENT_SMALL_MODEL: z14.string().optional()
+    });
+  }
+});
+
+// packages/schemas/dist/queue.js
+import { z as z15 } from "zod";
+var QueueClassSchema;
+var init_queue = __esm({
+  "packages/schemas/dist/queue.js"() {
+    "use strict";
+    QueueClassSchema = z15.enum([
+      /** CLI and direct user-facing requests; lowest latency target */
+      "interactive-high",
+      /** Planner role requests; moderate priority */
+      "planner-medium",
+      /** Editor role patch generation; high priority, may be long-running */
+      "editor-high",
+      /** Verifier role review; high priority, usually short */
+      "verifier-high",
+      /** Memory write-back and summarisation; background, low priority */
+      "memory-low",
+      /** Bulk indexing and embedding; lowest priority, best-effort */
+      "batch-indexing-low"
+    ]);
+  }
+});
+
+// packages/schemas/dist/operational-world.js
+import { z as z16 } from "zod";
+function addDuplicateIdIssues(values, path3, ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < values.length; index++) {
+    const value = values[index];
+    if (seen.has(value)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [path3, index],
+        message: `duplicate identifier: ${value}`
+      });
+    }
+    seen.add(value);
+  }
+}
+function validateGraphCollections(value, ctx) {
+  addDuplicateIdIssues(value.nodes.map((item) => item.nodeId), "nodes", ctx);
+  addDuplicateIdIssues(value.edges.map((item) => item.edgeId), "edges", ctx);
+  addDuplicateIdIssues(value.sourceBindings.map((item) => item.bindingId), "sourceBindings", ctx);
+  addDuplicateIdIssues(value.evidenceRefs.map((item) => item.evidenceId), "evidenceRefs", ctx);
+  addDuplicateIdIssues(value.claims.map((item) => item.claimId), "claims", ctx);
+  addDuplicateIdIssues(value.conflicts.map((item) => item.conflictId), "conflicts", ctx);
+  const nodeIds = new Set(value.nodes.map((item) => item.nodeId));
+  const bindingIds = new Set(value.sourceBindings.map((item) => item.bindingId));
+  const evidenceIds = new Set(value.evidenceRefs.map((item) => item.evidenceId));
+  const claimIds = new Set(value.claims.map((item) => item.claimId));
+  const conflictIds = new Set(value.conflicts.map((item) => item.conflictId));
+  value.nodes.forEach((node, index) => {
+    if (node.parentNodeId && !nodeIds.has(node.parentNodeId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["nodes", index, "parentNodeId"],
+        message: `unknown parent node: ${node.parentNodeId}`
+      });
+    }
+    node.bindingIds.forEach((id2) => {
+      if (!bindingIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["nodes", index, "bindingIds"],
+          message: `unknown source binding: ${id2}`
+        });
+      }
+    });
+    node.evidenceRefIds.forEach((id2) => {
+      if (!evidenceIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["nodes", index, "evidenceRefIds"],
+          message: `unknown evidence reference: ${id2}`
+        });
+      }
+    });
+    if (node.reference?.type === "claim" && !claimIds.has(node.reference.claimId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["nodes", index, "reference", "claimId"],
+        message: `unknown claim: ${node.reference.claimId}`
+      });
+    }
+    if (node.reference?.type === "conflict" && !conflictIds.has(node.reference.conflictId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["nodes", index, "reference", "conflictId"],
+        message: `unknown conflict: ${node.reference.conflictId}`
+      });
+    }
+    if (node.reference?.type === "evidence" && !evidenceIds.has(node.reference.evidenceId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["nodes", index, "reference", "evidenceId"],
+        message: `unknown evidence reference: ${node.reference.evidenceId}`
+      });
+    }
+    if (node.reference?.type === "source" && !bindingIds.has(node.reference.bindingId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["nodes", index, "reference", "bindingId"],
+        message: `unknown source binding: ${node.reference.bindingId}`
+      });
+    }
+    node.actionContract?.preconditions.forEach((precondition) => {
+      precondition.evidenceRefIds.forEach((id2) => {
+        if (!evidenceIds.has(id2)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["nodes", index, "actionContract", "preconditions"],
+            message: `unknown precondition evidence reference: ${id2}`
+          });
+        }
+      });
+    });
+    node.actionContract?.mutations.forEach((mutation, mutationIndex) => {
+      const target = mutation.target;
+      const targetExists = target.type === "artifact" || target.type === "node" && nodeIds.has(target.nodeId) || target.type === "claim" && claimIds.has(target.claimId) || target.type === "conflict" && conflictIds.has(target.conflictId) || target.type === "evidence" && evidenceIds.has(target.evidenceId) || target.type === "source" && bindingIds.has(target.bindingId);
+      if (!targetExists) {
+        ctx.addIssue({
+          code: "custom",
+          path: [
+            "nodes",
+            index,
+            "actionContract",
+            "mutations",
+            mutationIndex,
+            "target"
+          ],
+          message: "action mutation target is absent from the graph"
+        });
+      }
+    });
+  });
+  value.edges.forEach((edge, index) => {
+    if (!nodeIds.has(edge.sourceNodeId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["edges", index, "sourceNodeId"],
+        message: `unknown source node: ${edge.sourceNodeId}`
+      });
+    }
+    if (!nodeIds.has(edge.targetNodeId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["edges", index, "targetNodeId"],
+        message: `unknown target node: ${edge.targetNodeId}`
+      });
+    }
+    edge.evidenceRefIds.forEach((id2) => {
+      if (!evidenceIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["edges", index, "evidenceRefIds"],
+          message: `unknown evidence reference: ${id2}`
+        });
+      }
+    });
+  });
+  value.evidenceRefs.forEach((evidence, index) => {
+    if (!bindingIds.has(evidence.bindingId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["evidenceRefs", index, "bindingId"],
+        message: `unknown source binding: ${evidence.bindingId}`
+      });
+    }
+  });
+  value.claims.forEach((claim, index) => {
+    if (claim.subjectNodeId && !nodeIds.has(claim.subjectNodeId)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["claims", index, "subjectNodeId"],
+        message: `unknown claim subject node: ${claim.subjectNodeId}`
+      });
+    }
+    claim.evidenceRefIds.forEach((id2) => {
+      if (!evidenceIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["claims", index, "evidenceRefIds"],
+          message: `unknown evidence reference: ${id2}`
+        });
+      }
+    });
+    claim.dependsOnClaimIds.forEach((id2) => {
+      if (!claimIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["claims", index, "dependsOnClaimIds"],
+          message: `unknown claim dependency: ${id2}`
+        });
+      }
+    });
+  });
+  value.conflicts.forEach((conflict, index) => {
+    conflict.claimIds.forEach((id2) => {
+      if (!claimIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["conflicts", index, "claimIds"],
+          message: `unknown conflict claim: ${id2}`
+        });
+      }
+    });
+    conflict.evidenceRefIds.forEach((id2) => {
+      if (!evidenceIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["conflicts", index, "evidenceRefIds"],
+          message: `unknown evidence reference: ${id2}`
+        });
+      }
+    });
+    conflict.resolution?.evidenceRefIds.forEach((id2) => {
+      if (!evidenceIds.has(id2)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["conflicts", index, "resolution", "evidenceRefIds"],
+          message: `unknown resolution evidence reference: ${id2}`
+        });
+      }
+    });
+  });
+}
+var OPERATIONAL_WORLD_SCHEMA_VERSION, OperationalWorldSchemaVersionSchema, OperationalWorldIdSchema, OperationalWorldRevisionSchema, ConfidenceSchema, OperationalFactScopeSchema, OperationalMetadataDerivedFieldSchema, OperationalMetadataProvenanceSchema, JsonValueSchema, LineRangeLocatorSchema, CharacterRangeLocatorSchema, PageRangeLocatorSchema, SheetRangeLocatorSchema, TableRangeLocatorSchema, JsonPathLocatorSchema, HeadingLocatorSchema, FieldLocatorSchema, UriFragmentLocatorSchema, EvidenceLocatorSchema, SourceAuthoritySchema, SourceFreshnessSchema, SourceReadPolicySchema, SourceBindingSchema, EvidenceRoleSchema, EvidenceRefSchema, ClaimKindSchema, ClaimPolaritySchema, ClaimStatusSchema, WorkGraphNodeAuthoritySchema, ClaimSchema, ConflictKindSchema, ConflictStatusSchema, ConflictResolutionSchema, ConflictSchema, WorkGraphNodeKindSchema, WorkGraphNodeStatusSchema, WorkGraphTargetRefSchema, WorkActionPreconditionSchema, WorkActionMutationSchema, WorkActionApprovalSchema, WorkActionContractSchema, WorkGraphNodeReferenceSchema, WorkGraphNodeSchema, WorkGraphEdgeKindSchema, WorkGraphEdgeSchema, WorkGraphSchema, WorldPatchOperationSchema, WorldPatchSchema, ValidationIssueSeveritySchema, OperationalValidationIssueSchema, OperationalValidationStatusSchema, OperationalValidationResultSchema, ValidationArtifactHashSchema, OperationalValidationReceiptSchema, ReasoningSliceSelectionSchema, ReasoningSliceSchema;
+var init_operational_world = __esm({
+  "packages/schemas/dist/operational-world.js"() {
+    "use strict";
+    OPERATIONAL_WORLD_SCHEMA_VERSION = "omnius.operational-world.v1";
+    OperationalWorldSchemaVersionSchema = z16.literal(OPERATIONAL_WORLD_SCHEMA_VERSION);
+    OperationalWorldIdSchema = z16.string().trim().min(1).max(256);
+    OperationalWorldRevisionSchema = z16.string().trim().min(1).max(256);
+    ConfidenceSchema = z16.number().finite().min(0).max(1);
+    OperationalFactScopeSchema = z16.object({
+      kind: z16.enum([
+        "global",
+        "run",
+        "task",
+        "session",
+        "chat",
+        "thread",
+        "conversation",
+        "legacy_unscoped"
+      ]),
+      scopeId: OperationalWorldIdSchema,
+      taskEpoch: z16.number().int().nonnegative().optional()
+    }).strict();
+    OperationalMetadataDerivedFieldSchema = z16.enum([
+      "source_evidence",
+      "confidence",
+      "revision",
+      "temporal_validity",
+      "scope",
+      "metadata_provenance"
+    ]);
+    OperationalMetadataProvenanceSchema = z16.discriminatedUnion("kind", [
+      z16.object({ kind: z16.literal("native") }).strict(),
+      z16.object({
+        kind: z16.literal("legacy_derived"),
+        marker: z16.literal("metadata-only-no-semantic-assertion"),
+        sourceRecordId: OperationalWorldIdSchema,
+        derivedFields: z16.array(OperationalMetadataDerivedFieldSchema).min(1).max(6)
+      }).strict()
+    ]);
+    JsonValueSchema = z16.lazy(() => z16.union([
+      z16.string(),
+      z16.number().finite(),
+      z16.boolean(),
+      z16.null(),
+      z16.array(JsonValueSchema),
+      z16.record(z16.string(), JsonValueSchema)
+    ]));
+    LineRangeLocatorSchema = z16.object({
+      type: z16.literal("line_range"),
+      startLine: z16.number().int().positive(),
+      endLine: z16.number().int().positive()
+    }).strict();
+    CharacterRangeLocatorSchema = z16.object({
+      type: z16.literal("character_range"),
+      startOffset: z16.number().int().nonnegative(),
+      /** Exclusive end offset. */
+      endOffset: z16.number().int().positive()
+    }).strict();
+    PageRangeLocatorSchema = z16.object({
+      type: z16.literal("page_range"),
+      startPage: z16.number().int().positive(),
+      endPage: z16.number().int().positive()
+    }).strict();
+    SheetRangeLocatorSchema = z16.object({
+      type: z16.literal("sheet_range"),
+      sheetName: z16.string().trim().min(1).max(256),
+      startRow: z16.number().int().positive().optional(),
+      endRow: z16.number().int().positive().optional(),
+      startColumn: z16.number().int().positive().optional(),
+      endColumn: z16.number().int().positive().optional()
+    }).strict();
+    TableRangeLocatorSchema = z16.object({
+      type: z16.literal("table_range"),
+      table: z16.string().trim().min(1).max(256),
+      startRow: z16.number().int().nonnegative(),
+      endRow: z16.number().int().nonnegative(),
+      columns: z16.array(z16.string().trim().min(1).max(256)).max(128).optional()
+    }).strict();
+    JsonPathLocatorSchema = z16.object({
+      type: z16.literal("json_path"),
+      path: z16.string().trim().min(1).max(2048)
+    }).strict();
+    HeadingLocatorSchema = z16.object({
+      type: z16.literal("heading"),
+      heading: z16.string().trim().min(1).max(1024),
+      occurrence: z16.number().int().positive().optional()
+    }).strict();
+    FieldLocatorSchema = z16.object({
+      type: z16.literal("field"),
+      path: z16.array(z16.string().trim().min(1).max(256)).min(1).max(64),
+      recordKey: z16.string().trim().min(1).max(512).optional()
+    }).strict();
+    UriFragmentLocatorSchema = z16.object({
+      type: z16.literal("uri_fragment"),
+      fragment: z16.string().trim().min(1).max(2048)
+    }).strict();
+    EvidenceLocatorSchema = z16.discriminatedUnion("type", [
+      LineRangeLocatorSchema,
+      CharacterRangeLocatorSchema,
+      PageRangeLocatorSchema,
+      SheetRangeLocatorSchema,
+      TableRangeLocatorSchema,
+      JsonPathLocatorSchema,
+      HeadingLocatorSchema,
+      FieldLocatorSchema,
+      UriFragmentLocatorSchema
+    ]).superRefine((locator, ctx) => {
+      if (locator.type === "line_range" && locator.endLine < locator.startLine) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["endLine"],
+          message: "endLine must be greater than or equal to startLine"
+        });
+      }
+      if (locator.type === "character_range" && locator.endOffset <= locator.startOffset) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["endOffset"],
+          message: "endOffset must be greater than startOffset"
+        });
+      }
+      if (locator.type === "page_range" && locator.endPage < locator.startPage) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["endPage"],
+          message: "endPage must be greater than or equal to startPage"
+        });
+      }
+      if (locator.type === "sheet_range") {
+        if (locator.endRow !== void 0 && locator.startRow === void 0) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["startRow"],
+            message: "startRow is required when endRow is present"
+          });
+        } else if (locator.startRow !== void 0 && locator.endRow !== void 0 && locator.endRow < locator.startRow) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["endRow"],
+            message: "endRow must be greater than or equal to startRow"
+          });
+        }
+        if (locator.endColumn !== void 0 && locator.startColumn === void 0) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["startColumn"],
+            message: "startColumn is required when endColumn is present"
+          });
+        } else if (locator.startColumn !== void 0 && locator.endColumn !== void 0 && locator.endColumn < locator.startColumn) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["endColumn"],
+            message: "endColumn must be greater than or equal to startColumn"
+          });
+        }
+      }
+      if (locator.type === "table_range" && locator.endRow < locator.startRow) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["endRow"],
+          message: "endRow must be greater than or equal to startRow"
+        });
+      }
+    });
+    SourceAuthoritySchema = z16.enum([
+      "authoritative",
+      "primary",
+      "secondary",
+      "derived",
+      "unknown"
+    ]);
+    SourceFreshnessSchema = z16.enum(["fresh", "stale", "unknown"]);
+    SourceReadPolicySchema = z16.enum([
+      "immutable",
+      "snapshot",
+      "refresh_before_use",
+      "live"
+    ]);
+    SourceBindingSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      bindingId: OperationalWorldIdSchema,
+      sourceId: OperationalWorldIdSchema,
+      /** URI, repo-relative path, or external source identifier. */
+      sourceUri: z16.string().trim().min(1).max(4096),
+      sourceRevision: OperationalWorldRevisionSchema,
+      sourceHash: z16.string().trim().min(1).max(512).optional(),
+      locator: EvidenceLocatorSchema,
+      authority: SourceAuthoritySchema,
+      freshness: SourceFreshnessSchema,
+      readPolicy: SourceReadPolicySchema,
+      observedAt: z16.string().datetime(),
+      confidence: ConfidenceSchema,
+      notes: z16.string().trim().max(2e3).optional()
+    }).strict();
+    EvidenceRoleSchema = z16.enum([
+      "supports",
+      "refutes",
+      "context",
+      "verification",
+      "blocker"
+    ]);
+    EvidenceRefSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      evidenceId: OperationalWorldIdSchema,
+      bindingId: OperationalWorldIdSchema,
+      role: EvidenceRoleSchema,
+      excerpt: z16.string().max(4e3).optional(),
+      excerptHash: z16.string().trim().min(1).max(512).optional(),
+      observedAt: z16.string().datetime(),
+      confidence: ConfidenceSchema,
+      tags: z16.array(z16.string().trim().min(1).max(128)).max(64)
+    }).strict();
+    ClaimKindSchema = z16.enum([
+      "fact",
+      "inference",
+      "requirement",
+      "constraint",
+      "outcome"
+    ]);
+    ClaimPolaritySchema = z16.enum(["positive", "negative"]);
+    ClaimStatusSchema = z16.enum([
+      "proposed",
+      "supported",
+      "refuted",
+      "contested",
+      "unverified",
+      "blocked"
+    ]);
+    WorkGraphNodeAuthoritySchema = z16.enum([
+      "explicit",
+      "inferred",
+      "adopted"
+    ]);
+    ClaimSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      claimId: OperationalWorldIdSchema,
+      statement: z16.string().trim().min(1).max(4e3),
+      kind: ClaimKindSchema,
+      polarity: ClaimPolaritySchema,
+      status: ClaimStatusSchema,
+      confidence: ConfidenceSchema,
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).max(256),
+      dependsOnClaimIds: z16.array(OperationalWorldIdSchema).max(256),
+      tags: z16.array(z16.string().trim().min(1).max(128)).max(64),
+      /** Structured proposition fields used to group competing claims. */
+      subjectNodeId: OperationalWorldIdSchema.optional(),
+      predicate: z16.string().trim().min(1).max(512).optional(),
+      objectValue: JsonValueSchema.optional(),
+      validFrom: z16.string().datetime().optional(),
+      validTo: z16.string().datetime().optional(),
+      authority: WorkGraphNodeAuthoritySchema.optional()
+    }).strict().superRefine((claim, ctx) => {
+      if (claim.validFrom !== void 0 && claim.validTo !== void 0 && Date.parse(claim.validTo) < Date.parse(claim.validFrom)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["validTo"],
+          message: "validTo must not precede validFrom"
+        });
+      }
+    });
+    ConflictKindSchema = z16.enum([
+      "contradiction",
+      "source_disagreement",
+      "temporal",
+      "schema",
+      "authority"
+    ]);
+    ConflictStatusSchema = z16.enum([
+      "open",
+      "resolved",
+      "accepted_uncertainty"
+    ]);
+    ConflictResolutionSchema = z16.object({
+      decision: z16.string().trim().min(1).max(2e3),
+      rationale: z16.string().trim().min(1).max(4e3),
+      resolvedBy: z16.string().trim().min(1).max(256),
+      resolvedAt: z16.string().datetime(),
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).max(256)
+    }).strict();
+    ConflictSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      conflictId: OperationalWorldIdSchema,
+      kind: ConflictKindSchema,
+      summary: z16.string().trim().min(1).max(4e3),
+      claimIds: z16.array(OperationalWorldIdSchema).min(2).max(64),
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).max(256),
+      status: ConflictStatusSchema,
+      resolution: ConflictResolutionSchema.optional()
+    }).strict().superRefine((conflict, ctx) => {
+      if (new Set(conflict.claimIds).size !== conflict.claimIds.length) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["claimIds"],
+          message: "claimIds must contain at least two distinct claims"
+        });
+      }
+      if (conflict.status !== "open" && !conflict.resolution) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["resolution"],
+          message: "a non-open conflict requires a resolution record"
+        });
+      }
+    });
+    WorkGraphNodeKindSchema = z16.enum([
+      "objective",
+      "requirement",
+      "document",
+      "section",
+      "task",
+      "feature",
+      "component",
+      "module",
+      "acceptance",
+      "symbol",
+      "entity",
+      "event",
+      "action",
+      "mutation",
+      "verification",
+      "blocker",
+      "policy",
+      "artifact",
+      "decision",
+      "claim",
+      "evidence",
+      "conflict",
+      "validation",
+      "actor",
+      "conversation",
+      "relationship"
+    ]);
+    WorkGraphNodeStatusSchema = z16.enum([
+      "proposed",
+      "active",
+      "blocked",
+      "complete",
+      "invalid",
+      "superseded"
+    ]);
+    WorkGraphTargetRefSchema = z16.discriminatedUnion("type", [
+      z16.object({ type: z16.literal("node"), nodeId: OperationalWorldIdSchema }).strict(),
+      z16.object({ type: z16.literal("claim"), claimId: OperationalWorldIdSchema }).strict(),
+      z16.object({
+        type: z16.literal("conflict"),
+        conflictId: OperationalWorldIdSchema
+      }).strict(),
+      z16.object({
+        type: z16.literal("evidence"),
+        evidenceId: OperationalWorldIdSchema
+      }).strict(),
+      z16.object({ type: z16.literal("source"), bindingId: OperationalWorldIdSchema }).strict(),
+      z16.object({
+        type: z16.literal("artifact"),
+        uri: z16.string().trim().min(1).max(4096),
+        revision: OperationalWorldRevisionSchema.optional()
+      }).strict()
+    ]);
+    WorkActionPreconditionSchema = z16.object({
+      preconditionId: OperationalWorldIdSchema,
+      description: z16.string().trim().min(1).max(2e3),
+      status: z16.enum(["unknown", "satisfied", "unsatisfied", "waived"]),
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).max(256)
+    }).strict();
+    WorkActionMutationSchema = z16.object({
+      mutationId: OperationalWorldIdSchema,
+      kind: z16.enum(["create", "update", "delete", "execute", "deliver"]),
+      target: WorkGraphTargetRefSchema,
+      description: z16.string().trim().min(1).max(2e3),
+      reversible: z16.boolean()
+    }).strict();
+    WorkActionApprovalSchema = z16.object({
+      required: z16.boolean(),
+      status: z16.enum(["not_required", "pending", "approved", "rejected"]),
+      approvedBy: z16.string().trim().min(1).max(256).optional(),
+      approvedAt: z16.string().datetime().optional()
+    }).strict().superRefine((approval, ctx) => {
+      if (!approval.required && approval.status !== "not_required") {
+        ctx.addIssue({
+          code: "custom",
+          path: ["status"],
+          message: "approval status must be not_required when approval is not required"
+        });
+      }
+      if (approval.required && approval.status === "not_required") {
+        ctx.addIssue({
+          code: "custom",
+          path: ["status"],
+          message: "required approval cannot have not_required status"
+        });
+      }
+      if (approval.status === "approved" && (!approval.approvedBy || !approval.approvedAt)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["approvedBy"],
+          message: "approved actions require approvedBy and approvedAt"
+        });
+      }
+    });
+    WorkActionContractSchema = z16.object({
+      preconditions: z16.array(WorkActionPreconditionSchema).max(256),
+      mutations: z16.array(WorkActionMutationSchema).max(256),
+      sideEffects: z16.array(z16.string().trim().min(1).max(2e3)).max(256),
+      approval: WorkActionApprovalSchema,
+      authority: z16.enum([
+        "operator_explicit",
+        "delegated_scope",
+        "policy",
+        "none"
+      ]),
+      risk: z16.enum(["none", "low", "medium", "high", "critical"])
+    }).strict();
+    WorkGraphNodeReferenceSchema = z16.discriminatedUnion("type", [
+      z16.object({ type: z16.literal("claim"), claimId: OperationalWorldIdSchema }).strict(),
+      z16.object({
+        type: z16.literal("conflict"),
+        conflictId: OperationalWorldIdSchema
+      }).strict(),
+      z16.object({
+        type: z16.literal("evidence"),
+        evidenceId: OperationalWorldIdSchema
+      }).strict(),
+      z16.object({ type: z16.literal("source"), bindingId: OperationalWorldIdSchema }).strict()
+    ]);
+    WorkGraphNodeSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      nodeId: OperationalWorldIdSchema,
+      kind: WorkGraphNodeKindSchema,
+      label: z16.string().trim().min(1).max(1e3),
+      description: z16.string().trim().max(4e3).optional(),
+      status: WorkGraphNodeStatusSchema,
+      authority: WorkGraphNodeAuthoritySchema,
+      parentNodeId: OperationalWorldIdSchema.optional(),
+      bindingIds: z16.array(OperationalWorldIdSchema).min(1).max(256),
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).min(1).max(256),
+      confidence: ConfidenceSchema,
+      revision: OperationalWorldRevisionSchema,
+      validFrom: z16.string().datetime(),
+      validTo: z16.string().datetime().optional(),
+      scope: OperationalFactScopeSchema,
+      taskEpoch: z16.number().int().nonnegative().optional(),
+      metadataProvenance: OperationalMetadataProvenanceSchema,
+      reference: WorkGraphNodeReferenceSchema.optional(),
+      actionContract: WorkActionContractSchema.optional(),
+      attributes: z16.record(z16.string(), JsonValueSchema)
+    }).strict().superRefine((node, ctx) => {
+      const expectedReference = node.kind === "claim" ? "claim" : node.kind === "conflict" ? "conflict" : node.kind === "evidence" ? "evidence" : null;
+      if (expectedReference && node.reference?.type !== expectedReference) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["reference"],
+          message: `${node.kind} nodes require a matching ${expectedReference} reference`
+        });
+      }
+      if (node.parentNodeId === node.nodeId) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["parentNodeId"],
+          message: "a node cannot be its own parent"
+        });
+      }
+      if ((node.kind === "action" || node.kind === "mutation") && !node.actionContract) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["actionContract"],
+          message: `${node.kind} nodes require an action contract`
+        });
+      }
+      if (node.validFrom && node.validTo && Date.parse(node.validTo) < Date.parse(node.validFrom)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["validTo"],
+          message: "validTo must not precede validFrom"
+        });
+      }
+      if (node.scope?.taskEpoch !== void 0 && node.taskEpoch !== void 0 && node.scope.taskEpoch !== node.taskEpoch) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["taskEpoch"],
+          message: "taskEpoch must match scope.taskEpoch"
+        });
+      }
+    });
+    WorkGraphEdgeKindSchema = z16.enum([
+      "contains",
+      "part_of",
+      "decomposes_to",
+      "depends_on",
+      "satisfies",
+      "produces",
+      "supports",
+      "refutes",
+      "evidences",
+      "verified_by",
+      "evidenced_by",
+      "contradicted_by",
+      "blocked_by",
+      "derived_from",
+      "implements",
+      "modifies",
+      "validates",
+      "conflicts_with",
+      "supersedes",
+      "mentions",
+      "governs",
+      "blocks",
+      "assigned_to",
+      "attempts",
+      "invalidates",
+      "resolves",
+      "synthesizes",
+      "replied_to",
+      "reacted_to",
+      "delivered_to",
+      "owned_by",
+      "relates_to"
+    ]);
+    WorkGraphEdgeSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      edgeId: OperationalWorldIdSchema,
+      sourceNodeId: OperationalWorldIdSchema,
+      targetNodeId: OperationalWorldIdSchema,
+      kind: WorkGraphEdgeKindSchema,
+      directed: z16.boolean(),
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).min(1).max(256),
+      confidence: ConfidenceSchema,
+      revision: OperationalWorldRevisionSchema,
+      validFrom: z16.string().datetime(),
+      validTo: z16.string().datetime().optional(),
+      scope: OperationalFactScopeSchema,
+      taskEpoch: z16.number().int().nonnegative().optional(),
+      metadataProvenance: OperationalMetadataProvenanceSchema,
+      attributes: z16.record(z16.string(), JsonValueSchema)
+    }).strict().superRefine((edge, ctx) => {
+      if (edge.sourceNodeId === edge.targetNodeId) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["targetNodeId"],
+          message: "self-referential edges are not permitted"
+        });
+      }
+      if (edge.validFrom && edge.validTo && Date.parse(edge.validTo) < Date.parse(edge.validFrom)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["validTo"],
+          message: "validTo must not precede validFrom"
+        });
+      }
+      if (edge.scope?.taskEpoch !== void 0 && edge.taskEpoch !== void 0 && edge.scope.taskEpoch !== edge.taskEpoch) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["taskEpoch"],
+          message: "taskEpoch must match scope.taskEpoch"
+        });
+      }
+    });
+    WorkGraphSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      graphId: OperationalWorldIdSchema,
+      revision: OperationalWorldRevisionSchema,
+      previousRevision: OperationalWorldRevisionSchema.optional(),
+      title: z16.string().trim().min(1).max(1e3),
+      nodes: z16.array(WorkGraphNodeSchema).max(1e5),
+      edges: z16.array(WorkGraphEdgeSchema).max(25e4),
+      sourceBindings: z16.array(SourceBindingSchema).max(1e5),
+      evidenceRefs: z16.array(EvidenceRefSchema).max(25e4),
+      claims: z16.array(ClaimSchema).max(1e5),
+      conflicts: z16.array(ConflictSchema).max(1e5),
+      createdAt: z16.string().datetime(),
+      updatedAt: z16.string().datetime()
+    }).strict().superRefine(validateGraphCollections);
+    WorldPatchOperationSchema = z16.discriminatedUnion("op", [
+      z16.object({ op: z16.literal("upsert_node"), node: WorkGraphNodeSchema }).strict(),
+      z16.object({
+        op: z16.literal("remove_node"),
+        nodeId: OperationalWorldIdSchema,
+        cascade: z16.boolean()
+      }).strict(),
+      z16.object({ op: z16.literal("upsert_edge"), edge: WorkGraphEdgeSchema }).strict(),
+      z16.object({ op: z16.literal("remove_edge"), edgeId: OperationalWorldIdSchema }).strict(),
+      z16.object({
+        op: z16.literal("upsert_source_binding"),
+        sourceBinding: SourceBindingSchema
+      }).strict(),
+      z16.object({
+        op: z16.literal("remove_source_binding"),
+        bindingId: OperationalWorldIdSchema
+      }).strict(),
+      z16.object({
+        op: z16.literal("upsert_evidence_ref"),
+        evidenceRef: EvidenceRefSchema
+      }).strict(),
+      z16.object({
+        op: z16.literal("remove_evidence_ref"),
+        evidenceId: OperationalWorldIdSchema
+      }).strict(),
+      z16.object({ op: z16.literal("upsert_claim"), claim: ClaimSchema }).strict(),
+      z16.object({
+        op: z16.literal("remove_claim"),
+        claimId: OperationalWorldIdSchema
+      }).strict(),
+      z16.object({ op: z16.literal("upsert_conflict"), conflict: ConflictSchema }).strict(),
+      z16.object({
+        op: z16.literal("remove_conflict"),
+        conflictId: OperationalWorldIdSchema
+      }).strict()
+    ]);
+    WorldPatchSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      patchId: OperationalWorldIdSchema,
+      graphId: OperationalWorldIdSchema,
+      /** Optimistic-concurrency precondition. */
+      baseRevision: OperationalWorldRevisionSchema,
+      targetRevision: OperationalWorldRevisionSchema,
+      operations: z16.array(WorldPatchOperationSchema).min(1).max(1e4),
+      rationale: z16.string().trim().min(1).max(4e3),
+      createdBy: z16.string().trim().min(1).max(256),
+      createdAt: z16.string().datetime()
+    }).strict().superRefine((patch, ctx) => {
+      if (patch.baseRevision === patch.targetRevision) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["targetRevision"],
+          message: "targetRevision must differ from baseRevision"
+        });
+      }
+    });
+    ValidationIssueSeveritySchema = z16.enum([
+      "info",
+      "warning",
+      "error"
+    ]);
+    OperationalValidationIssueSchema = z16.object({
+      code: z16.string().trim().min(1).max(128),
+      severity: ValidationIssueSeveritySchema,
+      message: z16.string().trim().min(1).max(4e3),
+      path: z16.array(z16.union([z16.string(), z16.number().int().nonnegative()])).max(64),
+      nodeId: OperationalWorldIdSchema.optional(),
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).max(256)
+    }).strict();
+    OperationalValidationStatusSchema = z16.enum([
+      "pass",
+      "fail",
+      "partial"
+    ]);
+    OperationalValidationResultSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      valid: z16.boolean(),
+      status: OperationalValidationStatusSchema,
+      checkedRevision: OperationalWorldRevisionSchema,
+      issues: z16.array(OperationalValidationIssueSchema).max(1e4),
+      checkedAt: z16.string().datetime()
+    }).strict().superRefine((result, ctx) => {
+      const hasErrors = result.issues.some((issue2) => issue2.severity === "error");
+      if (result.valid !== (result.status === "pass")) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["valid"],
+          message: "valid must be true exactly when status is pass"
+        });
+      }
+      if (result.status === "pass" && hasErrors) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["issues"],
+          message: "a passing result cannot contain error issues"
+        });
+      }
+      if (result.status === "fail" && !hasErrors) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["issues"],
+          message: "a failing result must contain at least one error issue"
+        });
+      }
+    });
+    ValidationArtifactHashSchema = z16.object({
+      uri: z16.string().trim().min(1).max(4096),
+      algorithm: z16.enum(["sha256", "sha512", "blake3"]),
+      digest: z16.string().trim().min(1).max(512)
+    }).strict();
+    OperationalValidationReceiptSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      receiptId: OperationalWorldIdSchema,
+      graphId: OperationalWorldIdSchema,
+      patchId: OperationalWorldIdSchema.optional(),
+      baseRevision: OperationalWorldRevisionSchema,
+      resultRevision: OperationalWorldRevisionSchema,
+      validator: z16.object({
+        name: z16.string().trim().min(1).max(256),
+        version: z16.string().trim().min(1).max(128)
+      }).strict(),
+      startedAt: z16.string().datetime(),
+      finishedAt: z16.string().datetime(),
+      result: OperationalValidationResultSchema,
+      evidenceRefIds: z16.array(OperationalWorldIdSchema).max(1e4),
+      artifactHashes: z16.array(ValidationArtifactHashSchema).max(1e4)
+    }).strict().superRefine((receipt, ctx) => {
+      if (receipt.result.checkedRevision !== receipt.resultRevision) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["result", "checkedRevision"],
+          message: "checkedRevision must equal resultRevision"
+        });
+      }
+      if (Date.parse(receipt.finishedAt) < Date.parse(receipt.startedAt)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["finishedAt"],
+          message: "finishedAt must not precede startedAt"
+        });
+      }
+    });
+    ReasoningSliceSelectionSchema = z16.object({
+      strategy: z16.enum(["exact", "lexical", "semantic", "graph", "hybrid"]),
+      graphHops: z16.number().int().nonnegative().max(32),
+      maxCharacters: z16.number().int().positive(),
+      truncated: z16.boolean(),
+      omissions: z16.array(z16.string().trim().min(1).max(1e3)).max(256),
+      evidenceRoles: z16.array(EvidenceRoleSchema).max(5)
+    }).strict();
+    ReasoningSliceSchema = z16.object({
+      schemaVersion: OperationalWorldSchemaVersionSchema,
+      sliceId: OperationalWorldIdSchema,
+      graphId: OperationalWorldIdSchema,
+      revision: OperationalWorldRevisionSchema,
+      objective: z16.string().trim().min(1).max(4e3),
+      focusNodeIds: z16.array(OperationalWorldIdSchema).min(1).max(256),
+      nodes: z16.array(WorkGraphNodeSchema).max(1e4),
+      edges: z16.array(WorkGraphEdgeSchema).max(25e3),
+      sourceBindings: z16.array(SourceBindingSchema).max(1e4),
+      evidenceRefs: z16.array(EvidenceRefSchema).max(25e3),
+      claims: z16.array(ClaimSchema).max(1e4),
+      conflicts: z16.array(ConflictSchema).max(1e4),
+      selection: ReasoningSliceSelectionSchema,
+      generatedAt: z16.string().datetime()
+    }).strict().superRefine((slice, ctx) => {
+      validateGraphCollections(slice, ctx);
+      const nodeIds = new Set(slice.nodes.map((node) => node.nodeId));
+      slice.focusNodeIds.forEach((nodeId, index) => {
+        if (!nodeIds.has(nodeId)) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["focusNodeIds", index],
+            message: `focus node is absent from the reasoning slice: ${nodeId}`
+          });
+        }
+      });
+    });
+  }
+});
+
+// packages/schemas/dist/operational-world-migration.js
+var init_operational_world_migration = __esm({
+  "packages/schemas/dist/operational-world-migration.js"() {
+    "use strict";
+    init_operational_world();
+  }
+});
+
+// packages/schemas/dist/index.js
+var init_dist = __esm({
+  "packages/schemas/dist/index.js"() {
+    "use strict";
+    init_gpu_selection();
+    init_feature_workflow();
+    init_messages();
+    init_tools();
+    init_session();
+    init_task();
+    init_plan();
+    init_patch();
+    init_verification();
+    init_repoProfile();
+    init_retrieval();
+    init_dispatch();
+    init_memory();
+    init_backend();
+    init_config();
+    init_queue();
+    init_operational_world();
+    init_operational_world_migration();
+  }
+});
+
+// packages/execution/dist/gpu-selection.js
+var init_gpu_selection2 = __esm({
   "packages/execution/dist/gpu-selection.js"() {
     "use strict";
+    init_dist();
   }
 });
 
@@ -68,7 +1936,7 @@ var init_model_broker = __esm({
   "packages/execution/dist/model-broker.js"() {
     "use strict";
     init_jetson_monitor();
-    init_gpu_selection();
+    init_gpu_selection2();
     DEFAULT_IDLE_EVICT_MS = 5 * 60 * 1e3;
     STUCK_INFLIGHT_DIAGNOSTIC_MS = 5 * 60 * 1e3;
   }
@@ -1653,7 +3521,7 @@ var init_escape = __esm({
 });
 
 // node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js
-var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path2, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
 var init_esm3 = __esm({
   "node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js"() {
     init_esm2();
@@ -1722,11 +3590,11 @@ var init_esm3 = __esm({
       return (f) => f.length === len && f !== "." && f !== "..";
     };
     defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    path = {
+    path2 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
+    sep = defaultPlatform === "win32" ? path2.win32.sep : path2.posix.sep;
     minimatch.sep = sep;
     GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
@@ -47505,7 +49373,7 @@ var init_cuda_device_filter = __esm({
   "packages/execution/dist/tools/cuda-device-filter.js"() {
     "use strict";
     init_process_async();
-    init_gpu_selection();
+    init_gpu_selection2();
   }
 });
 
@@ -47853,6 +49721,7 @@ var init_memoryGraph = __esm({
 var init_embeddings = __esm({
   "packages/memory/dist/embeddings.js"() {
     "use strict";
+    init_dist();
   }
 });
 
@@ -48074,7 +49943,7 @@ var init_embeddingAligner = __esm({
 });
 
 // packages/memory/dist/crl/memory.js
-var init_memory = __esm({
+var init_memory2 = __esm({
   "packages/memory/dist/crl/memory.js"() {
     "use strict";
     init_episodeStore();
@@ -48083,7 +49952,7 @@ var init_memory = __esm({
 });
 
 // packages/memory/dist/crl/config.js
-var init_config = __esm({
+var init_config2 = __esm({
   "packages/memory/dist/crl/config.js"() {
     "use strict";
   }
@@ -48103,8 +49972,8 @@ var CRL_SYMBOLS, SYMBOL_MEANINGS, CRLParser, CRLEncoder, CRLDecoder, CRLTemplate
 var init_crl = __esm({
   "packages/memory/dist/crl/index.js"() {
     "use strict";
-    init_memory();
-    init_config();
+    init_memory2();
+    init_config2();
     init_converter();
     CRL_SYMBOLS = {
       // Logical operators (Core)
@@ -49101,7 +50970,7 @@ var init_evidence_retirement = __esm({
 });
 
 // packages/memory/dist/index.js
-var init_dist = __esm({
+var init_dist2 = __esm({
   "packages/memory/dist/index.js"() {
     "use strict";
     init_db();
@@ -49175,7 +51044,7 @@ var init_dist = __esm({
 var init_memory_read = __esm({
   "packages/execution/dist/tools/memory-read.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
   }
 });
 
@@ -49183,7 +51052,7 @@ var init_memory_read = __esm({
 var init_memory_write = __esm({
   "packages/execution/dist/tools/memory-write.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
   }
 });
 
@@ -49192,7 +51061,7 @@ var DEFAULT_INLINE_KG_MAX_BYTES, DEFAULT_INLINE_EPISODES_MAX_BYTES;
 var init_memory_search = __esm({
   "packages/execution/dist/tools/memory-search.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
     DEFAULT_INLINE_KG_MAX_BYTES = 512 * 1024 * 1024;
     DEFAULT_INLINE_EPISODES_MAX_BYTES = 1024 * 1024 * 1024;
   }
@@ -49202,7 +51071,7 @@ var init_memory_search = __esm({
 var init_memory_ops = __esm({
   "packages/execution/dist/tools/memory-ops.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
   }
 });
 
@@ -51922,7 +53791,7 @@ var init_pdf_transform = __esm({
 var init_source_corpus_ocr = __esm({
   "packages/execution/dist/tools/source-corpus-ocr.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
     init_pdf_corpus_archive();
   }
 });
@@ -51940,7 +53809,7 @@ var SEGMENT_CHARS, RECORD_BYTES, ACTIONS, SOURCE_CORPUS_TOOL_DEFINITION;
 var init_source_corpus = __esm({
   "packages/execution/dist/tools/source-corpus.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
     init_pdf_corpus_archive();
     init_source_corpus_ocr();
     init_corpus_directory_manifest();
@@ -51987,7 +53856,7 @@ var init_corpus_population = __esm({
 var init_source_corpus_workspace = __esm({
   "packages/execution/dist/tools/source-corpus-workspace.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
     init_source_corpus();
     init_corpus_population();
   }
@@ -52005,7 +53874,7 @@ var ACTIONS2, CORPUS_WORK_TOOL_DEFINITION;
 var init_corpus_work = __esm({
   "packages/execution/dist/tools/corpus-work.js"() {
     "use strict";
-    init_dist();
+    init_dist2();
     init_pdf_corpus_archive();
     init_corpus_derived_order();
     ACTIONS2 = ["begin", "next", "read", "commit", "status", "complete", "cancel", "export", "aggregate", "order"];
@@ -296425,7 +298294,7 @@ var init_community_detection = __esm({
 });
 
 // packages/indexer/dist/index.js
-var init_dist2 = __esm({
+var init_dist3 = __esm({
   "packages/indexer/dist/index.js"() {
     "use strict";
     init_codebase_indexer();
@@ -296483,7 +298352,7 @@ var init_code_graph_events = __esm({
 var init_code_graph_client = __esm({
   "packages/execution/dist/tools/code-graph-client.js"() {
     "use strict";
-    init_dist2();
+    init_dist3();
     init_code_graph_events();
   }
 });
@@ -297458,13 +299327,13 @@ var init_harness_plan = __esm({
 });
 
 // packages/execution/dist/index.js
-var init_dist3 = __esm({
+var init_dist4 = __esm({
   "packages/execution/dist/index.js"() {
     "use strict";
     init_feature_workflow_child();
     init_tool_executor();
     init_model_broker();
-    init_gpu_selection();
+    init_gpu_selection2();
     init_jetson_monitor();
     init_audio_classifier_runtime();
     init_audio_input_conditioning();
@@ -297677,7 +299546,7 @@ var DEFAULT_MIN_GPU_VRAM_MB;
 var init_ollama_pool = __esm({
   "packages/orchestrator/dist/ollama-pool.js"() {
     "use strict";
-    init_dist3();
+    init_dist4();
     DEFAULT_MIN_GPU_VRAM_MB = 16 * 1024;
   }
 });
@@ -299021,8 +300890,8 @@ var PROVIDER_PRESETS = [
 ];
 
 // packages/orchestrator/dist/agent-loop.js
-init_dist3();
-init_dist3();
+init_dist4();
+init_dist4();
 
 // packages/orchestrator/dist/plugins/types.js
 var PluginHook;
@@ -299036,1750 +300905,22 @@ var PluginHook;
 })(PluginHook || (PluginHook = {}));
 
 // packages/orchestrator/dist/plugins/manifest.js
-import { z } from "zod";
-var hookSchema = z.nativeEnum(PluginHook);
-var manifestSchema = z.object({
-  name: z.string().min(1, "Plugin name is required").regex(/^[a-z0-9_-]+$/, "Plugin name must be lowercase alphanumeric with hyphens/underscores"),
-  version: z.string().min(1, "Plugin version is required"),
-  description: z.string().default(""),
-  author: z.string().default(""),
-  hooks: z.array(hookSchema).default([]),
-  dependencies: z.array(z.string()).default([]),
-  source: z.enum(["user", "project", "npm"]),
-  path: z.string().optional()
-});
-
-// packages/schemas/dist/feature-workflow.js
-import { z as z2 } from "zod";
-var FEATURE_WORKFLOW_PLAN_SCHEMA = "omnius.feature-workflow-plan.v1";
-var FEATURE_WORKFLOW_PHASES = [
-  "research",
-  "specification",
-  "implementation",
-  "integration",
-  "acceptance",
-  "handoff"
-];
-var FeatureWorkflowPhaseSchema = z2.enum(FEATURE_WORKFLOW_PHASES);
-var id = z2.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,119}$/);
-var text = z2.string().trim().min(1).max(4e3);
-var FeatureWorkflowArtifactReferenceSchema = z2.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
-var path2 = z2.string().trim().min(1).max(1e3);
-var FeatureWorkflowCardSchema = z2.object({
-  id,
-  title: text,
-  phase: FeatureWorkflowPhaseSchema,
-  role: z2.enum([
-    "researcher",
-    "author",
-    "reviewer",
-    "implementer",
-    "integrator",
-    "verifier",
-    "synthesizer"
-  ]),
-  dependsOn: z2.array(id).max(128).default([]),
-  sourceIds: z2.array(id).max(256).default([]),
-  inputSlots: z2.array(id).max(256).default([]),
-  reviewSlots: z2.array(id).max(32).default([]),
-  ownedFiles: z2.array(path2).max(128).default([]),
-  acceptanceIds: z2.array(id).max(256).default([]),
-  verifier: z2.object({
-    command: z2.string().trim().min(1).max(4e3),
-    cwd: path2.optional(),
-    targetPaths: z2.array(path2).min(1).max(128)
-  }).strict().optional()
-}).strict();
-var FeatureWorkflowPlanSchema = z2.object({
-  schema: z2.literal(FEATURE_WORKFLOW_PLAN_SCHEMA),
-  id,
-  revision: z2.number().int().min(1).max(Number.MAX_SAFE_INTEGER),
-  objective: text,
-  requirements: z2.array(z2.object({ id, description: text }).strict()).min(1).max(256),
-  sources: z2.array(z2.object({ id, reference: FeatureWorkflowArtifactReferenceSchema }).strict()).max(256).default([]),
-  slots: z2.array(z2.object({
-    id,
-    kind: z2.enum([
-      "research",
-      "specification",
-      "implementation",
-      "integration",
-      "review",
-      "handoff"
-    ]),
-    cardId: id,
-    requiresReview: z2.boolean().default(false)
-  }).strict()).min(4).max(256),
-  cards: z2.array(FeatureWorkflowCardSchema).min(6).max(128)
-}).strict().superRefine((plan, ctx) => {
-  const fail = (message) => ctx.addIssue({ code: "custom", message });
-  const unique = (values, label) => {
-    if (new Set(values).size !== values.length)
-      fail(`duplicate ${label}`);
-  };
-  unique(plan.cards.map((c) => c.id), "card id");
-  unique(plan.slots.map((s) => s.id), "slot id");
-  unique(plan.sources.map((s) => s.id), "source id");
-  unique(plan.requirements.map((r) => r.id), "requirement id");
-  const cards = new Map(plan.cards.map((c) => [c.id, c]));
-  const slots = new Map(plan.slots.map((s) => [s.id, s]));
-  const sources = new Set(plan.sources.map((s) => s.id));
-  const assertions = new Map(plan.requirements.map((r) => [r.id, 0]));
-  for (const phase of FEATURE_WORKFLOW_PHASES)
-    if (!plan.cards.some((c) => c.phase === phase))
-      fail(`missing phase ${phase}`);
-  for (const slot of plan.slots) {
-    if (slot.id.startsWith("source:"))
-      fail(`reserved source namespace ${slot.id}`);
-    const producer = cards.get(slot.cardId);
-    if (!producer)
-      fail(`unknown producer ${slot.cardId}`);
-    if (slot.requiresReview && !plan.cards.some((c) => c.role === "reviewer" && c.reviewSlots.includes(slot.id)))
-      fail(`missing independent review for ${slot.id}`);
-    if (slot.requiresReview && producer && plan.cards.some((c) => c.reviewSlots.includes(slot.id) && c.phase !== producer.phase))
-      fail(`review must occur in producer phase ${slot.id}`);
-  }
-  for (const kind of [
-    "research",
-    "specification",
-    "integration",
-    "handoff"
-  ]) {
-    if (!plan.slots.some((s) => s.kind === kind && cards.get(s.cardId)?.phase === kind))
-      fail(`missing ${kind} artifact`);
-  }
-  if (!plan.slots.some((s) => s.kind === "specification" && s.requiresReview))
-    fail("specification requires independent review");
-  for (const card of plan.cards) {
-    if (card.role !== "reviewer" && card.role !== "verifier" && !plan.slots.some((slot) => slot.cardId === card.id))
-      fail(`work card requires an artifact slot ${card.id}`);
-    for (const [label, values] of Object.entries({
-      dependency: card.dependsOn,
-      source: card.sourceIds,
-      input: card.inputSlots,
-      review: card.reviewSlots,
-      acceptance: card.acceptanceIds
-    }))
-      unique(values, `${label} in ${card.id}`);
-    for (const dep of card.dependsOn)
-      if (!cards.has(dep))
-        fail(`unknown dependency ${dep}`);
-    for (const source of card.sourceIds)
-      if (!sources.has(source))
-        fail(`unknown source ${source}`);
-    for (const slotId of [...card.inputSlots, ...card.reviewSlots]) {
-      const slot = slots.get(slotId);
-      if (!slot) {
-        fail(`unknown slot ${slotId}`);
-        continue;
-      }
-      const producer = cards.get(slot.cardId);
-      if (slot.cardId === card.id)
-        fail(`self-dependent slot ${slotId}`);
-      if (producer && FEATURE_WORKFLOW_PHASES.indexOf(producer.phase) > FEATURE_WORKFLOW_PHASES.indexOf(card.phase))
-        fail(`future slot ${slotId}`);
-    }
-    for (const dep of card.dependsOn) {
-      const source = cards.get(dep);
-      if (source && FEATURE_WORKFLOW_PHASES.indexOf(source.phase) > FEATURE_WORKFLOW_PHASES.indexOf(card.phase))
-        fail(`future dependency ${dep}`);
-    }
-    if (card.role === "reviewer" !== card.reviewSlots.length > 0)
-      fail(`review role/slots mismatch ${card.id}`);
-    if (card.phase === "acceptance" && (card.role !== "verifier" || !card.verifier || card.acceptanceIds.length === 0))
-      fail(`acceptance needs explicit verifier ${card.id}`);
-    if (card.phase !== "acceptance" && (card.verifier || card.acceptanceIds.length))
-      fail(`acceptance authority outside acceptance phase ${card.id}`);
-    if (card.phase === "implementation" && card.role !== "reviewer" && (card.role !== "implementer" || card.ownedFiles.length === 0))
-      fail(`implementation needs owned files ${card.id}`);
-    for (const assertion of card.acceptanceIds) {
-      if (!assertions.has(assertion))
-        fail(`unknown acceptance ${assertion}`);
-      else
-        assertions.set(assertion, assertions.get(assertion) + 1);
-    }
-  }
-  for (const [assertion, count] of assertions)
-    if (count !== 1)
-      fail(`acceptance ${assertion} must have exactly one owner`);
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const visit = (cardId) => {
-    if (visiting.has(cardId)) {
-      fail(`dependency cycle ${cardId}`);
-      return;
-    }
-    if (visited.has(cardId))
-      return;
-    const card = cards.get(cardId);
-    if (!card)
-      return;
-    visiting.add(cardId);
-    for (const dependency of [
-      ...card.dependsOn,
-      ...[...card.inputSlots, ...card.reviewSlots].map((s) => slots.get(s)?.cardId).filter((s) => !!s)
-    ])
-      visit(dependency);
-    visiting.delete(cardId);
-    visited.add(cardId);
-  };
-  for (const card of plan.cards)
-    visit(card.id);
-});
-var FeatureWorkflowChildReportSchema = z2.object({
-  schema: z2.literal("omnius.feature-workflow-child-report.v1"),
-  cardId: id,
-  status: z2.enum(["completed", "partial", "blocked", "failed"]),
-  inputSlots: z2.record(z2.string().min(1).max(256), FeatureWorkflowArtifactReferenceSchema),
-  artifacts: z2.array(z2.object({ slotId: id, content: z2.string().min(1).max(1e5) }).strict()).max(32).default([]),
-  review: z2.object({
-    disposition: z2.enum(["approved", "changes_requested"]),
-    reviewedSlots: z2.record(id, FeatureWorkflowArtifactReferenceSchema),
-    findings: z2.array(z2.object({
-      id,
-      severity: z2.enum(["info", "blocking"]),
-      detail: text
-    }).strict()).max(64)
-  }).strict().optional(),
-  blockers: z2.array(text).max(32),
-  unresolvedQuestions: z2.array(text).max(32)
-}).strict();
-var FeatureWorkflowToolInputSchema = z2.discriminatedUnion("action", [
-  z2.object({
-    action: z2.enum(["create", "revise"]),
-    plan: FeatureWorkflowPlanSchema
-  }).strict(),
-  z2.object({ action: z2.literal("status") }).strict(),
-  z2.object({ action: z2.literal("discover") }).strict(),
-  z2.object({
-    action: z2.literal("resume"),
-    runId: id,
-    planReference: FeatureWorkflowArtifactReferenceSchema,
-    objectiveId: id
-  }).strict(),
-  z2.object({
-    action: z2.literal("repair"),
-    cardId: id,
-    failedCardId: id,
-    reason: text
-  }).strict(),
-  z2.object({
-    action: z2.literal("record_artifact"),
-    cardId: id,
-    slotId: id,
-    path: path2
-  }).strict()
-]);
-var FeatureWorkflowToolJsonSchema = z2.toJSONSchema(FeatureWorkflowToolInputSchema, { reused: "ref", unrepresentable: "any" });
-
-// packages/schemas/dist/messages.js
-import { z as z3 } from "zod";
-var AgentMessageSchema = z3.object({
-  id: z3.string().uuid(),
-  sessionId: z3.string().uuid(),
-  role: z3.enum(["user", "assistant", "system", "tool"]),
-  content: z3.string(),
-  timestamp: z3.string().datetime(),
-  metadata: z3.record(z3.string(), z3.unknown()).optional()
-});
-
-// packages/schemas/dist/tools.js
-import { z as z4 } from "zod";
-var ToolCallSchema = z4.object({
-  id: z4.string().uuid(),
-  name: z4.string(),
-  arguments: z4.record(z4.string(), z4.unknown()),
-  result: z4.unknown().optional(),
-  status: z4.enum(["pending", "running", "completed", "failed"]),
-  startedAt: z4.string().datetime().optional(),
-  completedAt: z4.string().datetime().optional()
-});
-
-// packages/schemas/dist/session.js
-import { z as z5 } from "zod";
-var SessionSchema = z5.object({
-  id: z5.string().uuid(),
-  projectRoot: z5.string(),
-  model: z5.string(),
-  createdAt: z5.string().datetime(),
-  updatedAt: z5.string().datetime(),
-  status: z5.enum(["active", "paused", "completed", "error"]),
-  config: z5.record(z5.string(), z5.unknown()).optional()
-});
-
-// packages/schemas/dist/task.js
-import { z as z6 } from "zod";
-var TaskClassSchema = z6.enum([
-  "bugfix",
-  "feature",
-  "refactor",
-  "migration",
-  "dependency-upgrade",
-  "test",
-  "docs",
-  "infra"
-]);
-var UrgencySchema = z6.enum(["low", "medium", "high", "critical"]);
-var NormalizedTaskSchema = z6.object({
-  /** Stable unique identifier for this task instance */
-  id: z6.string(),
-  /** Human-readable goal description */
-  goal: z6.string().min(1),
-  /** Constraints the solution must satisfy */
-  constraints: z6.array(z6.string()),
-  /** Criteria that must pass for the task to be considered done */
-  successCriteria: z6.array(z6.string()),
-  /** Absolute path to the repo root */
-  repoRoot: z6.string(),
-  urgency: UrgencySchema,
-  taskClass: TaskClassSchema,
-  /** Original raw user request before normalization */
-  rawRequest: z6.string().optional(),
-  /** Timestamp when the task was created (ISO-8601) */
-  createdAt: z6.string().datetime()
-});
-var TaskStatusSchema = z6.enum([
-  "pending",
-  "dispatched",
-  "in_progress",
-  "success",
-  "partial_success",
-  "needs_human_decision",
-  "blocked_missing_context",
-  "rollback_required",
-  "failed"
-]);
-
-// packages/schemas/dist/plan.js
-import { z as z7 } from "zod";
-var SubtaskKindSchema = z7.enum([
-  "inspect",
-  "patch",
-  "test",
-  "migrate",
-  "verify",
-  "merge"
-]);
-var SubtaskSchema = z7.object({
-  /** Stable identifier used for dependency references */
-  id: z7.string().min(1),
-  kind: SubtaskKindSchema,
-  /** File paths or symbol names that this subtask targets */
-  targets: z7.array(z7.string()),
-  /** IDs of subtasks that must complete before this one starts */
-  dependsOn: z7.array(z7.string()).optional(),
-  /** Why this subtask is necessary */
-  reason: z7.string().min(1),
-  /** Shell commands or assertions that confirm success */
-  validation: z7.array(z7.string())
-});
-var PlanSchema = z7.object({
-  goal: z7.string().min(1),
-  subtasks: z7.array(SubtaskSchema),
-  /** Files/modules at elevated risk of breakage */
-  riskAreas: z7.array(z7.string()),
-  /** Aspects of the codebase that are unclear or ambiguous */
-  unknowns: z7.array(z7.string())
-});
-
-// packages/schemas/dist/patch.js
-import { z as z8 } from "zod";
-var EditOperationSchema = z8.enum([
-  "diff",
-  "rewrite",
-  "append",
-  "create"
-]);
-var FileEditSchema = z8.object({
-  /** Repo-relative or absolute path to the file being edited */
-  file: z8.string().min(1),
-  operation: EditOperationSchema,
-  /** Unified diff, full file content, appended text, or new file content */
-  content: z8.string()
-});
-var NeedsMoreContextSchema = z8.object({
-  reason: z8.string().min(1),
-  requestedPaths: z8.array(z8.string()).optional(),
-  requestedSymbols: z8.array(z8.string()).optional()
-});
-var PatchProposalSchema = z8.object({
-  /** One-paragraph description of what changed and why */
-  summary: z8.string().min(1),
-  edits: z8.array(FileEditSchema),
-  /** Test commands or test file paths that should be executed to validate */
-  testsToRun: z8.array(z8.string()),
-  /** Assumptions the editor made that the verifier should check */
-  assumptions: z8.array(z8.string()),
-  /** Known risks introduced by this patch */
-  risks: z8.array(z8.string()),
-  /**
-   * When the editor cannot safely produce a patch without more information.
-   * The presence of this field indicates the patch is incomplete.
-   */
-  needsMoreContext: NeedsMoreContextSchema.optional()
-});
-
-// packages/schemas/dist/verification.js
-import { z as z9 } from "zod";
-var VerificationStatusSchema = z9.enum(["pass", "fail", "partial"]);
-var VerificationNextActionSchema = z9.enum([
-  "finish",
-  "retry",
-  "rollback",
-  "inspect_more"
-]);
-var VerificationDecisionSchema = z9.object({
-  status: VerificationStatusSchema,
-  /** Concrete evidence lines from logs, test output, or type-checker output */
-  evidence: z9.array(z9.string()),
-  nextAction: VerificationNextActionSchema,
-  /** Files that should be prioritised in the next retrieval/editing round */
-  focusFiles: z9.array(z9.string()),
-  /**
-   * Short fingerprint string identifying the failure category.
-   * Used to detect repeat failure loops. Only present when status !== "pass".
-   */
-  failureFingerprint: z9.string().optional()
-});
-
-// packages/schemas/dist/repoProfile.js
-import { z as z10 } from "zod";
-var LanguageSchema = z10.enum([
-  "typescript",
-  "javascript",
-  "python",
-  "go",
-  "rust",
-  "java",
-  "csharp",
-  "sql",
-  "other"
-]);
-var PackageManagerSchema = z10.enum([
-  "npm",
-  "pnpm",
-  "yarn",
-  "bun",
-  "pip",
-  "poetry",
-  "cargo",
-  "go-modules",
-  "maven",
-  "gradle",
-  "other"
-]);
-var BuildSystemSchema = z10.enum([
-  "tsc",
-  "vite",
-  "webpack",
-  "esbuild",
-  "turbo",
-  "nx",
-  "make",
-  "cmake",
-  "cargo",
-  "gradle",
-  "maven",
-  "other"
-]);
-var MigrationSystemSchema = z10.enum([
-  "prisma",
-  "drizzle",
-  "knex",
-  "alembic",
-  "flyway",
-  "liquibase",
-  "typeorm",
-  "sequelize",
-  "other",
-  "none"
-]);
-var RepoProfileSchema = z10.object({
-  /** Languages present in the repo, ordered by prevalence */
-  languages: z10.array(LanguageSchema),
-  /** Frameworks detected (e.g. "nextjs", "fastapi", "express") */
-  frameworks: z10.array(z10.string()),
-  packageManager: PackageManagerSchema.optional(),
-  buildSystem: BuildSystemSchema.optional(),
-  /** Shell commands known to run the test suite */
-  testCommands: z10.array(z10.string()),
-  /** Shell commands known to run the linter */
-  lintCommands: z10.array(z10.string()),
-  migrationSystem: MigrationSystemSchema.optional(),
-  /** Runtime assumptions such as Node version, Python version, etc. */
-  runtimeAssumptions: z10.array(z10.string()),
-  /** Names of environment variables the repo consumes */
-  envVarNames: z10.array(z10.string()),
-  /** Deployment-related notes (e.g. Docker, Kubernetes, serverless) */
-  deploymentNotes: z10.array(z10.string()),
-  /** Absolute path to the repo root on the agent's filesystem */
-  repoRoot: z10.string(),
-  /** ISO-8601 timestamp of the last profile update */
-  lastIndexed: z10.string().datetime()
-});
-
-// packages/schemas/dist/retrieval.js
-import { z as z11 } from "zod";
-var RetrievalRequestSchema = z11.object({
-  /** Natural language description of what information is needed */
-  query: z11.string().min(1),
-  /** File path hints that the retrieval system should prioritise */
-  pathsHint: z11.array(z11.string()),
-  /** Symbol names (functions, classes, types) to look up */
-  symbolHint: z11.array(z11.string()),
-  /** Error message fragments to search for in logs and source */
-  errorHint: z11.array(z11.string()),
-  /** Maximum number of files to include in the retrieval packet */
-  maxFiles: z11.number().int().positive(),
-  /** Maximum number of code snippets to include */
-  maxSnippets: z11.number().int().positive(),
-  /** Whether test files should be included in results */
-  includeTests: z11.boolean(),
-  /** Whether config files (tsconfig, package.json, .env.example …) should be included */
-  includeConfigs: z11.boolean()
-});
-var SnippetSchema = z11.object({
-  /** Repo-relative path of the source file */
-  file: z11.string(),
-  /** 1-based start line */
-  startLine: z11.number().int().positive(),
-  /** 1-based end line (inclusive) */
-  endLine: z11.number().int().positive(),
-  /** The actual source text */
-  content: z11.string(),
-  /** Why this snippet was selected */
-  relevanceNote: z11.string().optional()
-});
-var RetrievalPacketSchema = z11.object({
-  /** Echo of the original request that produced this packet */
-  request: RetrievalRequestSchema,
-  /** Full file contents or extracts, keyed by repo-relative path */
-  files: z11.record(z11.string(), z11.string()),
-  snippets: z11.array(SnippetSchema),
-  /** One-line architecture note for orientation */
-  architectureNote: z11.string().optional(),
-  /** Note summarising relevant prior attempts at related tasks */
-  priorAttemptNote: z11.string().optional(),
-  /** ISO-8601 timestamp when the packet was assembled */
-  assembledAt: z11.string().datetime()
-});
-
-// packages/schemas/dist/dispatch.js
-import { z as z12 } from "zod";
-var DispatchModeSchema = z12.enum([
-  "single_pass",
-  "multi_agent",
-  "hybrid"
-]);
-var TaskComplexitySchema = z12.enum(["low", "medium", "high"]);
-var AgentRoleSchema = z12.enum([
-  "planner",
-  "scout",
-  "editor",
-  "verifier",
-  "researcher"
-]);
-var BudgetsSchema = z12.object({
-  /** Maximum prompt tokens across all model calls for this task */
-  promptTokens: z12.number().int().positive(),
-  /** Maximum number of retry cycles allowed per subtask */
-  retries: z12.number().int().nonnegative(),
-  /** Maximum wall-clock seconds before the task is considered timed out */
-  wallClockSec: z12.number().positive()
-});
-var DispatchDecisionSchema = z12.object({
-  mode: DispatchModeSchema,
-  taskComplexity: TaskComplexitySchema,
-  splitRecommended: z12.boolean(),
-  /** Agent roles that should be spun up for the first wave of execution */
-  initialAgents: z12.array(AgentRoleSchema),
-  budgets: BudgetsSchema
-});
-
-// packages/schemas/dist/memory.js
-import { z as z13 } from "zod";
-var RiskLevelSchema = z13.enum(["low", "medium", "high", "critical"]);
-var FileSummarySchema = z13.object({
-  /** Repo-relative path of the file */
-  path: z13.string().min(1),
-  /** One-sentence description of the file's role */
-  purpose: z13.string(),
-  /** Primary exported symbols (functions, classes, constants) */
-  mainExports: z13.array(z13.string()),
-  /** Key import paths this file depends on */
-  keyImports: z13.array(z13.string()),
-  /** Logical ownership area (e.g. "auth", "api", "db", "frontend") */
-  ownershipDomain: z13.string(),
-  riskLevel: RiskLevelSchema,
-  /** Paths of test files that cover this file */
-  relatedTests: z13.array(z13.string()),
-  /** SHA-256 or similar hash of the file content at last index time */
-  summaryHash: z13.string(),
-  /** ISO-8601 timestamp of the last indexing pass */
-  lastIndexed: z13.string().datetime()
-});
-var FailureCategorySchema = z13.enum([
-  "ts_type_drift",
-  "import_path_mismatch",
-  "route_not_registered",
-  "env_var_absent",
-  "schema_runtime_mismatch",
-  "migration_missing",
-  "circular_dependency",
-  "stale_snapshot",
-  "build_error",
-  "test_error",
-  "other"
-]);
-var FailureFingerprintSchema = z13.object({
-  /** Short stable identifier (e.g. "ts_type_drift:UserSchema") */
-  fingerprint: z13.string().min(1),
-  category: FailureCategorySchema,
-  /** Human-readable summary of what went wrong */
-  description: z13.string(),
-  /** Files involved in or triggering the failure */
-  affectedFiles: z13.array(z13.string()),
-  /** How many times this fingerprint has been seen */
-  occurrenceCount: z13.number().int().nonnegative(),
-  /** ISO-8601 timestamp of first occurrence */
-  firstSeen: z13.string().datetime(),
-  /** ISO-8601 timestamp of most recent occurrence */
-  lastSeen: z13.string().datetime()
-});
-var TaskMemorySchema = z13.object({
-  taskId: z13.string().min(1),
-  goal: z13.string(),
-  /** Normalised constraints carried into the task */
-  normalizedConstraints: z13.array(z13.string()),
-  /** Files that were read or modified during the task */
-  filesTouched: z13.array(z13.string()),
-  /** Summary of patches applied (not the full diff) */
-  patchesApplied: z13.array(z13.string()),
-  /** Final validation outcome ("pass" | "fail" | "partial") */
-  validationOutcome: z13.enum(["pass", "fail", "partial"]),
-  /** Human-readable reasons for any failures */
-  failureReasons: z13.array(z13.string()),
-  /** Follow-up tasks or open questions left behind */
-  followUpTodos: z13.array(z13.string()),
-  /**
-   * Subjective quality score 0–100 assigned by the verifier
-   * (100 = perfect, 0 = complete failure)
-   */
-  qualityScore: z13.number().int().min(0).max(100),
-  /** ISO-8601 timestamp when the task completed */
-  completedAt: z13.string().datetime()
-});
-
-// packages/schemas/dist/backend.js
-import { z as z14 } from "zod";
-var MessageRoleSchema = z14.enum([
-  "system",
-  "user",
-  "assistant",
-  "tool"
-]);
-var ChatMessageSchema = z14.object({
-  role: MessageRoleSchema,
-  content: z14.string(),
-  /** Tool call ID, required when role === "tool" */
-  toolCallId: z14.string().optional(),
-  /** Tool name, required when role === "tool" */
-  name: z14.string().optional()
-});
-var CompletionRequestSchema = z14.object({
-  messages: z14.array(ChatMessageSchema),
-  /** Override the model used by the backend for this request */
-  model: z14.string().optional(),
-  maxTokens: z14.number().int().positive().optional(),
-  temperature: z14.number().min(0).max(2).optional(),
-  /** Request class for queue routing */
-  queueClass: z14.string().optional(),
-  /** Prefix hash for cache-aware routing */
-  prefixHash: z14.string().optional(),
-  stopSequences: z14.array(z14.string()).optional()
-});
-var TokenUsageSchema = z14.object({
-  promptTokens: z14.number().int().nonnegative(),
-  completionTokens: z14.number().int().nonnegative(),
-  totalTokens: z14.number().int().nonnegative(),
-  cacheCreationInputTokens: z14.number().int().nonnegative().optional(),
-  cacheReadInputTokens: z14.number().int().nonnegative().optional(),
-  promptEvalCount: z14.number().int().nonnegative().optional()
-});
-var CompletionResponseSchema = z14.object({
-  content: z14.string(),
-  usage: TokenUsageSchema.optional(),
-  /** Which model actually served the request */
-  model: z14.string().optional(),
-  finishReason: z14.enum(["stop", "length", "tool_calls", "content_filter", "error"]).optional()
-});
-var StructuredCompletionRequestSchema = CompletionRequestSchema.extend({
-  /**
-   * The Zod schema used to constrain and validate the output.
-   * Stored as unknown here because Zod schemas are not themselves
-   * serialisable — callers pass the live schema object.
-   */
-  outputSchema: z14.unknown(),
-  /** Human-readable label used in prompt injection for the schema */
-  schemaLabel: z14.string().optional()
-});
-var BackendHealthSchema = z14.object({
-  status: z14.enum(["ok", "degraded", "down"]),
-  latencyMs: z14.number().nonnegative().optional(),
-  /** Fraction of GPU memory currently in use (0–1) */
-  gpuMemoryUsed: z14.number().min(0).max(1).optional(),
-  /** Fraction of KV cache currently in use (0–1) */
-  kvCacheUsed: z14.number().min(0).max(1).optional(),
-  /** Number of requests currently waiting in the queue */
-  queueDepth: z14.number().int().nonnegative().optional(),
-  /** Human-readable note about any degraded state */
-  note: z14.string().optional()
-});
-var BackendMetricsSchema = z14.object({
-  /** Total requests handled since startup */
-  totalRequests: z14.number().int().nonnegative(),
-  /** Requests that completed successfully */
-  successfulRequests: z14.number().int().nonnegative(),
-  /** Requests that failed */
-  failedRequests: z14.number().int().nonnegative(),
-  /** Average time-to-first-token across recent requests (ms) */
-  avgTtftMs: z14.number().nonnegative().optional(),
-  /** Average end-to-end latency across recent requests (ms) */
-  avgLatencyMs: z14.number().nonnegative().optional(),
-  /** Approximate prefix cache hit rate (0–1) */
-  prefixCacheHitRate: z14.number().min(0).max(1).optional(),
-  /** Number of sleep/wake cycles since startup */
-  sleepWakeCycles: z14.number().int().nonnegative().optional(),
-  /** Number of OOM / preemption / offload events */
-  oomEvents: z14.number().int().nonnegative().optional(),
-  /** ISO-8601 timestamp of when the backend service started */
-  uptimeSince: z14.string().datetime().optional()
-});
-
-// packages/schemas/dist/config.js
-import { z as z15 } from "zod";
-var AgentConfigSchema = z15.object({
-  // -----------------------------------------------------------------------
-  // Model / backend
-  // -----------------------------------------------------------------------
-  /** HuggingFace model ID, e.g. "Qwen/Qwen3.5-122B-A10B" */
-  MODEL_ID: z15.string().min(1),
-  /** Base URL of the primary vLLM OpenAI-compatible endpoint */
-  VLLM_BASE_URL: z15.string().url(),
-  /** API key sent to the vLLM service (often the literal string "EMPTY") */
-  VLLM_API_KEY: z15.string().default("EMPTY"),
-  // -----------------------------------------------------------------------
-  // Context / memory tuning
-  // -----------------------------------------------------------------------
-  /**
-   * Maximum context length for the model.
-   * Should be discovered by startup probing rather than hard-coded.
-   */
-  AGENT_MAX_MODEL_LEN: z15.string().transform((v) => parseInt(v, 10)).pipe(z15.number().int().positive()).default(65536),
-  /** Enable vLLM automatic prefix caching (1 = enabled) */
-  AGENT_ENABLE_PREFIX_CACHING: z15.string().transform((v) => v === "1" || v.toLowerCase() === "true").pipe(z15.boolean()).default(true),
-  /** Enable vLLM sleep mode when idle (1 = enabled) */
-  AGENT_ENABLE_SLEEP_MODE: z15.string().transform((v) => v === "1" || v.toLowerCase() === "true").pipe(z15.boolean()).default(true),
-  // -----------------------------------------------------------------------
-  // Agent behaviour
-  // -----------------------------------------------------------------------
-  /** Maximum retry cycles per subtask */
-  AGENT_MAX_RETRIES: z15.string().transform((v) => parseInt(v, 10)).pipe(z15.number().int().nonnegative()).default(3),
-  /** Maximum number of parallel subagents that may run simultaneously */
-  AGENT_MAX_PARALLEL_SUBAGENTS: z15.string().transform((v) => parseInt(v, 10)).pipe(z15.number().int().positive()).default(4),
-  // -----------------------------------------------------------------------
-  // Retrieval limits
-  // -----------------------------------------------------------------------
-  /** Maximum files included in a single retrieval packet */
-  AGENT_RETRIEVAL_MAX_FILES: z15.string().transform((v) => parseInt(v, 10)).pipe(z15.number().int().positive()).default(8),
-  /** Maximum snippets included in a single retrieval packet */
-  AGENT_RETRIEVAL_MAX_SNIPPETS: z15.string().transform((v) => parseInt(v, 10)).pipe(z15.number().int().positive()).default(16),
-  // -----------------------------------------------------------------------
-  // File paths
-  // -----------------------------------------------------------------------
-  /** Directory where agent working trees and artefacts are written */
-  AGENT_WORK_ROOT: z15.string().min(1),
-  /** Directory where the indexer stores its indexes and embeddings */
-  AGENT_INDEX_ROOT: z15.string().min(1),
-  // -----------------------------------------------------------------------
-  // Optional models
-  // -----------------------------------------------------------------------
-  /** Model ID or endpoint for the embedding model (optional) */
-  AGENT_EMBEDDING_MODEL: z15.string().optional(),
-  /**
-   * Optional smaller local model for triage/summarisation tasks.
-   * When set, used in Profile C (hybrid mode).
-   */
-  AGENT_SMALL_MODEL: z15.string().optional()
-});
-
-// packages/schemas/dist/queue.js
-import { z as z16 } from "zod";
-var QueueClassSchema = z16.enum([
-  /** CLI and direct user-facing requests; lowest latency target */
-  "interactive-high",
-  /** Planner role requests; moderate priority */
-  "planner-medium",
-  /** Editor role patch generation; high priority, may be long-running */
-  "editor-high",
-  /** Verifier role review; high priority, usually short */
-  "verifier-high",
-  /** Memory write-back and summarisation; background, low priority */
-  "memory-low",
-  /** Bulk indexing and embedding; lowest priority, best-effort */
-  "batch-indexing-low"
-]);
-
-// packages/schemas/dist/operational-world.js
 import { z as z17 } from "zod";
-var OPERATIONAL_WORLD_SCHEMA_VERSION = "omnius.operational-world.v1";
-var OperationalWorldSchemaVersionSchema = z17.literal(OPERATIONAL_WORLD_SCHEMA_VERSION);
-var OperationalWorldIdSchema = z17.string().trim().min(1).max(256);
-var OperationalWorldRevisionSchema = z17.string().trim().min(1).max(256);
-var ConfidenceSchema = z17.number().finite().min(0).max(1);
-var OperationalFactScopeSchema = z17.object({
-  kind: z17.enum([
-    "global",
-    "run",
-    "task",
-    "session",
-    "chat",
-    "thread",
-    "conversation",
-    "legacy_unscoped"
-  ]),
-  scopeId: OperationalWorldIdSchema,
-  taskEpoch: z17.number().int().nonnegative().optional()
-}).strict();
-var OperationalMetadataDerivedFieldSchema = z17.enum([
-  "source_evidence",
-  "confidence",
-  "revision",
-  "temporal_validity",
-  "scope",
-  "metadata_provenance"
-]);
-var OperationalMetadataProvenanceSchema = z17.discriminatedUnion("kind", [
-  z17.object({ kind: z17.literal("native") }).strict(),
-  z17.object({
-    kind: z17.literal("legacy_derived"),
-    marker: z17.literal("metadata-only-no-semantic-assertion"),
-    sourceRecordId: OperationalWorldIdSchema,
-    derivedFields: z17.array(OperationalMetadataDerivedFieldSchema).min(1).max(6)
-  }).strict()
-]);
-var JsonValueSchema = z17.lazy(() => z17.union([
-  z17.string(),
-  z17.number().finite(),
-  z17.boolean(),
-  z17.null(),
-  z17.array(JsonValueSchema),
-  z17.record(z17.string(), JsonValueSchema)
-]));
-var LineRangeLocatorSchema = z17.object({
-  type: z17.literal("line_range"),
-  startLine: z17.number().int().positive(),
-  endLine: z17.number().int().positive()
-}).strict();
-var CharacterRangeLocatorSchema = z17.object({
-  type: z17.literal("character_range"),
-  startOffset: z17.number().int().nonnegative(),
-  /** Exclusive end offset. */
-  endOffset: z17.number().int().positive()
-}).strict();
-var PageRangeLocatorSchema = z17.object({
-  type: z17.literal("page_range"),
-  startPage: z17.number().int().positive(),
-  endPage: z17.number().int().positive()
-}).strict();
-var SheetRangeLocatorSchema = z17.object({
-  type: z17.literal("sheet_range"),
-  sheetName: z17.string().trim().min(1).max(256),
-  startRow: z17.number().int().positive().optional(),
-  endRow: z17.number().int().positive().optional(),
-  startColumn: z17.number().int().positive().optional(),
-  endColumn: z17.number().int().positive().optional()
-}).strict();
-var TableRangeLocatorSchema = z17.object({
-  type: z17.literal("table_range"),
-  table: z17.string().trim().min(1).max(256),
-  startRow: z17.number().int().nonnegative(),
-  endRow: z17.number().int().nonnegative(),
-  columns: z17.array(z17.string().trim().min(1).max(256)).max(128).optional()
-}).strict();
-var JsonPathLocatorSchema = z17.object({
-  type: z17.literal("json_path"),
-  path: z17.string().trim().min(1).max(2048)
-}).strict();
-var HeadingLocatorSchema = z17.object({
-  type: z17.literal("heading"),
-  heading: z17.string().trim().min(1).max(1024),
-  occurrence: z17.number().int().positive().optional()
-}).strict();
-var FieldLocatorSchema = z17.object({
-  type: z17.literal("field"),
-  path: z17.array(z17.string().trim().min(1).max(256)).min(1).max(64),
-  recordKey: z17.string().trim().min(1).max(512).optional()
-}).strict();
-var UriFragmentLocatorSchema = z17.object({
-  type: z17.literal("uri_fragment"),
-  fragment: z17.string().trim().min(1).max(2048)
-}).strict();
-var EvidenceLocatorSchema = z17.discriminatedUnion("type", [
-  LineRangeLocatorSchema,
-  CharacterRangeLocatorSchema,
-  PageRangeLocatorSchema,
-  SheetRangeLocatorSchema,
-  TableRangeLocatorSchema,
-  JsonPathLocatorSchema,
-  HeadingLocatorSchema,
-  FieldLocatorSchema,
-  UriFragmentLocatorSchema
-]).superRefine((locator, ctx) => {
-  if (locator.type === "line_range" && locator.endLine < locator.startLine) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["endLine"],
-      message: "endLine must be greater than or equal to startLine"
-    });
-  }
-  if (locator.type === "character_range" && locator.endOffset <= locator.startOffset) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["endOffset"],
-      message: "endOffset must be greater than startOffset"
-    });
-  }
-  if (locator.type === "page_range" && locator.endPage < locator.startPage) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["endPage"],
-      message: "endPage must be greater than or equal to startPage"
-    });
-  }
-  if (locator.type === "sheet_range") {
-    if (locator.endRow !== void 0 && locator.startRow === void 0) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["startRow"],
-        message: "startRow is required when endRow is present"
-      });
-    } else if (locator.startRow !== void 0 && locator.endRow !== void 0 && locator.endRow < locator.startRow) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["endRow"],
-        message: "endRow must be greater than or equal to startRow"
-      });
-    }
-    if (locator.endColumn !== void 0 && locator.startColumn === void 0) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["startColumn"],
-        message: "startColumn is required when endColumn is present"
-      });
-    } else if (locator.startColumn !== void 0 && locator.endColumn !== void 0 && locator.endColumn < locator.startColumn) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["endColumn"],
-        message: "endColumn must be greater than or equal to startColumn"
-      });
-    }
-  }
-  if (locator.type === "table_range" && locator.endRow < locator.startRow) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["endRow"],
-      message: "endRow must be greater than or equal to startRow"
-    });
-  }
-});
-var SourceAuthoritySchema = z17.enum([
-  "authoritative",
-  "primary",
-  "secondary",
-  "derived",
-  "unknown"
-]);
-var SourceFreshnessSchema = z17.enum(["fresh", "stale", "unknown"]);
-var SourceReadPolicySchema = z17.enum([
-  "immutable",
-  "snapshot",
-  "refresh_before_use",
-  "live"
-]);
-var SourceBindingSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  bindingId: OperationalWorldIdSchema,
-  sourceId: OperationalWorldIdSchema,
-  /** URI, repo-relative path, or external source identifier. */
-  sourceUri: z17.string().trim().min(1).max(4096),
-  sourceRevision: OperationalWorldRevisionSchema,
-  sourceHash: z17.string().trim().min(1).max(512).optional(),
-  locator: EvidenceLocatorSchema,
-  authority: SourceAuthoritySchema,
-  freshness: SourceFreshnessSchema,
-  readPolicy: SourceReadPolicySchema,
-  observedAt: z17.string().datetime(),
-  confidence: ConfidenceSchema,
-  notes: z17.string().trim().max(2e3).optional()
-}).strict();
-var EvidenceRoleSchema = z17.enum([
-  "supports",
-  "refutes",
-  "context",
-  "verification",
-  "blocker"
-]);
-var EvidenceRefSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  evidenceId: OperationalWorldIdSchema,
-  bindingId: OperationalWorldIdSchema,
-  role: EvidenceRoleSchema,
-  excerpt: z17.string().max(4e3).optional(),
-  excerptHash: z17.string().trim().min(1).max(512).optional(),
-  observedAt: z17.string().datetime(),
-  confidence: ConfidenceSchema,
-  tags: z17.array(z17.string().trim().min(1).max(128)).max(64)
-}).strict();
-var ClaimKindSchema = z17.enum([
-  "fact",
-  "inference",
-  "requirement",
-  "constraint",
-  "outcome"
-]);
-var ClaimPolaritySchema = z17.enum(["positive", "negative"]);
-var ClaimStatusSchema = z17.enum([
-  "proposed",
-  "supported",
-  "refuted",
-  "contested",
-  "unverified",
-  "blocked"
-]);
-var WorkGraphNodeAuthoritySchema = z17.enum([
-  "explicit",
-  "inferred",
-  "adopted"
-]);
-var ClaimSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  claimId: OperationalWorldIdSchema,
-  statement: z17.string().trim().min(1).max(4e3),
-  kind: ClaimKindSchema,
-  polarity: ClaimPolaritySchema,
-  status: ClaimStatusSchema,
-  confidence: ConfidenceSchema,
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).max(256),
-  dependsOnClaimIds: z17.array(OperationalWorldIdSchema).max(256),
-  tags: z17.array(z17.string().trim().min(1).max(128)).max(64),
-  /** Structured proposition fields used to group competing claims. */
-  subjectNodeId: OperationalWorldIdSchema.optional(),
-  predicate: z17.string().trim().min(1).max(512).optional(),
-  objectValue: JsonValueSchema.optional(),
-  validFrom: z17.string().datetime().optional(),
-  validTo: z17.string().datetime().optional(),
-  authority: WorkGraphNodeAuthoritySchema.optional()
-}).strict().superRefine((claim, ctx) => {
-  if (claim.validFrom !== void 0 && claim.validTo !== void 0 && Date.parse(claim.validTo) < Date.parse(claim.validFrom)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["validTo"],
-      message: "validTo must not precede validFrom"
-    });
-  }
-});
-var ConflictKindSchema = z17.enum([
-  "contradiction",
-  "source_disagreement",
-  "temporal",
-  "schema",
-  "authority"
-]);
-var ConflictStatusSchema = z17.enum([
-  "open",
-  "resolved",
-  "accepted_uncertainty"
-]);
-var ConflictResolutionSchema = z17.object({
-  decision: z17.string().trim().min(1).max(2e3),
-  rationale: z17.string().trim().min(1).max(4e3),
-  resolvedBy: z17.string().trim().min(1).max(256),
-  resolvedAt: z17.string().datetime(),
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).max(256)
-}).strict();
-var ConflictSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  conflictId: OperationalWorldIdSchema,
-  kind: ConflictKindSchema,
-  summary: z17.string().trim().min(1).max(4e3),
-  claimIds: z17.array(OperationalWorldIdSchema).min(2).max(64),
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).max(256),
-  status: ConflictStatusSchema,
-  resolution: ConflictResolutionSchema.optional()
-}).strict().superRefine((conflict, ctx) => {
-  if (new Set(conflict.claimIds).size !== conflict.claimIds.length) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["claimIds"],
-      message: "claimIds must contain at least two distinct claims"
-    });
-  }
-  if (conflict.status !== "open" && !conflict.resolution) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["resolution"],
-      message: "a non-open conflict requires a resolution record"
-    });
-  }
-});
-var WorkGraphNodeKindSchema = z17.enum([
-  "objective",
-  "requirement",
-  "document",
-  "section",
-  "task",
-  "feature",
-  "component",
-  "module",
-  "acceptance",
-  "symbol",
-  "entity",
-  "event",
-  "action",
-  "mutation",
-  "verification",
-  "blocker",
-  "policy",
-  "artifact",
-  "decision",
-  "claim",
-  "evidence",
-  "conflict",
-  "validation",
-  "actor",
-  "conversation",
-  "relationship"
-]);
-var WorkGraphNodeStatusSchema = z17.enum([
-  "proposed",
-  "active",
-  "blocked",
-  "complete",
-  "invalid",
-  "superseded"
-]);
-var WorkGraphTargetRefSchema = z17.discriminatedUnion("type", [
-  z17.object({ type: z17.literal("node"), nodeId: OperationalWorldIdSchema }).strict(),
-  z17.object({ type: z17.literal("claim"), claimId: OperationalWorldIdSchema }).strict(),
-  z17.object({
-    type: z17.literal("conflict"),
-    conflictId: OperationalWorldIdSchema
-  }).strict(),
-  z17.object({
-    type: z17.literal("evidence"),
-    evidenceId: OperationalWorldIdSchema
-  }).strict(),
-  z17.object({ type: z17.literal("source"), bindingId: OperationalWorldIdSchema }).strict(),
-  z17.object({
-    type: z17.literal("artifact"),
-    uri: z17.string().trim().min(1).max(4096),
-    revision: OperationalWorldRevisionSchema.optional()
-  }).strict()
-]);
-var WorkActionPreconditionSchema = z17.object({
-  preconditionId: OperationalWorldIdSchema,
-  description: z17.string().trim().min(1).max(2e3),
-  status: z17.enum(["unknown", "satisfied", "unsatisfied", "waived"]),
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).max(256)
-}).strict();
-var WorkActionMutationSchema = z17.object({
-  mutationId: OperationalWorldIdSchema,
-  kind: z17.enum(["create", "update", "delete", "execute", "deliver"]),
-  target: WorkGraphTargetRefSchema,
-  description: z17.string().trim().min(1).max(2e3),
-  reversible: z17.boolean()
-}).strict();
-var WorkActionApprovalSchema = z17.object({
-  required: z17.boolean(),
-  status: z17.enum(["not_required", "pending", "approved", "rejected"]),
-  approvedBy: z17.string().trim().min(1).max(256).optional(),
-  approvedAt: z17.string().datetime().optional()
-}).strict().superRefine((approval, ctx) => {
-  if (!approval.required && approval.status !== "not_required") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["status"],
-      message: "approval status must be not_required when approval is not required"
-    });
-  }
-  if (approval.required && approval.status === "not_required") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["status"],
-      message: "required approval cannot have not_required status"
-    });
-  }
-  if (approval.status === "approved" && (!approval.approvedBy || !approval.approvedAt)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["approvedBy"],
-      message: "approved actions require approvedBy and approvedAt"
-    });
-  }
-});
-var WorkActionContractSchema = z17.object({
-  preconditions: z17.array(WorkActionPreconditionSchema).max(256),
-  mutations: z17.array(WorkActionMutationSchema).max(256),
-  sideEffects: z17.array(z17.string().trim().min(1).max(2e3)).max(256),
-  approval: WorkActionApprovalSchema,
-  authority: z17.enum([
-    "operator_explicit",
-    "delegated_scope",
-    "policy",
-    "none"
-  ]),
-  risk: z17.enum(["none", "low", "medium", "high", "critical"])
-}).strict();
-var WorkGraphNodeReferenceSchema = z17.discriminatedUnion("type", [
-  z17.object({ type: z17.literal("claim"), claimId: OperationalWorldIdSchema }).strict(),
-  z17.object({
-    type: z17.literal("conflict"),
-    conflictId: OperationalWorldIdSchema
-  }).strict(),
-  z17.object({
-    type: z17.literal("evidence"),
-    evidenceId: OperationalWorldIdSchema
-  }).strict(),
-  z17.object({ type: z17.literal("source"), bindingId: OperationalWorldIdSchema }).strict()
-]);
-var WorkGraphNodeSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  nodeId: OperationalWorldIdSchema,
-  kind: WorkGraphNodeKindSchema,
-  label: z17.string().trim().min(1).max(1e3),
-  description: z17.string().trim().max(4e3).optional(),
-  status: WorkGraphNodeStatusSchema,
-  authority: WorkGraphNodeAuthoritySchema,
-  parentNodeId: OperationalWorldIdSchema.optional(),
-  bindingIds: z17.array(OperationalWorldIdSchema).min(1).max(256),
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).min(1).max(256),
-  confidence: ConfidenceSchema,
-  revision: OperationalWorldRevisionSchema,
-  validFrom: z17.string().datetime(),
-  validTo: z17.string().datetime().optional(),
-  scope: OperationalFactScopeSchema,
-  taskEpoch: z17.number().int().nonnegative().optional(),
-  metadataProvenance: OperationalMetadataProvenanceSchema,
-  reference: WorkGraphNodeReferenceSchema.optional(),
-  actionContract: WorkActionContractSchema.optional(),
-  attributes: z17.record(z17.string(), JsonValueSchema)
-}).strict().superRefine((node, ctx) => {
-  const expectedReference = node.kind === "claim" ? "claim" : node.kind === "conflict" ? "conflict" : node.kind === "evidence" ? "evidence" : null;
-  if (expectedReference && node.reference?.type !== expectedReference) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["reference"],
-      message: `${node.kind} nodes require a matching ${expectedReference} reference`
-    });
-  }
-  if (node.parentNodeId === node.nodeId) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["parentNodeId"],
-      message: "a node cannot be its own parent"
-    });
-  }
-  if ((node.kind === "action" || node.kind === "mutation") && !node.actionContract) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["actionContract"],
-      message: `${node.kind} nodes require an action contract`
-    });
-  }
-  if (node.validFrom && node.validTo && Date.parse(node.validTo) < Date.parse(node.validFrom)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["validTo"],
-      message: "validTo must not precede validFrom"
-    });
-  }
-  if (node.scope?.taskEpoch !== void 0 && node.taskEpoch !== void 0 && node.scope.taskEpoch !== node.taskEpoch) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["taskEpoch"],
-      message: "taskEpoch must match scope.taskEpoch"
-    });
-  }
-});
-var WorkGraphEdgeKindSchema = z17.enum([
-  "contains",
-  "part_of",
-  "decomposes_to",
-  "depends_on",
-  "satisfies",
-  "produces",
-  "supports",
-  "refutes",
-  "evidences",
-  "verified_by",
-  "evidenced_by",
-  "contradicted_by",
-  "blocked_by",
-  "derived_from",
-  "implements",
-  "modifies",
-  "validates",
-  "conflicts_with",
-  "supersedes",
-  "mentions",
-  "governs",
-  "blocks",
-  "assigned_to",
-  "attempts",
-  "invalidates",
-  "resolves",
-  "synthesizes",
-  "replied_to",
-  "reacted_to",
-  "delivered_to",
-  "owned_by",
-  "relates_to"
-]);
-var WorkGraphEdgeSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  edgeId: OperationalWorldIdSchema,
-  sourceNodeId: OperationalWorldIdSchema,
-  targetNodeId: OperationalWorldIdSchema,
-  kind: WorkGraphEdgeKindSchema,
-  directed: z17.boolean(),
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).min(1).max(256),
-  confidence: ConfidenceSchema,
-  revision: OperationalWorldRevisionSchema,
-  validFrom: z17.string().datetime(),
-  validTo: z17.string().datetime().optional(),
-  scope: OperationalFactScopeSchema,
-  taskEpoch: z17.number().int().nonnegative().optional(),
-  metadataProvenance: OperationalMetadataProvenanceSchema,
-  attributes: z17.record(z17.string(), JsonValueSchema)
-}).strict().superRefine((edge, ctx) => {
-  if (edge.sourceNodeId === edge.targetNodeId) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["targetNodeId"],
-      message: "self-referential edges are not permitted"
-    });
-  }
-  if (edge.validFrom && edge.validTo && Date.parse(edge.validTo) < Date.parse(edge.validFrom)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["validTo"],
-      message: "validTo must not precede validFrom"
-    });
-  }
-  if (edge.scope?.taskEpoch !== void 0 && edge.taskEpoch !== void 0 && edge.scope.taskEpoch !== edge.taskEpoch) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["taskEpoch"],
-      message: "taskEpoch must match scope.taskEpoch"
-    });
-  }
-});
-function addDuplicateIdIssues(values, path3, ctx) {
-  const seen = /* @__PURE__ */ new Set();
-  for (let index = 0; index < values.length; index++) {
-    const value = values[index];
-    if (seen.has(value)) {
-      ctx.addIssue({
-        code: "custom",
-        path: [path3, index],
-        message: `duplicate identifier: ${value}`
-      });
-    }
-    seen.add(value);
-  }
-}
-function validateGraphCollections(value, ctx) {
-  addDuplicateIdIssues(value.nodes.map((item) => item.nodeId), "nodes", ctx);
-  addDuplicateIdIssues(value.edges.map((item) => item.edgeId), "edges", ctx);
-  addDuplicateIdIssues(value.sourceBindings.map((item) => item.bindingId), "sourceBindings", ctx);
-  addDuplicateIdIssues(value.evidenceRefs.map((item) => item.evidenceId), "evidenceRefs", ctx);
-  addDuplicateIdIssues(value.claims.map((item) => item.claimId), "claims", ctx);
-  addDuplicateIdIssues(value.conflicts.map((item) => item.conflictId), "conflicts", ctx);
-  const nodeIds = new Set(value.nodes.map((item) => item.nodeId));
-  const bindingIds = new Set(value.sourceBindings.map((item) => item.bindingId));
-  const evidenceIds = new Set(value.evidenceRefs.map((item) => item.evidenceId));
-  const claimIds = new Set(value.claims.map((item) => item.claimId));
-  const conflictIds = new Set(value.conflicts.map((item) => item.conflictId));
-  value.nodes.forEach((node, index) => {
-    if (node.parentNodeId && !nodeIds.has(node.parentNodeId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["nodes", index, "parentNodeId"],
-        message: `unknown parent node: ${node.parentNodeId}`
-      });
-    }
-    node.bindingIds.forEach((id2) => {
-      if (!bindingIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["nodes", index, "bindingIds"],
-          message: `unknown source binding: ${id2}`
-        });
-      }
-    });
-    node.evidenceRefIds.forEach((id2) => {
-      if (!evidenceIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["nodes", index, "evidenceRefIds"],
-          message: `unknown evidence reference: ${id2}`
-        });
-      }
-    });
-    if (node.reference?.type === "claim" && !claimIds.has(node.reference.claimId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["nodes", index, "reference", "claimId"],
-        message: `unknown claim: ${node.reference.claimId}`
-      });
-    }
-    if (node.reference?.type === "conflict" && !conflictIds.has(node.reference.conflictId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["nodes", index, "reference", "conflictId"],
-        message: `unknown conflict: ${node.reference.conflictId}`
-      });
-    }
-    if (node.reference?.type === "evidence" && !evidenceIds.has(node.reference.evidenceId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["nodes", index, "reference", "evidenceId"],
-        message: `unknown evidence reference: ${node.reference.evidenceId}`
-      });
-    }
-    if (node.reference?.type === "source" && !bindingIds.has(node.reference.bindingId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["nodes", index, "reference", "bindingId"],
-        message: `unknown source binding: ${node.reference.bindingId}`
-      });
-    }
-    node.actionContract?.preconditions.forEach((precondition) => {
-      precondition.evidenceRefIds.forEach((id2) => {
-        if (!evidenceIds.has(id2)) {
-          ctx.addIssue({
-            code: "custom",
-            path: ["nodes", index, "actionContract", "preconditions"],
-            message: `unknown precondition evidence reference: ${id2}`
-          });
-        }
-      });
-    });
-    node.actionContract?.mutations.forEach((mutation, mutationIndex) => {
-      const target = mutation.target;
-      const targetExists = target.type === "artifact" || target.type === "node" && nodeIds.has(target.nodeId) || target.type === "claim" && claimIds.has(target.claimId) || target.type === "conflict" && conflictIds.has(target.conflictId) || target.type === "evidence" && evidenceIds.has(target.evidenceId) || target.type === "source" && bindingIds.has(target.bindingId);
-      if (!targetExists) {
-        ctx.addIssue({
-          code: "custom",
-          path: [
-            "nodes",
-            index,
-            "actionContract",
-            "mutations",
-            mutationIndex,
-            "target"
-          ],
-          message: "action mutation target is absent from the graph"
-        });
-      }
-    });
-  });
-  value.edges.forEach((edge, index) => {
-    if (!nodeIds.has(edge.sourceNodeId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["edges", index, "sourceNodeId"],
-        message: `unknown source node: ${edge.sourceNodeId}`
-      });
-    }
-    if (!nodeIds.has(edge.targetNodeId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["edges", index, "targetNodeId"],
-        message: `unknown target node: ${edge.targetNodeId}`
-      });
-    }
-    edge.evidenceRefIds.forEach((id2) => {
-      if (!evidenceIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["edges", index, "evidenceRefIds"],
-          message: `unknown evidence reference: ${id2}`
-        });
-      }
-    });
-  });
-  value.evidenceRefs.forEach((evidence, index) => {
-    if (!bindingIds.has(evidence.bindingId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["evidenceRefs", index, "bindingId"],
-        message: `unknown source binding: ${evidence.bindingId}`
-      });
-    }
-  });
-  value.claims.forEach((claim, index) => {
-    if (claim.subjectNodeId && !nodeIds.has(claim.subjectNodeId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["claims", index, "subjectNodeId"],
-        message: `unknown claim subject node: ${claim.subjectNodeId}`
-      });
-    }
-    claim.evidenceRefIds.forEach((id2) => {
-      if (!evidenceIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["claims", index, "evidenceRefIds"],
-          message: `unknown evidence reference: ${id2}`
-        });
-      }
-    });
-    claim.dependsOnClaimIds.forEach((id2) => {
-      if (!claimIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["claims", index, "dependsOnClaimIds"],
-          message: `unknown claim dependency: ${id2}`
-        });
-      }
-    });
-  });
-  value.conflicts.forEach((conflict, index) => {
-    conflict.claimIds.forEach((id2) => {
-      if (!claimIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["conflicts", index, "claimIds"],
-          message: `unknown conflict claim: ${id2}`
-        });
-      }
-    });
-    conflict.evidenceRefIds.forEach((id2) => {
-      if (!evidenceIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["conflicts", index, "evidenceRefIds"],
-          message: `unknown evidence reference: ${id2}`
-        });
-      }
-    });
-    conflict.resolution?.evidenceRefIds.forEach((id2) => {
-      if (!evidenceIds.has(id2)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["conflicts", index, "resolution", "evidenceRefIds"],
-          message: `unknown resolution evidence reference: ${id2}`
-        });
-      }
-    });
-  });
-}
-var WorkGraphSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  graphId: OperationalWorldIdSchema,
-  revision: OperationalWorldRevisionSchema,
-  previousRevision: OperationalWorldRevisionSchema.optional(),
-  title: z17.string().trim().min(1).max(1e3),
-  nodes: z17.array(WorkGraphNodeSchema).max(1e5),
-  edges: z17.array(WorkGraphEdgeSchema).max(25e4),
-  sourceBindings: z17.array(SourceBindingSchema).max(1e5),
-  evidenceRefs: z17.array(EvidenceRefSchema).max(25e4),
-  claims: z17.array(ClaimSchema).max(1e5),
-  conflicts: z17.array(ConflictSchema).max(1e5),
-  createdAt: z17.string().datetime(),
-  updatedAt: z17.string().datetime()
-}).strict().superRefine(validateGraphCollections);
-var WorldPatchOperationSchema = z17.discriminatedUnion("op", [
-  z17.object({ op: z17.literal("upsert_node"), node: WorkGraphNodeSchema }).strict(),
-  z17.object({
-    op: z17.literal("remove_node"),
-    nodeId: OperationalWorldIdSchema,
-    cascade: z17.boolean()
-  }).strict(),
-  z17.object({ op: z17.literal("upsert_edge"), edge: WorkGraphEdgeSchema }).strict(),
-  z17.object({ op: z17.literal("remove_edge"), edgeId: OperationalWorldIdSchema }).strict(),
-  z17.object({
-    op: z17.literal("upsert_source_binding"),
-    sourceBinding: SourceBindingSchema
-  }).strict(),
-  z17.object({
-    op: z17.literal("remove_source_binding"),
-    bindingId: OperationalWorldIdSchema
-  }).strict(),
-  z17.object({
-    op: z17.literal("upsert_evidence_ref"),
-    evidenceRef: EvidenceRefSchema
-  }).strict(),
-  z17.object({
-    op: z17.literal("remove_evidence_ref"),
-    evidenceId: OperationalWorldIdSchema
-  }).strict(),
-  z17.object({ op: z17.literal("upsert_claim"), claim: ClaimSchema }).strict(),
-  z17.object({
-    op: z17.literal("remove_claim"),
-    claimId: OperationalWorldIdSchema
-  }).strict(),
-  z17.object({ op: z17.literal("upsert_conflict"), conflict: ConflictSchema }).strict(),
-  z17.object({
-    op: z17.literal("remove_conflict"),
-    conflictId: OperationalWorldIdSchema
-  }).strict()
-]);
-var WorldPatchSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  patchId: OperationalWorldIdSchema,
-  graphId: OperationalWorldIdSchema,
-  /** Optimistic-concurrency precondition. */
-  baseRevision: OperationalWorldRevisionSchema,
-  targetRevision: OperationalWorldRevisionSchema,
-  operations: z17.array(WorldPatchOperationSchema).min(1).max(1e4),
-  rationale: z17.string().trim().min(1).max(4e3),
-  createdBy: z17.string().trim().min(1).max(256),
-  createdAt: z17.string().datetime()
-}).strict().superRefine((patch, ctx) => {
-  if (patch.baseRevision === patch.targetRevision) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["targetRevision"],
-      message: "targetRevision must differ from baseRevision"
-    });
-  }
-});
-var ValidationIssueSeveritySchema = z17.enum([
-  "info",
-  "warning",
-  "error"
-]);
-var OperationalValidationIssueSchema = z17.object({
-  code: z17.string().trim().min(1).max(128),
-  severity: ValidationIssueSeveritySchema,
-  message: z17.string().trim().min(1).max(4e3),
-  path: z17.array(z17.union([z17.string(), z17.number().int().nonnegative()])).max(64),
-  nodeId: OperationalWorldIdSchema.optional(),
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).max(256)
-}).strict();
-var OperationalValidationStatusSchema = z17.enum([
-  "pass",
-  "fail",
-  "partial"
-]);
-var OperationalValidationResultSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  valid: z17.boolean(),
-  status: OperationalValidationStatusSchema,
-  checkedRevision: OperationalWorldRevisionSchema,
-  issues: z17.array(OperationalValidationIssueSchema).max(1e4),
-  checkedAt: z17.string().datetime()
-}).strict().superRefine((result, ctx) => {
-  const hasErrors = result.issues.some((issue2) => issue2.severity === "error");
-  if (result.valid !== (result.status === "pass")) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["valid"],
-      message: "valid must be true exactly when status is pass"
-    });
-  }
-  if (result.status === "pass" && hasErrors) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["issues"],
-      message: "a passing result cannot contain error issues"
-    });
-  }
-  if (result.status === "fail" && !hasErrors) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["issues"],
-      message: "a failing result must contain at least one error issue"
-    });
-  }
-});
-var ValidationArtifactHashSchema = z17.object({
-  uri: z17.string().trim().min(1).max(4096),
-  algorithm: z17.enum(["sha256", "sha512", "blake3"]),
-  digest: z17.string().trim().min(1).max(512)
-}).strict();
-var OperationalValidationReceiptSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  receiptId: OperationalWorldIdSchema,
-  graphId: OperationalWorldIdSchema,
-  patchId: OperationalWorldIdSchema.optional(),
-  baseRevision: OperationalWorldRevisionSchema,
-  resultRevision: OperationalWorldRevisionSchema,
-  validator: z17.object({
-    name: z17.string().trim().min(1).max(256),
-    version: z17.string().trim().min(1).max(128)
-  }).strict(),
-  startedAt: z17.string().datetime(),
-  finishedAt: z17.string().datetime(),
-  result: OperationalValidationResultSchema,
-  evidenceRefIds: z17.array(OperationalWorldIdSchema).max(1e4),
-  artifactHashes: z17.array(ValidationArtifactHashSchema).max(1e4)
-}).strict().superRefine((receipt, ctx) => {
-  if (receipt.result.checkedRevision !== receipt.resultRevision) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["result", "checkedRevision"],
-      message: "checkedRevision must equal resultRevision"
-    });
-  }
-  if (Date.parse(receipt.finishedAt) < Date.parse(receipt.startedAt)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["finishedAt"],
-      message: "finishedAt must not precede startedAt"
-    });
-  }
-});
-var ReasoningSliceSelectionSchema = z17.object({
-  strategy: z17.enum(["exact", "lexical", "semantic", "graph", "hybrid"]),
-  graphHops: z17.number().int().nonnegative().max(32),
-  maxCharacters: z17.number().int().positive(),
-  truncated: z17.boolean(),
-  omissions: z17.array(z17.string().trim().min(1).max(1e3)).max(256),
-  evidenceRoles: z17.array(EvidenceRoleSchema).max(5)
-}).strict();
-var ReasoningSliceSchema = z17.object({
-  schemaVersion: OperationalWorldSchemaVersionSchema,
-  sliceId: OperationalWorldIdSchema,
-  graphId: OperationalWorldIdSchema,
-  revision: OperationalWorldRevisionSchema,
-  objective: z17.string().trim().min(1).max(4e3),
-  focusNodeIds: z17.array(OperationalWorldIdSchema).min(1).max(256),
-  nodes: z17.array(WorkGraphNodeSchema).max(1e4),
-  edges: z17.array(WorkGraphEdgeSchema).max(25e3),
-  sourceBindings: z17.array(SourceBindingSchema).max(1e4),
-  evidenceRefs: z17.array(EvidenceRefSchema).max(25e3),
-  claims: z17.array(ClaimSchema).max(1e4),
-  conflicts: z17.array(ConflictSchema).max(1e4),
-  selection: ReasoningSliceSelectionSchema,
-  generatedAt: z17.string().datetime()
-}).strict().superRefine((slice, ctx) => {
-  validateGraphCollections(slice, ctx);
-  const nodeIds = new Set(slice.nodes.map((node) => node.nodeId));
-  slice.focusNodeIds.forEach((nodeId, index) => {
-    if (!nodeIds.has(nodeId)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["focusNodeIds", index],
-        message: `focus node is absent from the reasoning slice: ${nodeId}`
-      });
-    }
-  });
+var hookSchema = z17.nativeEnum(PluginHook);
+var manifestSchema = z17.object({
+  name: z17.string().min(1, "Plugin name is required").regex(/^[a-z0-9_-]+$/, "Plugin name must be lowercase alphanumeric with hyphens/underscores"),
+  version: z17.string().min(1, "Plugin version is required"),
+  description: z17.string().default(""),
+  author: z17.string().default(""),
+  hooks: z17.array(hookSchema).default([]),
+  dependencies: z17.array(z17.string()).default([]),
+  source: z17.enum(["user", "project", "npm"]),
+  path: z17.string().optional()
 });
 
+// packages/orchestrator/dist/taskNormalizer.js
+init_dist();
+
 // packages/orchestrator/dist/promptLoader.js
 import { readFileSync as readFileSync4, existsSync as existsSync4 } from "node:fs";
 import { join as join13, dirname as dirname7, resolve as resolve10, sep as sep2 } from "node:path";
@@ -300817,11 +300958,26 @@ function loadPrompt(promptPath, vars) {
   return content.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
 }
 
+// packages/orchestrator/dist/dispatcher.js
+init_dist();
+
+// packages/orchestrator/dist/plannerRunner.js
+init_dist();
+
+// packages/orchestrator/dist/scoutRunner.js
+init_dist();
+
+// packages/orchestrator/dist/editorRunner.js
+init_dist();
+
+// packages/orchestrator/dist/verifierRunner.js
+init_dist();
+
 // packages/orchestrator/dist/terminalTaskReport.js
-init_dist3();
+init_dist4();
 
 // packages/orchestrator/dist/liveVirtualContext.js
-init_dist();
+init_dist2();
 
 // packages/orchestrator/dist/live-memory-passages.js
 var stopWords = new Set("a an and are as at be by can do for from has have how i in is it its me my of on or our please that the their them these they this those to us was we what when where which who will with you your".split(" "));
@@ -300891,7 +301047,7 @@ var RERANK_SYSTEM = [
 ].join(" ");
 
 // packages/orchestrator/dist/structuredMemoryInference.js
-init_dist();
+init_dist2();
 var EXTRACTION_SYSTEM = [
   "You classify durable structured memory from exact user-authored source chunks.",
   "This is a semantic inference task: extract only information that will matter beyond the immediate wording.",
@@ -301039,16 +301195,23 @@ var pendingSchema = z19.object({
   expectedEntryCount: integer2.nonnegative()
 }).strict();
 
+// packages/orchestrator/dist/agenticRunner.js
+init_dist();
+
+// packages/orchestrator/dist/featureWorkflowRunnerBoundary.js
+init_dist();
+
 // packages/orchestrator/dist/featureWorkflow.js
+init_dist();
+init_dist4();
 import { z as z20 } from "zod";
-init_dist3();
 
 // packages/orchestrator/dist/contentAddressedArtifactStore.js
 var DEFAULT_MAX_ARTIFACT_BYTES = 32 * 1024 * 1024;
 var DEFAULT_MAX_STORE_BYTES = 512 * 1024 * 1024;
 
 // packages/orchestrator/dist/verificationCommand.js
-init_dist3();
+init_dist4();
 
 // packages/orchestrator/dist/featureWorkflow.js
 var SCHEMA2 = "omnius.feature-workflow-checkpoint.v1";
@@ -301332,8 +301495,17 @@ var activeSchema = z22.object({
   evidence: z22.object({ phases: z22.number().int().min(1).max(3), calls: z22.array(call).min(1).max(12) }).optional()
 });
 
+// packages/orchestrator/dist/operational-world/reducer.js
+init_dist();
+
+// packages/orchestrator/dist/operational-world/persistence.js
+init_dist();
+
+// packages/orchestrator/dist/operational-world/reasoningSlice.js
+init_dist();
+
 // packages/orchestrator/dist/verificationInvocation.js
-init_dist3();
+init_dist4();
 
 // packages/orchestrator/dist/agenticRunner.js
 import { z as z24 } from "zod";
@@ -301357,7 +301529,7 @@ var PERSONALITY_PRESETS = {
 var PRESET_NAMES = Object.keys(PERSONALITY_PRESETS);
 
 // packages/orchestrator/dist/phase-skill-guidance.js
-init_dist3();
+init_dist4();
 
 // packages/orchestrator/dist/deliveryCoverage.js
 import { z as z23 } from "zod";
@@ -301443,19 +301615,19 @@ var deliveryCoverageManifestSchema = z23.object({
 });
 
 // packages/orchestrator/dist/agenticRunner.js
-init_dist3();
-init_dist();
+init_dist4();
+init_dist2();
 
 // packages/orchestrator/dist/taskHandoff.js
-init_dist3();
+init_dist4();
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 
 // packages/orchestrator/dist/codeGraphLink.js
-init_dist3();
+init_dist4();
 
 // packages/orchestrator/dist/agenticRunner.js
-init_dist3();
-init_dist3();
+init_dist4();
+init_dist4();
 
 // packages/orchestrator/dist/backend-stall-policy.js
 var DEFAULT_BACKEND_STALL_LIMITS = {
@@ -301464,31 +301636,31 @@ var DEFAULT_BACKEND_STALL_LIMITS = {
 };
 
 // packages/orchestrator/dist/failure-resolution-transaction.js
-init_dist3();
+init_dist4();
 
 // packages/orchestrator/dist/contextWindowDump.js
-init_dist();
+init_dist2();
 var DEFAULT_INDEX_MAX_BYTES = 2 * 1024 * 1024;
 
 // packages/orchestrator/dist/decomposition-orchestrator.js
-init_dist3();
+init_dist4();
 
 // packages/orchestrator/dist/longhaul-integration.js
-init_dist3();
-init_dist();
-init_dist();
+init_dist4();
+init_dist2();
+init_dist2();
 
 // packages/orchestrator/dist/contextSNR.js
-init_dist();
+init_dist2();
 
 // packages/orchestrator/dist/corpus-native-source-proof-memo.js
-init_dist();
+init_dist2();
 
 // packages/orchestrator/dist/corpus-page-review-source.js
-init_dist();
+init_dist2();
 
 // packages/orchestrator/dist/contextEngine.js
-init_dist();
+init_dist2();
 
 // packages/orchestrator/dist/agenticRunner.js
 var SYSTEM_PROMPT_COMMON = `${STE_COMMUNICATION_POLICY}
@@ -301599,7 +301771,7 @@ function brokerAdmissionFailureResponse(err) {
 }
 
 // packages/orchestrator/dist/memory-compiler-replay.js
-init_dist();
+init_dist2();
 
 // packages/orchestrator/dist/index.js
 init_ollama_pool();
@@ -302733,7 +302905,7 @@ var SENSITIVE_HOME_FILES = [
 ];
 
 // packages/orchestrator/dist/subagent-prompt.js
-init_dist3();
+init_dist4();
 var WORKER_PREAMBLE = [
   "You are an isolated sub-agent with a deliberately small context and a single,",
   "bounded purpose. You were spawned by an orchestrator that holds the overall",