omnius 1.0.813 → 1.0.816

package/dist/memory-maintenance-worker.js

@@ -626,6 +626,1737 @@ var DEFAULT_CAPACITIES = {
   L5: Number.POSITIVE_INFINITY
 };
 
+// packages/schemas/dist/feature-workflow.js
+import { z } from "zod";
+var FEATURE_WORKFLOW_PLAN_SCHEMA = "omnius.feature-workflow-plan.v1";
+var FEATURE_WORKFLOW_PHASES = [
+  "research",
+  "specification",
+  "implementation",
+  "integration",
+  "acceptance",
+  "handoff"
+];
+var FeatureWorkflowPhaseSchema = z.enum(FEATURE_WORKFLOW_PHASES);
+var id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,119}$/);
+var text = z.string().trim().min(1).max(4e3);
+var FeatureWorkflowArtifactReferenceSchema = z.string().regex(/^omnius-artifact:\/\/sha256\/[a-f0-9]{64}$/);
+var path = z.string().trim().min(1).max(1e3);
+var 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();
+var 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);
+});
+var 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();
+var 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()
+]);
+var FeatureWorkflowToolJsonSchema = z.toJSONSchema(FeatureWorkflowToolInputSchema, { reused: "ref", unrepresentable: "any" });
+
+// packages/schemas/dist/messages.js
+import { z as z2 } from "zod";
+var 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 = 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 = 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 = z5.enum([
+  "bugfix",
+  "feature",
+  "refactor",
+  "migration",
+  "dependency-upgrade",
+  "test",
+  "docs",
+  "infra"
+]);
+var UrgencySchema = z5.enum(["low", "medium", "high", "critical"]);
+var 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()
+});
+var 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 = z6.enum([
+  "inspect",
+  "patch",
+  "test",
+  "migrate",
+  "verify",
+  "merge"
+]);
+var 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())
+});
+var 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 = z7.enum([
+  "diff",
+  "rewrite",
+  "append",
+  "create"
+]);
+var 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()
+});
+var NeedsMoreContextSchema = z7.object({
+  reason: z7.string().min(1),
+  requestedPaths: z7.array(z7.string()).optional(),
+  requestedSymbols: z7.array(z7.string()).optional()
+});
+var 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 = z8.enum(["pass", "fail", "partial"]);
+var VerificationNextActionSchema = z8.enum([
+  "finish",
+  "retry",
+  "rollback",
+  "inspect_more"
+]);
+var 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 = z9.enum([
+  "typescript",
+  "javascript",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "csharp",
+  "sql",
+  "other"
+]);
+var PackageManagerSchema = z9.enum([
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "pip",
+  "poetry",
+  "cargo",
+  "go-modules",
+  "maven",
+  "gradle",
+  "other"
+]);
+var BuildSystemSchema = z9.enum([
+  "tsc",
+  "vite",
+  "webpack",
+  "esbuild",
+  "turbo",
+  "nx",
+  "make",
+  "cmake",
+  "cargo",
+  "gradle",
+  "maven",
+  "other"
+]);
+var MigrationSystemSchema = z9.enum([
+  "prisma",
+  "drizzle",
+  "knex",
+  "alembic",
+  "flyway",
+  "liquibase",
+  "typeorm",
+  "sequelize",
+  "other",
+  "none"
+]);
+var 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 = 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()
+});
+var 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()
+});
+var 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 = z11.enum([
+  "single_pass",
+  "multi_agent",
+  "hybrid"
+]);
+var TaskComplexitySchema = z11.enum(["low", "medium", "high"]);
+var AgentRoleSchema = z11.enum([
+  "planner",
+  "scout",
+  "editor",
+  "verifier",
+  "researcher"
+]);
+var 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()
+});
+var 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 = z12.enum(["low", "medium", "high", "critical"]);
+var 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()
+});
+var 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"
+]);
+var 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()
+});
+var 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 = z13.enum([
+  "system",
+  "user",
+  "assistant",
+  "tool"
+]);
+var 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()
+});
+var 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()
+});
+var 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()
+});
+var 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()
+});
+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: z13.unknown(),
+  /** Human-readable label used in prompt injection for the schema */
+  schemaLabel: z13.string().optional()
+});
+var 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()
+});
+var 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 = 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 = 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";
+var OPERATIONAL_WORLD_SCHEMA_VERSION = "omnius.operational-world.v1";
+var OperationalWorldSchemaVersionSchema = z16.literal(OPERATIONAL_WORLD_SCHEMA_VERSION);
+var OperationalWorldIdSchema = z16.string().trim().min(1).max(256);
+var OperationalWorldRevisionSchema = z16.string().trim().min(1).max(256);
+var ConfidenceSchema = z16.number().finite().min(0).max(1);
+var OperationalFactScopeSchema = z16.object({
+  kind: z16.enum([
+    "global",
+    "run",
+    "task",
+    "session",
+    "chat",
+    "thread",
+    "conversation",
+    "legacy_unscoped"
+  ]),
+  scopeId: OperationalWorldIdSchema,
+  taskEpoch: z16.number().int().nonnegative().optional()
+}).strict();
+var OperationalMetadataDerivedFieldSchema = z16.enum([
+  "source_evidence",
+  "confidence",
+  "revision",
+  "temporal_validity",
+  "scope",
+  "metadata_provenance"
+]);
+var 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()
+]);
+var JsonValueSchema = z16.lazy(() => z16.union([
+  z16.string(),
+  z16.number().finite(),
+  z16.boolean(),
+  z16.null(),
+  z16.array(JsonValueSchema),
+  z16.record(z16.string(), JsonValueSchema)
+]));
+var LineRangeLocatorSchema = z16.object({
+  type: z16.literal("line_range"),
+  startLine: z16.number().int().positive(),
+  endLine: z16.number().int().positive()
+}).strict();
+var CharacterRangeLocatorSchema = z16.object({
+  type: z16.literal("character_range"),
+  startOffset: z16.number().int().nonnegative(),
+  /** Exclusive end offset. */
+  endOffset: z16.number().int().positive()
+}).strict();
+var PageRangeLocatorSchema = z16.object({
+  type: z16.literal("page_range"),
+  startPage: z16.number().int().positive(),
+  endPage: z16.number().int().positive()
+}).strict();
+var 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();
+var 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();
+var JsonPathLocatorSchema = z16.object({
+  type: z16.literal("json_path"),
+  path: z16.string().trim().min(1).max(2048)
+}).strict();
+var HeadingLocatorSchema = z16.object({
+  type: z16.literal("heading"),
+  heading: z16.string().trim().min(1).max(1024),
+  occurrence: z16.number().int().positive().optional()
+}).strict();
+var 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();
+var UriFragmentLocatorSchema = z16.object({
+  type: z16.literal("uri_fragment"),
+  fragment: z16.string().trim().min(1).max(2048)
+}).strict();
+var 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"
+    });
+  }
+});
+var SourceAuthoritySchema = z16.enum([
+  "authoritative",
+  "primary",
+  "secondary",
+  "derived",
+  "unknown"
+]);
+var SourceFreshnessSchema = z16.enum(["fresh", "stale", "unknown"]);
+var SourceReadPolicySchema = z16.enum([
+  "immutable",
+  "snapshot",
+  "refresh_before_use",
+  "live"
+]);
+var 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();
+var EvidenceRoleSchema = z16.enum([
+  "supports",
+  "refutes",
+  "context",
+  "verification",
+  "blocker"
+]);
+var 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();
+var ClaimKindSchema = z16.enum([
+  "fact",
+  "inference",
+  "requirement",
+  "constraint",
+  "outcome"
+]);
+var ClaimPolaritySchema = z16.enum(["positive", "negative"]);
+var ClaimStatusSchema = z16.enum([
+  "proposed",
+  "supported",
+  "refuted",
+  "contested",
+  "unverified",
+  "blocked"
+]);
+var WorkGraphNodeAuthoritySchema = z16.enum([
+  "explicit",
+  "inferred",
+  "adopted"
+]);
+var 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"
+    });
+  }
+});
+var ConflictKindSchema = z16.enum([
+  "contradiction",
+  "source_disagreement",
+  "temporal",
+  "schema",
+  "authority"
+]);
+var ConflictStatusSchema = z16.enum([
+  "open",
+  "resolved",
+  "accepted_uncertainty"
+]);
+var 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();
+var 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"
+    });
+  }
+});
+var 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"
+]);
+var WorkGraphNodeStatusSchema = z16.enum([
+  "proposed",
+  "active",
+  "blocked",
+  "complete",
+  "invalid",
+  "superseded"
+]);
+var 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()
+]);
+var 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();
+var 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();
+var 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"
+    });
+  }
+});
+var 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();
+var 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()
+]);
+var 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"
+    });
+  }
+});
+var 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"
+]);
+var 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"
+    });
+  }
+});
+function addDuplicateIdIssues(values, path2, 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: [path2, 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 = 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);
+var 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()
+]);
+var 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"
+    });
+  }
+});
+var ValidationIssueSeveritySchema = z16.enum([
+  "info",
+  "warning",
+  "error"
+]);
+var 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();
+var OperationalValidationStatusSchema = z16.enum([
+  "pass",
+  "fail",
+  "partial"
+]);
+var 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((issue) => issue.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 = 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();
+var 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"
+    });
+  }
+});
+var 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();
+var 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/memory/dist/episodeStore.js
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
@@ -928,12 +2659,12 @@ var DEFAULT_CONFIG2 = {
 function extractQueryEntities(query) {
   const entities = [];
   const seen = /* @__PURE__ */ new Set();
-  const add = (text) => {
-    const normalized = text.trim().toLowerCase();
+  const add = (text2) => {
+    const normalized = text2.trim().toLowerCase();
     if (normalized.length < 2 || seen.has(normalized))
       return;
     seen.add(normalized);
-    entities.push(text.trim());
+    entities.push(text2.trim());
   };
   const filePattern = /(?:[\w./-]+\/[\w./-]+|[\w-]+\.\w{1,5})\b/g;
   for (const match of query.matchAll(filePattern)) {
@@ -1046,8 +2777,8 @@ function personalizedPageRank(graph, seedNodeIds, config) {
       if (delta > maxDelta)
         maxDelta = delta;
     }
-    for (const [id, score] of newScores)
-      scores.set(id, score);
+    for (const [id2, score] of newScores)
+      scores.set(id2, score);
     if (maxDelta < cfg.convergenceThreshold) {
       return scores;
     }
@@ -1300,13 +3031,13 @@ var EpisodeStore = class {
    *  orchestrator when an episode that was retrieved is detected to have
    *  been mentioned in a subsequent assistant turn. Idempotent on missing
    *  ids (no row → no-op). Returns the new count, or null if not found. */
-  bumpReuseCount(id, delta = 1) {
+  bumpReuseCount(id2, delta = 1) {
     const safeDelta = Number.isFinite(delta) ? delta : 1;
     try {
-      const result = this.db.prepare(`UPDATE episodes SET reuse_count = COALESCE(reuse_count, 0) + ? WHERE id = ?`).run(safeDelta, id);
+      const result = this.db.prepare(`UPDATE episodes SET reuse_count = COALESCE(reuse_count, 0) + ? WHERE id = ?`).run(safeDelta, id2);
       if (result.changes === 0)
         return null;
-      const row = this.db.prepare(`SELECT reuse_count FROM episodes WHERE id = ?`).get(id);
+      const row = this.db.prepare(`SELECT reuse_count FROM episodes WHERE id = ?`).get(id2);
       return row?.reuse_count ?? null;
     } catch {
       return null;
@@ -1372,7 +3103,7 @@ var EpisodeStore = class {
   }
   /** Insert a new episode. Returns the episode ID. */
   insert(ep) {
-    const id = randomUUID();
+    const id2 = randomUUID();
     const now = Date.now();
     const contentHash = episodeIdentityHash(ep);
     const modality = ep.modality ?? "text";
@@ -1393,17 +3124,17 @@ var EpisodeStore = class {
     this.db.prepare(`
       INSERT INTO episodes (id, timestamp, session_id, task_id, turn_number, modality, tool_name, content, content_hash, metadata, importance, decay_class, strength)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1.0)
-    `).run(id, now, ep.sessionId ?? null, ep.taskId ?? null, ep.turnNumber ?? null, modality, ep.toolName ?? null, ep.content, contentHash, ep.metadata ? JSON.stringify(ep.metadata) : null, importance, decayClass);
+    `).run(id2, now, ep.sessionId ?? null, ep.taskId ?? null, ep.turnNumber ?? null, modality, ep.toolName ?? null, ep.content, contentHash, ep.metadata ? JSON.stringify(ep.metadata) : null, importance, decayClass);
     if (this.graph) {
       try {
-        const episode = this.get(id);
+        const episode = this.get(id2);
         if (episode) {
           linkEpisode(episode, this, this.graph, this.zettelConfig);
         }
       } catch {
       }
     }
-    return id;
+    return id2;
   }
   /** Retrieve episodes matching a query, scored by recency + importance + (lexical + embedding). */
   search(query, opts = {}) {
@@ -1637,8 +3368,8 @@ var EpisodeStore = class {
     updateAll();
   }
   /** Get a single episode by ID. */
-  get(id) {
-    const row = this.db.prepare("SELECT * FROM episodes WHERE id = ?").get(id);
+  get(id2) {
+    const row = this.db.prepare("SELECT * FROM episodes WHERE id = ?").get(id2);
     return row ? this.rowToEpisode(row) : null;
   }
   /** Get recent episodes (for context assembly). */
@@ -1667,18 +3398,18 @@ var EpisodeStore = class {
     return result.changes;
   }
   /** Update embedding for an episode (async fill from WO-AM-10). */
-  setEmbedding(id, embedding) {
+  setEmbedding(id2, embedding) {
     const buf = Buffer.from(embedding.buffer);
-    this.db.prepare("UPDATE episodes SET embedding = ? WHERE id = ?").run(buf, id);
+    this.db.prepare("UPDATE episodes SET embedding = ? WHERE id = ?").run(buf, id2);
   }
   /** WO-AM-GAP-03: Set CLIP embedding for cross-modal retrieval (512d). */
-  setClipEmbedding(id, clipEmbedding) {
+  setClipEmbedding(id2, clipEmbedding) {
     const buf = Buffer.from(clipEmbedding.buffer);
-    this.db.prepare("UPDATE episodes SET clip_embedding = ? WHERE id = ?").run(buf, id);
+    this.db.prepare("UPDATE episodes SET clip_embedding = ? WHERE id = ?").run(buf, id2);
   }
   /** Update gist for an episode (from WO-AM-07 gist compression). */
-  setGist(id, gist) {
-    this.db.prepare("UPDATE episodes SET gist = ? WHERE id = ?").run(gist, id);
+  setGist(id2, gist) {
+    this.db.prepare("UPDATE episodes SET gist = ? WHERE id = ?").run(gist, id2);
   }
   /** Close the database connection. */
   close() {
@@ -2003,12 +3734,12 @@ var CRLParser = class {
     return props;
   }
   parseIdentifier() {
-    let id = "";
+    let id2 = "";
     while (this.pos < this.input.length && /[a-zA-Z0-9_]/.test(this.peek())) {
-      id += this.peek();
+      id2 += this.peek();
       this.pos++;
     }
-    return id;
+    return id2;
   }
   parseTemplate() {
     const start = this.pos;
@@ -2180,8 +3911,8 @@ var CRLEncoder = class {
   /**
    * Encode natural language text to CRL
    */
-  encode(text) {
-    let result = this.compress(text);
+  encode(text2) {
+    let result = this.compress(text2);
     const concepts = this.extractConcepts(result);
     const relations = this.extractRelations(result, concepts);
     if (relations.length > 0) {
@@ -2192,11 +3923,11 @@ var CRLEncoder = class {
   /**
    * Extract key concepts from text
    */
-  extractConcepts(text) {
+  extractConcepts(text2) {
     const concepts = [];
     const conceptPattern = /\[([^\]]+)\]/g;
     let match;
-    while ((match = conceptPattern.exec(text)) !== null) {
+    while ((match = conceptPattern.exec(text2)) !== null) {
       concepts.push({
         type: "concept",
         name: match[1],
@@ -2205,7 +3936,7 @@ var CRLEncoder = class {
       });
     }
     const implicitPattern = /\b([A-Z][a-z]+(?:_[A-Z][a-z]+)*)\b/g;
-    while ((match = implicitPattern.exec(text)) !== null) {
+    while ((match = implicitPattern.exec(text2)) !== null) {
       if (!concepts.find((c) => c.name === match[1])) {
         concepts.push({
           type: "concept",
@@ -2220,11 +3951,11 @@ var CRLEncoder = class {
   /**
    * Extract relations between concepts
    */
-  extractRelations(text, concepts) {
+  extractRelations(text2, concepts) {
     const relations = [];
     const relationPattern = /\[([^\]]+)\]\s*(→|↔|∴|∵|⇒|⇐)(?::(\w+))?\s*(?:→)?\s*\[([^\]]+)\]/g;
     let match;
-    while ((match = relationPattern.exec(text)) !== null) {
+    while ((match = relationPattern.exec(text2)) !== null) {
       const from = concepts.find((c) => c.name === match[1]);
       const to = concepts.find((c) => c.name === match[4]);
       if (from && to) {
@@ -2268,7 +3999,7 @@ var CRLEncoder = class {
   /**
    * Compress text using CRL patterns
    */
-  compress(text) {
+  compress(text2) {
     const replacements = [
       [/therefore/gi, "∴"],
       [/because/gi, "∵"],
@@ -2285,7 +4016,7 @@ var CRLEncoder = class {
       [/fixes/gi, "→:fixes"],
       [/relates to/gi, "∩"]
     ];
-    let result = text;
+    let result = text2;
     for (const [pattern, replacement] of replacements) {
       result = result.replace(pattern, replacement);
     }
@@ -2438,7 +4169,7 @@ var CRLDecoder = class {
   /**
    * Expand CRL symbols to natural language
    */
-  expand(text) {
+  expand(text2) {
     const expansions = {
       "∴": "therefore",
       "∵": "because",
@@ -2464,7 +4195,7 @@ var CRLDecoder = class {
       "∃": "there exists",
       "∄": "there does not exist"
     };
-    let result = text;
+    let result = text2;
     for (const [symbol, expansion] of Object.entries(expansions)) {
       result = result.replace(new RegExp(`(^|[.!?]\\s*)${symbol}`, "g"), (match, prefix) => {
         const capitalized = expansion.charAt(0).toUpperCase() + expansion.slice(1);
@@ -2518,8 +4249,8 @@ var CRL = {
   /**
    * Quick encode: natural language → CRL
    */
-  encode(text) {
-    return this.encoder.encode(text);
+  encode(text2) {
+    return this.encoder.encode(text2);
   },
   /**
    * Quick decode: CRL → natural language
@@ -2530,14 +4261,14 @@ var CRL = {
   /**
    * Quick compress: replace common patterns with symbols
    */
-  compress(text) {
-    return this.encoder.compress(text);
+  compress(text2) {
+    return this.encoder.compress(text2);
   },
   /**
    * Quick expand: replace symbols with natural language
    */
-  expand(text) {
-    return this.decoder.expand(text);
+  expand(text2) {
+    return this.decoder.expand(text2);
   },
   /**
    * Resolve templates with context
@@ -2582,11 +4313,11 @@ function slowWaveReplay(db, options = {}) {
   }
   const integratedNodes = [];
   if (options.graph) {
-    for (const id of ids) {
+    for (const id2 of ids) {
       try {
-        const referenced = db.prepare(`SELECT 1 FROM kg_edges WHERE source_episode_id = ? LIMIT 1`).get(id);
+        const referenced = db.prepare(`SELECT 1 FROM kg_edges WHERE source_episode_id = ? LIMIT 1`).get(id2);
         if (!referenced) {
-          const nodeText = `episode:${id}`;
+          const nodeText = `episode:${id2}`;
           const newNodeId = options.graph.upsertNode({ text: nodeText, nodeType: "event" });
           if (newNodeId)
             integratedNodes.push(newNodeId);
@@ -2977,8 +4708,8 @@ function runMemoryMaintenance(options) {
   return result;
 }
 function emptyResult(options, started) {
-  const missing = (path) => ({
-    path,
+  const missing = (path2) => ({
+    path: path2,
     exists: false,
     sizeBeforeBytes: 0,
     sizeAfterBytes: 0,
@@ -3029,17 +4760,17 @@ function emptyResult(options, started) {
     stoppedEarly: false
   };
 }
-function storeStats(path) {
-  const walPath = `${path}-wal`;
-  const shmPath = `${path}-shm`;
-  const archivePath = path.endsWith("knowledge.db") ? join2(dirname(path), "knowledge.archive.db") : "";
-  const sizeBeforeBytes = fileSize(path);
+function storeStats(path2) {
+  const walPath = `${path2}-wal`;
+  const shmPath = `${path2}-shm`;
+  const archivePath = path2.endsWith("knowledge.db") ? join2(dirname(path2), "knowledge.archive.db") : "";
+  const sizeBeforeBytes = fileSize(path2);
   const walBeforeBytes = fileSize(walPath);
   const shmBeforeBytes = fileSize(shmPath);
   const archiveBeforeBytes = archivePath ? fileSize(archivePath) : 0;
   return {
-    path,
-    exists: existsSync2(path),
+    path: path2,
+    exists: existsSync2(path2),
     sizeBeforeBytes,
     sizeAfterBytes: sizeBeforeBytes,
     walBeforeBytes,
@@ -3062,9 +4793,9 @@ function refreshStoreStatsAfter(stats) {
   stats.archiveAfterBytes = archivePath ? fileSize(archivePath) : 0;
   stats.physicalAfterBytes = stats.sizeAfterBytes + stats.walAfterBytes + stats.shmAfterBytes + stats.archiveAfterBytes;
 }
-function fileSize(path) {
+function fileSize(path2) {
   try {
-    return existsSync2(path) ? statSync(path).size : 0;
+    return existsSync2(path2) ? statSync(path2).size : 0;
   } catch {
     return 0;
   }
@@ -3340,8 +5071,8 @@ function deleteEpisodes(db, ids, dryRun) {
   let deleted = 0;
   const stmt = db.prepare(`DELETE FROM episodes WHERE id = ?`);
   const tx = db.transaction((rows) => {
-    for (const id of rows) {
-      const result = stmt.run(id);
+    for (const id2 of rows) {
+      const result = stmt.run(id2);
       deleted += Number(result.changes ?? 0);
     }
   });
@@ -3637,8 +5368,8 @@ function reinforceGraphNodes(dbPath, ids) {
     const stmt = db.prepare("UPDATE kg_nodes SET last_seen = ?, mention_count = COALESCE(mention_count, 1) + 1 WHERE id = ?");
     let updated = 0;
     const tx = db.transaction((rows) => {
-      for (const id of rows)
-        updated += Number(stmt.run(now, id).changes ?? 0);
+      for (const id2 of rows)
+        updated += Number(stmt.run(now, id2).changes ?? 0);
     });
     tx(ids);
     return updated;
@@ -3703,8 +5434,8 @@ function deleteById(db, table, ids) {
   let deleted = 0;
   const stmt = db.prepare(`DELETE FROM ${table} WHERE id = ?`);
   const tx = db.transaction((rows) => {
-    for (const id of rows) {
-      const result = stmt.run(id);
+    for (const id2 of rows) {
+      const result = stmt.run(id2);
       deleted += Number(result.changes ?? 0);
     }
   });
@@ -3752,9 +5483,9 @@ function graphNodeScore(row) {
   const recency = Math.exp(-age / (30 * DAY));
   return Math.log1p(Math.max(0, row.mentionCount)) * 0.7 + recency * 0.3;
 }
-function vectorFor(rawEmbedding, text) {
+function vectorFor(rawEmbedding, text2) {
   const decoded = decodeEmbedding(rawEmbedding);
-  return decoded ?? hashEmbedding(text);
+  return decoded ?? hashEmbedding(text2);
 }
 function decodeEmbedding(raw) {
   if (!raw)
@@ -3775,10 +5506,10 @@ function decodeEmbedding(raw) {
   }
   return null;
 }
-function hashEmbedding(text, dimensions = 256) {
+function hashEmbedding(text2, dimensions = 256) {
   const dim = Math.max(16, dimensions);
   const vector = new Array(dim).fill(0);
-  const tokens = text.toLowerCase().split(/[^\p{L}\p{N}_./-]+/u).map((token) => token.trim()).filter(Boolean);
+  const tokens = text2.toLowerCase().split(/[^\p{L}\p{N}_./-]+/u).map((token) => token.trim()).filter(Boolean);
   const features = [...tokens];
   for (let i = 0; i < tokens.length - 1; i++) {
     features.push(`${tokens[i]} ${tokens[i + 1]}`);
@@ -3847,8 +5578,8 @@ function vacuum(db) {
 import { join as join3 } from "node:path";
 
 // packages/cli/src/tui/commands/kg-prune-inference.ts
-function truncate(text, max) {
-  const clean = text.replace(/\s+/g, " ").trim();
+function truncate(text2, max) {
+  const clean = text2.replace(/\s+/g, " ").trim();
   return clean.length > max ? clean.slice(0, max - 1) + "…" : clean;
 }
 async function classifySignalNodes(candidates, cfg) {
@@ -3917,8 +5648,8 @@ function parseIdArray(content, valid) {
   if (!Array.isArray(parsed)) return [];
   const out = [];
   for (const item of parsed) {
-    const id = typeof item === "string" ? item : String(item ?? "");
-    if (id && valid.has(id) && !out.includes(id)) out.push(id);
+    const id2 = typeof item === "string" ? item : String(item ?? "");
+    if (id2 && valid.has(id2) && !out.includes(id2)) out.push(id2);
   }
   return out;
 }