openpond 0.0.69 → 0.1.0

package/dist/chunks/continual-FYDKLCO7.js

@@ -0,0 +1,803 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  DEFAULT_LOCAL_TRAINING_API_URL,
+  createLocalAuthenticatedRequest
+} from "./chunk-J7PYGDRY.js";
+import {
+  ContinualBenchPanelRoleSchema
+} from "./chunk-R3C3MNSI.js";
+import {
+  yaml
+} from "./chunk-X7ZG4TSW.js";
+import {
+  resolveApiBaseUrlOption
+} from "./chunk-SMNFI2FU.js";
+import "./chunk-KSRWKXRB.js";
+import {
+  external_exports
+} from "./chunk-FQS2QL5F.js";
+import {
+  optionString,
+  parseBooleanOption,
+  parseIntegerOption,
+  parseNumberOption
+} from "./chunk-MUMPWI4O.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/continual.ts
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+
+// ../../packages/continual-support/dist/adapter.js
+var CONTINUAL_SUPPORT_COMMANDS = Object.freeze({
+  init: "openpond continual init --from ./tasks.jsonl",
+  validate: "openpond continual validate ./continual-support.yaml",
+  run: "openpond continual run ./continual-support.yaml",
+  report: "openpond continual report <comparison-series-id>"
+});
+
+// ../../packages/continual-support/dist/hash.js
+import { createHash } from "node:crypto";
+function canonicalJson(value) {
+  return `${JSON.stringify(normalize(value), null, 2)}
+`;
+}
+function contentHash(value) {
+  return createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+function normalize(value) {
+  if (Array.isArray(value))
+    return value.map(normalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, normalize(child)]));
+  }
+  return value;
+}
+
+// ../../packages/continual-support/dist/leakage.js
+function auditContinualBenchLeakage(input) {
+  const threshold = input.semanticSimilarityThreshold ?? 0.8;
+  if (!(threshold > 0 && threshold <= 1))
+    throw new Error("semanticSimilarityThreshold must be in (0, 1].");
+  const allowed = new Set((input.allowSharedFamiliesBetween ?? []).flatMap(([left, right]) => [`${left}\0${right}`, `${right}\0${left}`]));
+  const findings = [];
+  for (let leftIndex = 0; leftIndex < input.panels.length; leftIndex += 1) {
+    const leftPanel = input.panels[leftIndex];
+    for (let rightIndex = leftIndex + 1; rightIndex < input.panels.length; rightIndex += 1) {
+      const rightPanel = input.panels[rightIndex];
+      for (const left of leftPanel.tasks)
+        for (const right of rightPanel.tasks) {
+          const base = { leftPanel: leftPanel.id, rightPanel: rightPanel.id, leftTaskId: left.id, rightTaskId: right.id };
+          if (left.id === right.id)
+            findings.push({ ...base, kind: "duplicate_id", similarity: 1 });
+          else if (left.contentHash === right.contentHash)
+            findings.push({ ...base, kind: "duplicate_content", similarity: 1 });
+          if (left.familyId === right.familyId && !allowed.has(`${leftPanel.id}\0${rightPanel.id}`))
+            findings.push({ ...base, kind: "family_overlap", similarity: null });
+          if (left.prompt && right.prompt) {
+            const similarity = jaccard(left.prompt, right.prompt);
+            if (similarity >= threshold)
+              findings.push({ ...base, kind: "prompt_overlap", similarity });
+          }
+        }
+    }
+  }
+  const release = {
+    schemaVersion: "openpond.continualBenchLeakageAudit.v1",
+    threshold,
+    findings: findings.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))
+  };
+  return { ...release, contentHash: contentHash(release) };
+}
+function jaccard(left, right) {
+  const tokens = (value) => new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
+  const leftTokens = tokens(left);
+  const rightTokens = tokens(right);
+  const union = /* @__PURE__ */ new Set([...leftTokens, ...rightTokens]);
+  if (!union.size)
+    return 1;
+  let intersection = 0;
+  for (const token of leftTokens)
+    if (rightTokens.has(token))
+      intersection += 1;
+  return intersection / union.size;
+}
+
+// ../../packages/continual-support/dist/manifest.js
+var Id = external_exports.string().trim().min(1).max(240);
+var Hash = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var TaskRef = external_exports.object({ id: Id, contentHash: Hash }).strict();
+var ContinualBenchPortableTaskSchema = external_exports.object({
+  id: Id,
+  familyId: Id,
+  contentHash: Hash,
+  prompt: external_exports.string().max(1e6).optional(),
+  payload: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+}).strict();
+var ContinualBenchPortablePanelSchema = external_exports.object({
+  id: Id,
+  role: ContinualBenchPanelRoleSchema,
+  passLabel: Id.nullable(),
+  taskIds: external_exports.array(Id).min(1).max(1e6),
+  disclosurePhase: external_exports.enum(["review", "evaluation", "final"]),
+  optimizerEligible: external_exports.boolean()
+}).strict().superRefine((panel, context) => {
+  const shouldOptimize = panel.role === "correction" || panel.role === "training_eligible";
+  if (panel.optimizerEligible !== shouldOptimize) {
+    context.addIssue({
+      code: "custom",
+      path: ["optimizerEligible"],
+      message: "Only correction and training-eligible panels may be optimizer eligible."
+    });
+  }
+  if (panel.role === "frozen_final" && panel.disclosurePhase !== "final") {
+    context.addIssue({
+      code: "custom",
+      path: ["disclosurePhase"],
+      message: "The frozen-final panel may only be disclosed in the final phase."
+    });
+  }
+  if (new Set(panel.taskIds).size !== panel.taskIds.length) {
+    context.addIssue({ code: "custom", path: ["taskIds"], message: "Panel task ids must be unique." });
+  }
+});
+var ContinualBenchPortablePassSchema = external_exports.object({
+  label: Id,
+  familyIds: external_exports.array(Id).min(1).max(1e5)
+}).strict();
+var ContinualBenchOpenPondExecutionSchema = external_exports.object({
+  adapter: external_exports.literal("openpond"),
+  apiBaseUrl: external_exports.string().url().optional(),
+  series: external_exports.record(external_exports.string(), external_exports.unknown())
+}).strict();
+var ContinualBenchPortableManifestSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualBenchManifest.v1"),
+  id: Id,
+  revision: external_exports.number().int().positive(),
+  name: external_exports.string().trim().min(1).max(500),
+  description: external_exports.string().trim().min(1).max(2e4),
+  license: external_exports.string().trim().min(1).max(100),
+  source: external_exports.object({
+    repository: external_exports.string().trim().min(1).max(2e3).nullable(),
+    commit: external_exports.string().trim().min(1).max(500).nullable(),
+    generatedBy: external_exports.string().trim().min(1).max(2e3)
+  }).strict(),
+  split: external_exports.object({
+    seed: Id,
+    correctionCasesPerFamily: external_exports.number().int().positive().max(100),
+    correctionSelection: external_exports.enum(["stable_hash", "minimize_prompt_similarity"]),
+    semanticSimilarityThreshold: external_exports.number().gt(0).lte(1)
+  }).strict(),
+  passes: external_exports.array(ContinualBenchPortablePassSchema).min(1).max(1e3),
+  tasks: external_exports.array(ContinualBenchPortableTaskSchema).min(1).max(1e6),
+  panels: external_exports.array(ContinualBenchPortablePanelSchema).min(1).max(1e5),
+  grader: external_exports.object({
+    id: Id,
+    contentHash: Hash,
+    outcomeScale: external_exports.object({ minimum: external_exports.number().finite(), maximum: external_exports.number().finite() }).strict()
+  }).strict(),
+  evaluation: external_exports.object({
+    seeds: external_exports.array(external_exports.number().int()).min(1).max(100),
+    repetitions: external_exports.number().int().positive().max(100),
+    confidenceLevel: external_exports.number().gt(0).lt(1),
+    pairedBootstrapSamples: external_exports.number().int().min(1e3).max(1e6)
+  }).strict(),
+  execution: ContinualBenchOpenPondExecutionSchema.optional(),
+  contentHash: Hash
+}).strict().superRefine((manifest, context) => {
+  const taskIds = manifest.tasks.map((task) => task.id);
+  if (new Set(taskIds).size !== taskIds.length) {
+    context.addIssue({ code: "custom", path: ["tasks"], message: "Manifest task ids must be unique." });
+  }
+  const knownTasks = new Set(taskIds);
+  for (const [index, panel] of manifest.panels.entries()) {
+    if (panel.taskIds.some((id) => !knownTasks.has(id))) {
+      context.addIssue({ code: "custom", path: ["panels", index, "taskIds"], message: "Every panel task must exist in the manifest inventory." });
+    }
+  }
+  const passLabels = manifest.passes.map((pass) => pass.label);
+  if (new Set(passLabels).size !== passLabels.length) {
+    context.addIssue({ code: "custom", path: ["passes"], message: "Pass labels must be unique." });
+  }
+  const families = new Set(manifest.tasks.map((task) => task.familyId));
+  const assigned = manifest.passes.flatMap((pass) => pass.familyIds);
+  if (new Set(assigned).size !== assigned.length) {
+    context.addIssue({ code: "custom", path: ["passes"], message: "An issue family may belong to only one pass." });
+  }
+  if (assigned.some((familyId) => !families.has(familyId))) {
+    context.addIssue({ code: "custom", path: ["passes"], message: "Every assigned family must exist in the task inventory." });
+  }
+});
+function sealPortableManifest(input) {
+  return ContinualBenchPortableManifestSchema.parse({ ...input, contentHash: contentHash(input) });
+}
+function verifyPortableManifest(manifest) {
+  const parsed = ContinualBenchPortableManifestSchema.parse(manifest);
+  const { contentHash: declared, ...unsealed } = parsed;
+  return declared === contentHash(unsealed);
+}
+
+// ../../packages/continual-support/dist/metrics.js
+var Id2 = external_exports.string().trim().min(1).max(240);
+var Hash2 = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var NullableMetric = external_exports.number().finite().nullable();
+var ContinualBenchAttemptMetricSchema = external_exports.object({
+  attemptId: Id2,
+  seed: external_exports.number().int(),
+  repetition: external_exports.number().int().nonnegative(),
+  score: NullableMetric,
+  passed: external_exports.boolean().nullable(),
+  latencyMs: external_exports.number().nonnegative().nullable(),
+  costUsd: external_exports.number().nonnegative().nullable(),
+  transcript: external_exports.object({ path: external_exports.string().min(1), contentHash: Hash2 }).strict().nullable(),
+  trace: external_exports.object({ path: external_exports.string().min(1), contentHash: Hash2 }).strict().nullable(),
+  graderOutputHash: Hash2.nullable(),
+  status: external_exports.enum(["completed", "failed", "cancelled"])
+}).strict();
+var ContinualBenchTaskMetricSchema = external_exports.object({
+  targetId: Id2,
+  panelId: Id2,
+  panelRole: ContinualBenchPanelRoleSchema,
+  taskId: Id2,
+  familyId: Id2,
+  attempts: external_exports.array(ContinualBenchAttemptMetricSchema).min(1).max(1e4),
+  meanScore: NullableMetric,
+  passRate: NullableMetric,
+  confidenceInterval: external_exports.tuple([external_exports.number().finite(), external_exports.number().finite()]).nullable()
+}).strict();
+var ContinualBenchEfficiencyMetricSchema = external_exports.object({
+  targetId: Id2,
+  trainingGpuSeconds: external_exports.number().nonnegative().nullable(),
+  evaluationGpuSeconds: external_exports.number().nonnegative().nullable(),
+  providerSpendUsd: external_exports.number().nonnegative().nullable(),
+  totalSpendUsd: external_exports.number().nonnegative().nullable(),
+  durationSeconds: external_exports.number().nonnegative().nullable(),
+  optimizerGroups: external_exports.number().int().nonnegative().nullable(),
+  trajectories: external_exports.number().int().nonnegative().nullable()
+}).strict();
+var ContinualBenchOutcomeSchema = external_exports.enum([
+  "systems_complete",
+  "correction_absorbed",
+  "issue_generalized",
+  "continually_current",
+  "frontier_pareto_result",
+  "inconclusive",
+  "loss"
+]);
+
+// ../../packages/continual-support/dist/releases.js
+function createContinualBenchPanelAllocations(split) {
+  const panels = [];
+  const orderedFamilies = [...split.families].sort((left, right) => left.passLabel.localeCompare(right.passLabel));
+  for (const family of orderedFamilies) {
+    panels.push(sealPanel({ id: `${family.passLabel.toLowerCase()}-correction`, role: "correction", passLabel: family.passLabel, taskIds: family.correctionTaskIds, familyIds: [family.familyId], optimizerEligible: true }));
+    panels.push(sealPanel({ id: `${family.passLabel.toLowerCase()}-siblings`, role: "sibling_verification", passLabel: family.passLabel, taskIds: family.siblingTaskIds, familyIds: [family.familyId], optimizerEligible: false }));
+  }
+  for (let index = 0; index < orderedFamilies.length; index += 1) {
+    const through = orderedFamilies.slice(0, index + 1);
+    panels.push(sealPanel({
+      id: `known-${through[index].passLabel.toLowerCase()}`,
+      role: "cumulative_known",
+      passLabel: through[index].passLabel,
+      taskIds: through.flatMap((family) => [...family.correctionTaskIds, ...family.siblingTaskIds]),
+      familyIds: through.map((family) => family.familyId),
+      optimizerEligible: false
+    }));
+  }
+  panels.push(sealPanel({
+    id: "training-eligible",
+    role: "training_eligible",
+    passLabel: null,
+    taskIds: orderedFamilies.flatMap((family) => family.correctionTaskIds),
+    familyIds: orderedFamilies.map((family) => family.familyId),
+    optimizerEligible: true
+  }));
+  return panels;
+}
+function assertOptimizerIsolation(manifest) {
+  const hiddenRoles = /* @__PURE__ */ new Set(["sibling_verification", "development", "retained", "frozen_final"]);
+  const forbidden = new Set(manifest.panels.filter((panel) => hiddenRoles.has(panel.role)).flatMap((panel) => panel.taskIds));
+  const optimizer = manifest.panels.filter((panel) => panel.optimizerEligible).flatMap((panel) => panel.taskIds);
+  const overlaps = optimizer.filter((id) => forbidden.has(id));
+  if (overlaps.length)
+    throw new Error(`Hidden evaluation tasks are optimizer eligible: ${[...new Set(overlaps)].sort().join(", ")}`);
+}
+function sealPanel(input) {
+  const normalized = { ...input, taskIds: [...input.taskIds].sort(), familyIds: [...input.familyIds].sort() };
+  return { ...normalized, contentHash: contentHash(normalized) };
+}
+
+// ../../packages/continual-support/dist/validation.js
+function validateContinualBenchManifest(value) {
+  const parsed = ContinualBenchPortableManifestSchema.safeParse(value);
+  if (!parsed.success) {
+    return {
+      valid: false,
+      manifestHash: null,
+      leakageHash: null,
+      issues: parsed.error.issues.map((issue) => ({
+        severity: "error",
+        code: "schema",
+        message: issue.message,
+        path: issue.path.join(".")
+      }))
+    };
+  }
+  const manifest = parsed.data;
+  const issues = [];
+  if (!verifyPortableManifest(manifest))
+    issues.push({ severity: "error", code: "content_hash", message: "Manifest contentHash does not match its canonical payload.", path: "contentHash" });
+  const taskById = new Map(manifest.tasks.map((task) => [task.id, task]));
+  const correctionSiblingPairs = [];
+  for (const pass of manifest.passes) {
+    const correction = manifest.panels.find((panel) => panel.role === "correction" && panel.passLabel === pass.label);
+    const sibling = manifest.panels.find((panel) => panel.role === "sibling_verification" && panel.passLabel === pass.label);
+    if (!correction || !sibling) {
+      issues.push({ severity: "error", code: "missing_holdout", message: `Pass ${pass.label} requires both correction and sibling-verification panels.`, path: "panels" });
+      continue;
+    }
+    correctionSiblingPairs.push([correction.id, sibling.id]);
+    const correctionFamilies = new Set(correction.taskIds.map((id) => taskById.get(id)?.familyId));
+    const siblingFamilies = new Set(sibling.taskIds.map((id) => taskById.get(id)?.familyId));
+    for (const familyId of pass.familyIds) {
+      if (!correctionFamilies.has(familyId) || !siblingFamilies.has(familyId)) {
+        issues.push({ severity: "error", code: "insufficient_family", message: `Pass ${pass.label} family ${familyId} lacks a correction or sibling case; the holdout was not weakened.`, path: "passes" });
+      }
+    }
+  }
+  const leakage = auditContinualBenchLeakage({
+    panels: manifest.panels.filter((panel) => panel.role !== "cumulative_known" && panel.role !== "training_eligible").map((panel) => ({
+      id: panel.id,
+      tasks: panel.taskIds.map((id) => {
+        const task = taskById.get(id);
+        return { id: task.id, familyId: task.familyId, contentHash: task.contentHash, prompt: task.prompt };
+      })
+    })),
+    allowSharedFamiliesBetween: correctionSiblingPairs,
+    semanticSimilarityThreshold: manifest.split.semanticSimilarityThreshold
+  });
+  for (const finding of leakage.findings) {
+    issues.push({
+      severity: "error",
+      code: `leakage_${finding.kind}`,
+      message: `${finding.leftTaskId} in ${finding.leftPanel} overlaps ${finding.rightTaskId} in ${finding.rightPanel}.`,
+      path: "panels"
+    });
+  }
+  return { valid: !issues.some((issue) => issue.severity === "error"), manifestHash: manifest.contentHash, issues, leakageHash: leakage.contentHash };
+}
+function requireValidContinualBenchManifest(value) {
+  const report = validateContinualBenchManifest(value);
+  if (!report.valid)
+    throw new Error(report.issues.map((issue) => `${issue.code}: ${issue.message}`).join("\n"));
+  return ContinualBenchPortableManifestSchema.parse(value);
+}
+
+// ../../packages/continual-support/dist/report.js
+var Id3 = external_exports.string().trim().min(1).max(240);
+var Hash3 = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var ContinualBenchReportPointSchema = external_exports.object({
+  id: Id3,
+  label: external_exports.string().trim().min(1).max(500),
+  kind: external_exports.enum(["candidate", "accepted_head", "base", "master", "external_reference"]),
+  ordinal: external_exports.number().int().nonnegative().nullable(),
+  meanScore: external_exports.number().finite().nullable(),
+  confidenceInterval: external_exports.tuple([external_exports.number().finite(), external_exports.number().finite()]).nullable(),
+  taskMetrics: external_exports.array(ContinualBenchTaskMetricSchema).max(1e6),
+  efficiency: ContinualBenchEfficiencyMetricSchema.nullable(),
+  evidenceUrl: external_exports.string().url().nullable()
+}).strict();
+var ContinualBenchPortableReportSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualBenchReport.v1"),
+  seriesId: Id3,
+  protocol: external_exports.object({ id: Id3, revision: external_exports.number().int().positive(), contentHash: Hash3 }).strict(),
+  generatedAt: external_exports.string().datetime({ offset: true }),
+  status: external_exports.enum(["partial", "terminal"]),
+  points: external_exports.array(ContinualBenchReportPointSchema).min(1).max(1e4),
+  outcomes: external_exports.array(ContinualBenchOutcomeSchema).max(7),
+  audit: external_exports.array(external_exports.object({ requirement: Id3, status: external_exports.enum(["passed", "failed", "unavailable"]), evidenceRefs: external_exports.array(Id3).max(1e5) }).strict()).max(1e4),
+  chart: external_exports.object({
+    x: external_exports.literal("ordinal"),
+    y: external_exports.literal("meanScore"),
+    series: external_exports.array(external_exports.object({ pointId: Id3, label: external_exports.string(), ordinal: external_exports.number().nullable(), value: external_exports.number().nullable(), lower: external_exports.number().nullable(), upper: external_exports.number().nullable(), kind: external_exports.string() }).strict())
+  }).strict(),
+  contentHash: Hash3
+}).strict();
+function createContinualBenchReport(input) {
+  const chart = {
+    x: "ordinal",
+    y: "meanScore",
+    series: input.points.map((point) => ({
+      pointId: point.id,
+      label: point.label,
+      ordinal: point.ordinal,
+      value: point.meanScore,
+      lower: point.confidenceInterval?.[0] ?? null,
+      upper: point.confidenceInterval?.[1] ?? null,
+      kind: point.kind
+    }))
+  };
+  const unsealed = { ...input, chart };
+  return ContinualBenchPortableReportSchema.parse({ ...unsealed, contentHash: contentHash(unsealed) });
+}
+function exportContinualBenchReport(report) {
+  const parsed = ContinualBenchPortableReportSchema.parse(report);
+  const { contentHash: declared, ...unsealed } = parsed;
+  if (declared !== contentHash(unsealed))
+    throw new Error("Continual Support report content hash does not match its payload.");
+  return canonicalJson(parsed);
+}
+
+// ../../packages/continual-support/dist/split.js
+function createContinualBenchSplit(input) {
+  const correctionCount = input.correctionCasesPerFamily ?? 1;
+  if (!Number.isInteger(correctionCount) || correctionCount < 1)
+    throw new Error("correctionCasesPerFamily must be a positive integer.");
+  const byId = /* @__PURE__ */ new Map();
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const task of input.tasks) {
+    if (byId.has(task.id))
+      throw new Error(`Duplicate task id: ${task.id}`);
+    byId.set(task.id, task);
+    const family = byFamily.get(task.familyId) ?? [];
+    family.push(task);
+    byFamily.set(task.familyId, family);
+  }
+  const passByFamily = /* @__PURE__ */ new Map();
+  for (const pass of input.passes) {
+    if (!pass.label.trim())
+      throw new Error("Pass labels cannot be empty.");
+    for (const familyId of pass.familyIds) {
+      if (passByFamily.has(familyId))
+        throw new Error(`Family ${familyId} is assigned to more than one pass.`);
+      passByFamily.set(familyId, pass.label);
+    }
+  }
+  const allocations = [];
+  const families = [];
+  const advisories = [];
+  for (const [familyId, tasks] of [...byFamily].sort(([left], [right]) => left.localeCompare(right))) {
+    const passLabel = passByFamily.get(familyId);
+    if (!passLabel) {
+      advisories.push({ code: "unassigned_family", familyId, taskCount: tasks.length });
+      continue;
+    }
+    let ordered = [...tasks].sort((left, right) => {
+      const leftKey = contentHash([input.seed, familyId, left.id, left.contentHash]);
+      const rightKey = contentHash([input.seed, familyId, right.id, right.contentHash]);
+      return leftKey.localeCompare(rightKey) || left.id.localeCompare(right.id);
+    });
+    if (ordered.length <= correctionCount) {
+      advisories.push({ code: "insufficient_siblings", familyId, taskCount: ordered.length });
+      continue;
+    }
+    if (input.correctionSelection === "minimize_prompt_similarity" && correctionCount === 1 && ordered.every((task) => task.prompt)) {
+      ordered = [...ordered].sort((left, right) => {
+        const leftMaximum = maximumSiblingSimilarity(left, ordered);
+        const rightMaximum = maximumSiblingSimilarity(right, ordered);
+        return leftMaximum - rightMaximum || left.id.localeCompare(right.id);
+      });
+    }
+    const correction = ordered.slice(0, correctionCount);
+    const siblings = ordered.slice(correctionCount);
+    allocations.push(...correction.map((task) => ({ ...task, passLabel, panelRole: "correction", optimizerEligible: true })), ...siblings.map((task) => ({ ...task, passLabel, panelRole: "sibling_verification", optimizerEligible: false })));
+    families.push({ familyId, passLabel, correctionTaskIds: correction.map((task) => task.id), siblingTaskIds: siblings.map((task) => task.id) });
+  }
+  for (const familyId of passByFamily.keys()) {
+    if (!byFamily.has(familyId))
+      throw new Error(`Assigned family ${familyId} has no source tasks.`);
+  }
+  const release = {
+    schemaVersion: "openpond.continualBenchSplit.v1",
+    seed: input.seed,
+    allocations: allocations.sort((left, right) => left.passLabel.localeCompare(right.passLabel) || left.familyId.localeCompare(right.familyId) || left.id.localeCompare(right.id)),
+    families: families.sort((left, right) => left.passLabel.localeCompare(right.passLabel) || left.familyId.localeCompare(right.familyId)),
+    advisories: advisories.sort((left, right) => left.familyId.localeCompare(right.familyId) || left.code.localeCompare(right.code))
+  };
+  return { ...release, contentHash: contentHash(release) };
+}
+function maximumSiblingSimilarity(task, family) {
+  return Math.max(...family.filter((candidate) => candidate.id !== task.id).map((candidate) => jaccard2(task.prompt, candidate.prompt)));
+}
+function jaccard2(left, right) {
+  const tokenize = (value) => new Set(value.toLowerCase().match(/[a-z0-9]+/g) ?? []);
+  const leftTokens = tokenize(left);
+  const rightTokens = tokenize(right);
+  const union = /* @__PURE__ */ new Set([...leftTokens, ...rightTokens]);
+  if (!union.size)
+    return 1;
+  let intersection = 0;
+  for (const token of leftTokens)
+    if (rightTokens.has(token))
+      intersection += 1;
+  return intersection / union.size;
+}
+
+// src/cli/continual.ts
+async function runContinualCommand(options, rest, dependencies = {}) {
+  const subcommand = rest[0];
+  if (!subcommand || !["init", "validate", "run", "report"].includes(subcommand)) {
+    throw new Error("usage: openpond continual <init|validate|run|report> [manifest-or-series-id]");
+  }
+  const log = dependencies.log ?? console.log;
+  if (subcommand === "init") {
+    await initializeManifest(options, rest.slice(1), dependencies, log);
+    return;
+  }
+  if (subcommand === "report") {
+    await exportReport(options, rest.slice(1), dependencies, log);
+    return;
+  }
+  const manifestPath = rest[1];
+  if (!manifestPath || rest.length !== 2) throw new Error(`usage: openpond continual ${subcommand} <manifest-path>`);
+  const manifestValue = await loadStructuredFile(path.resolve(manifestPath), dependencies.readFile ?? readFile);
+  const validation = validateContinualBenchManifest(manifestValue);
+  if (subcommand === "validate") {
+    if (parseBooleanOption(options.json)) log(JSON.stringify(validation, null, 2));
+    else {
+      log(validation.valid ? `Valid Continual Support manifest ${validation.manifestHash}.` : "Continual Support manifest is invalid.");
+      log(`Leakage audit ${validation.leakageHash ?? "unavailable"}; ${validation.issues.length} finding(s).`);
+      for (const issue of validation.issues) log(`${issue.severity}: ${issue.code} at ${issue.path}: ${issue.message}`);
+    }
+    if (!validation.valid) throw withExitCode("Continual Support validation failed.", 2);
+    return;
+  }
+  const manifest = requireValidContinualBenchManifest(manifestValue);
+  assertOptimizerIsolation(manifest);
+  await submitManifest(manifest, options, dependencies, log);
+}
+async function initializeManifest(options, rest, dependencies, log) {
+  if (rest.length) throw new Error("continual init accepts --from and --output options, not positional arguments.");
+  const sourcePath = optionString(options, "from");
+  if (!sourcePath) throw new Error("continual init requires --from <tasks.json|tasks.jsonl>.");
+  const outputPath = path.resolve(optionString(options, "output") || "continual-support.yaml");
+  const rows = await readSourceRows(path.resolve(sourcePath), dependencies.readFile ?? readFile);
+  const nonInteractive = parseBooleanOption(options.nonInteractive) || !process.stdin.isTTY;
+  const prompt = dependencies.prompt ?? defaultPrompt;
+  const normalized = await completeLabels(rows, nonInteractive, prompt);
+  const splitRows = normalized.filter((row) => row.panelRole === null || row.panelRole === "correction" || row.panelRole === "sibling_verification");
+  const passes = [...new Map(splitRows.map((row) => [row.passLabel, row])).keys()].sort().map((label) => ({
+    label,
+    familyIds: [...new Set(splitRows.filter((row) => row.passLabel === label).map((row) => row.familyId))].sort()
+  }));
+  const tasks = normalized.map((row) => ({
+    id: row.id,
+    familyId: row.familyId,
+    contentHash: contentHash(row.payload),
+    ...row.prompt ? { prompt: row.prompt } : {},
+    payload: row.payload
+  }));
+  const split = createContinualBenchSplit({
+    tasks: splitRows.map((row) => ({ id: row.id, familyId: row.familyId, contentHash: contentHash(row.payload), prompt: row.prompt })),
+    passes,
+    seed: optionString(options, "seed") || "continual-support-v1",
+    correctionCasesPerFamily: parseIntegerOption(options.correctionCasesPerFamily, "correction-cases-per-family") ?? 1,
+    correctionSelection: optionString(options, "correctionSelection") === "stable_hash" ? "stable_hash" : "minimize_prompt_similarity"
+  });
+  if (split.advisories.length) {
+    throw new Error(`The proposed split is incomplete and was not weakened: ${split.advisories.map((item) => `${item.code}:${item.familyId}`).join(", ")}`);
+  }
+  const generatedPanels = createContinualBenchPanelAllocations(split).map((panel) => ({
+    id: panel.id,
+    role: panel.role,
+    passLabel: panel.passLabel,
+    taskIds: panel.taskIds,
+    disclosurePhase: panel.role === "sibling_verification" ? "evaluation" : "review",
+    optimizerEligible: panel.optimizerEligible
+  }));
+  const stableRoles = ["development", "retained", "frozen_final"];
+  for (const role of stableRoles) {
+    const taskIds = normalized.filter((row) => row.panelRole === role).map((row) => row.id).sort();
+    if (taskIds.length) generatedPanels.push({
+      id: role.replace("_", "-"),
+      role,
+      passLabel: null,
+      taskIds,
+      disclosurePhase: role === "frozen_final" ? "final" : "evaluation",
+      optimizerEligible: false
+    });
+  }
+  const id = optionString(options, "id") || slug(optionString(options, "name") || path.basename(sourcePath, path.extname(sourcePath)));
+  const graderId = optionString(options, "grader") || "user-supplied-grader-v1";
+  const unsealed = {
+    schemaVersion: "openpond.continualBenchManifest.v1",
+    id,
+    revision: 1,
+    name: optionString(options, "name") || id,
+    description: optionString(options, "description") || "A sealed continual-support workflow converted from an ordinary task set.",
+    license: optionString(options, "license") || "UNSPECIFIED",
+    source: { repository: optionString(options, "repository") || null, commit: optionString(options, "commit") || null, generatedBy: `openpond continual init --from ${sourcePath}` },
+    split: {
+      seed: split.seed,
+      correctionCasesPerFamily: parseIntegerOption(options.correctionCasesPerFamily, "correction-cases-per-family") ?? 1,
+      correctionSelection: optionString(options, "correctionSelection") === "stable_hash" ? "stable_hash" : "minimize_prompt_similarity",
+      semanticSimilarityThreshold: parseNumberOption(options.semanticSimilarityThreshold, "semantic-similarity-threshold") ?? 0.8
+    },
+    passes,
+    tasks,
+    panels: generatedPanels,
+    grader: { id: graderId, contentHash: contentHash({ id: graderId }), outcomeScale: { minimum: 0, maximum: 1 } },
+    evaluation: { seeds: [1701, 1709, 1721], repetitions: 3, confidenceLevel: 0.95, pairedBootstrapSamples: 1e4 }
+  };
+  const manifest = sealPortableManifest(unsealed);
+  const serialized = outputPath.endsWith(".json") ? `${JSON.stringify(manifest, null, 2)}
+` : yaml.dump(manifest, { noRefs: true, lineWidth: 120, sortKeys: false });
+  await (dependencies.writeFile ?? writeFile)(outputPath, serialized, "utf8");
+  log(`Created ${outputPath}.`);
+  log(`Manifest ${manifest.contentHash}; split ${split.contentHash}.`);
+}
+async function submitManifest(manifest, options, dependencies, log) {
+  if (!manifest.execution) throw new Error("This manifest validates locally but needs an execution.openpond series binding before `continual run`.");
+  const series = { ...manifest.execution.series };
+  const benchmarkProtocol = series.benchmarkProtocol;
+  const issueFamilyLedger = object(benchmarkProtocol?.issueFamilyLedger);
+  if (!benchmarkProtocol || issueFamilyLedger.contentHash !== manifest.contentHash) {
+    throw new Error("execution.series.benchmarkProtocol.issueFamilyLedger must bind the exact sealed portable manifest hash.");
+  }
+  const baseUrl = resolveApiBaseUrlOption(options) ?? manifest.execution.apiBaseUrl ?? process.env.OPENPOND_LOCAL_API_URL?.replace(/\/$/, "") ?? DEFAULT_LOCAL_TRAINING_API_URL;
+  const request = dependencies.request ?? await createLocalAuthenticatedRequest(baseUrl);
+  const saved = object(await requestJson(request, `${baseUrl}/v1/training/comparison-series`, "POST", { series }));
+  const seriesId = string(saved.id) || string(series.id);
+  const revision = number(saved.revision);
+  if (!seriesId || !revision) throw new Error("OpenPond did not return a Comparison Series identity and revision.");
+  await requestJson(request, `${baseUrl}/v1/training/comparison-series/${encodeURIComponent(seriesId)}/seal`, "POST", { expectedRevision: revision });
+  const canonicalUrl = `/models/comparisons/${encodeURIComponent(seriesId)}`;
+  const result = { comparisonSeriesId: seriesId, canonicalUrl, protocolHash: manifest.contentHash };
+  log(parseBooleanOption(options.json) ? JSON.stringify(result, null, 2) : `Created and sealed Comparison Series ${seriesId}.
+${canonicalUrl}
+No release was queued or started.`);
+}
+async function exportReport(options, rest, dependencies, log) {
+  const seriesId = rest[0];
+  if (!seriesId || rest.length !== 1) throw new Error("usage: openpond continual report <comparison-series-id> [--output <path>]");
+  const baseUrl = resolveApiBaseUrlOption(options) ?? process.env.OPENPOND_LOCAL_API_URL?.replace(/\/$/, "") ?? DEFAULT_LOCAL_TRAINING_API_URL;
+  const request = dependencies.request ?? await createLocalAuthenticatedRequest(baseUrl);
+  const state = object(await requestJson(request, `${baseUrl}/v1/training`, "GET"));
+  const series = array(state.comparisonSeries).map(object).find((item) => item.id === seriesId);
+  if (!series) throw new Error(`Comparison Series ${seriesId} was not found.`);
+  const protocol = object(series.benchmarkProtocol);
+  const entries = array(state.comparisonSeriesEntries).map(object).filter((item) => item.seriesId === seriesId);
+  const snapshots = array(state.modelCurrencySnapshots).map(object).filter((item) => item.seriesId === seriesId);
+  const snapshotByEntry = new Map(snapshots.map((item) => [string(item.entryId), item]));
+  const points = entries.filter((entry) => string(entry.modelVersionId)).map((entry) => {
+    const snapshot = snapshotByEntry.get(string(entry.id));
+    const panels = array(snapshot?.panels).map(object);
+    const available = panels.map((panel) => numberOrNull(panel.strictSuccess)).filter((value) => value !== null);
+    const strict = available.length ? available.reduce((sum, value) => sum + value, 0) / available.length : null;
+    const efficiency = objectOrNull(snapshot?.efficiency);
+    return {
+      id: string(entry.id),
+      label: string(entry.label),
+      kind: "candidate",
+      ordinal: numberOrNull(entry.ordinal),
+      meanScore: strict,
+      confidenceInterval: null,
+      taskMetrics: [],
+      efficiency: efficiency ? {
+        targetId: string(entry.modelVersionId),
+        trainingGpuSeconds: numberOrNull(efficiency.gpuSeconds),
+        evaluationGpuSeconds: null,
+        providerSpendUsd: null,
+        totalSpendUsd: numberOrNull(efficiency.costUsd),
+        durationSeconds: numberOrNull(efficiency.latencyMs) === null ? null : numberOrNull(efficiency.latencyMs) / 1e3,
+        optimizerGroups: null,
+        trajectories: null
+      } : null,
+      evidenceUrl: `${baseUrl}/models/comparisons/${encodeURIComponent(seriesId)}`
+    };
+  });
+  if (!points.length) throw new Error(`Comparison Series ${seriesId} has no receipt-derived candidate points to report.`);
+  const terminal = entries.every((entry) => ["candidate", "accepted", "rejected", "no_signal", "failed", "cancelled"].includes(string(entry.status) || ""));
+  const report = createContinualBenchReport({
+    schemaVersion: "openpond.continualBenchReport.v1",
+    seriesId,
+    protocol: { id: string(protocol.id), revision: number(protocol.revision), contentHash: string(protocol.contentHash) },
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: terminal ? "terminal" : "partial",
+    points,
+    outcomes: [],
+    audit: [{ requirement: "receipt-derived-points", status: "passed", evidenceRefs: points.map((point) => point.id) }]
+  });
+  const serialized = exportContinualBenchReport(report);
+  const output = optionString(options, "output");
+  if (output) {
+    await (dependencies.writeFile ?? writeFile)(path.resolve(output), serialized, "utf8");
+    log(`Wrote ${path.resolve(output)} (${report.contentHash}).`);
+  } else log(serialized.trimEnd());
+}
+async function loadStructuredFile(filePath, reader) {
+  const source = await reader(filePath, "utf8");
+  return filePath.endsWith(".json") ? JSON.parse(source) : yaml.load(source);
+}
+async function readSourceRows(filePath, reader) {
+  const source = await reader(filePath, "utf8");
+  const values = filePath.endsWith(".jsonl") ? source.split(/\r?\n/).filter((line) => line.trim()).map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      throw new Error(`Invalid JSONL at line ${index + 1}.`);
+    }
+  }) : JSON.parse(source);
+  if (!Array.isArray(values) || !values.length) throw new Error("The source must contain a non-empty JSON array or JSONL sequence.");
+  return values.map((value, index) => normalizeSourceRow(value, index));
+}
+function normalizeSourceRow(value, index) {
+  const row = object(value);
+  const id = string(row.id) || string(row.taskId) || string(row.task_id);
+  if (!id) throw new Error(`Source row ${index + 1} is missing id/taskId.`);
+  const familyId = string(row.familyId) || string(row.family_id) || string(row.clusterKey);
+  const passLabel = string(row.passLabel) || string(row.pass_label);
+  const rawRole = string(row.panelRole) || string(row.panel_role);
+  const roles = /* @__PURE__ */ new Set(["correction", "sibling_verification", "cumulative_known", "development", "retained", "frozen_final", "training_eligible"]);
+  if (rawRole && !roles.has(rawRole)) throw new Error(`Source row ${id} has unsupported panel role ${rawRole}.`);
+  return { id, familyId, passLabel, panelRole: rawRole, prompt: string(row.prompt) || string(objectOrNull(row.input)?.prompt) || void 0, payload: row };
+}
+async function completeLabels(rows, nonInteractive, prompt) {
+  const output = [];
+  const familyPass = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let familyId = row.familyId;
+    if (!familyId) {
+      if (nonInteractive) throw new Error(`Task ${row.id} lacks familyId; non-interactive init never fabricates issue families.`);
+      familyId = (await prompt(`Issue family for ${row.id}: `)).trim();
+      if (!familyId) throw new Error(`Task ${row.id} requires an issue family.`);
+    }
+    let passLabel = row.passLabel;
+    if (!row.panelRole || row.panelRole === "correction" || row.panelRole === "sibling_verification") {
+      passLabel = passLabel || familyPass.get(familyId) || null;
+      if (!passLabel) {
+        if (nonInteractive) throw new Error(`Task family ${familyId} lacks passLabel; provide labels for CI.`);
+        passLabel = (await prompt(`Pass label for family ${familyId}: `)).trim();
+      }
+      if (!passLabel) throw new Error(`Family ${familyId} requires a pass label.`);
+      const existing = familyPass.get(familyId);
+      if (existing && existing !== passLabel) throw new Error(`Family ${familyId} appears in both ${existing} and ${passLabel}.`);
+      familyPass.set(familyId, passLabel);
+    }
+    output.push({ ...row, familyId, passLabel });
+  }
+  return output;
+}
+async function defaultPrompt(question) {
+  const input = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await input.question(question);
+  } finally {
+    input.close();
+  }
+}
+async function requestJson(request, url, method, body) {
+  const response = await request(url, { method, headers: body === void 0 ? { Accept: "application/json" } : { Accept: "application/json", "Content-Type": "application/json" }, body: body === void 0 ? void 0 : JSON.stringify(body) });
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : null;
+  if (!response.ok) throw new Error(`OpenPond request failed (${response.status}): ${string(objectOrNull(payload)?.error) || response.statusText}`);
+  return payload;
+}
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function objectOrNull(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+function string(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function number(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function numberOrNull(value) {
+  return number(value);
+}
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "continual-support";
+}
+function withExitCode(message, exitCode) {
+  return Object.assign(new Error(message), { exitCode });
+}
+export {
+  runContinualCommand
+};