openpond 0.0.69 → 0.1.0

package/dist/chunks/chunk-R3C3MNSI.js

@@ -0,0 +1,140 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  external_exports
+} from "./chunk-FQS2QL5F.js";
+
+// ../../packages/continual-support/dist/schema.js
+var Id = external_exports.string().trim().min(1).max(240);
+var Hash = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var Timestamp = external_exports.string().datetime({ offset: true });
+var ImmutableRef = external_exports.object({ id: Id, contentHash: Hash }).strict();
+var VersionedRef = ImmutableRef.extend({ revision: external_exports.number().int().positive() }).strict();
+var ChatModelRef = external_exports.object({ providerId: Id, modelId: external_exports.string().trim().min(1).max(300) }).strict();
+var ContinualBenchPanelRoleSchema = external_exports.enum(["correction", "sibling_verification", "cumulative_known", "development", "retained", "frozen_final", "training_eligible"]);
+var ContinualBenchIssueCaseSchema = external_exports.object({
+  taskId: Id,
+  taskContentHash: Hash,
+  panelRole: ContinualBenchPanelRoleSchema,
+  passLabel: Id.nullable(),
+  optimizerEligible: external_exports.boolean(),
+  criticalInvariantIds: external_exports.array(Id).max(100).default([])
+}).strict().superRefine((entry, context) => {
+  if (entry.optimizerEligible !== (entry.panelRole === "correction"))
+    context.addIssue({ code: "custom", path: ["optimizerEligible"], message: "Only correction cases may be optimizer eligible." });
+});
+var ContinualBenchIssuePacketSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualBenchIssuePacket.v1"),
+  id: Id,
+  revision: external_exports.number().int().positive(),
+  contentHash: Hash,
+  familyId: Id,
+  familyLabel: external_exports.string().trim().min(1).max(500),
+  severity: external_exports.enum(["low", "medium", "high", "critical"]),
+  cases: external_exports.array(ContinualBenchIssueCaseSchema).min(2).max(1e4),
+  duplicateEvidence: ImmutableRef,
+  leakageEvidence: ImmutableRef,
+  priorExposureEvidence: ImmutableRef,
+  observedAt: Timestamp,
+  reviewedAt: Timestamp,
+  queuedAt: Timestamp.nullable(),
+  runAt: Timestamp.nullable(),
+  createdBy: Id,
+  createdAt: Timestamp
+}).strict().superRefine((packet, context) => {
+  if (!packet.cases.some((entry) => entry.panelRole === "correction"))
+    context.addIssue({ code: "custom", path: ["cases"], message: "An issue packet requires a correction case." });
+  if (!packet.cases.some((entry) => entry.panelRole === "sibling_verification"))
+    context.addIssue({ code: "custom", path: ["cases"], message: "An issue packet requires a sibling-verification case." });
+  if (new Set(packet.cases.map((entry) => entry.taskId)).size !== packet.cases.length)
+    context.addIssue({ code: "custom", path: ["cases"], message: "Issue-packet task ids must be unique." });
+});
+var ContinualBenchPanelReleaseSchema = external_exports.object({
+  id: Id,
+  role: ContinualBenchPanelRoleSchema,
+  passLabel: Id.nullable(),
+  taskset: VersionedRef,
+  familyIds: external_exports.array(Id).min(1).max(1e5),
+  taskCount: external_exports.number().int().positive().max(1e6),
+  sealedAt: Timestamp
+}).strict().superRefine((panel, context) => {
+  const requiresPass = panel.role === "correction" || panel.role === "sibling_verification" || panel.role === "cumulative_known";
+  if (requiresPass !== (panel.passLabel !== null))
+    context.addIssue({ code: "custom", path: ["passLabel"], message: requiresPass ? "This panel role requires a pass label." : "This panel role is series-wide and cannot carry a pass label." });
+});
+var ContinualBenchPolicyIdentitySchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({ kind: external_exports.literal("base_model"), id: Id, revision: external_exports.string().trim().min(1).max(500), contentHash: Hash }).strict(),
+  external_exports.object({ kind: external_exports.literal("model_version"), id: Id, contentHash: Hash }).strict(),
+  external_exports.object({ kind: external_exports.literal("external_reference"), id: Id, model: ChatModelRef, providerRevision: external_exports.string().trim().min(1).max(500), contentHash: Hash }).strict()
+]);
+var ContinualBenchScheduleEntrySchema = external_exports.object({
+  scheduleEntryId: Id,
+  ordinal: external_exports.number().int().nonnegative(),
+  label: Id,
+  role: external_exports.enum(["seed", "daily_residual", "rank_candidate", "weekly_rollup", "full_refresh"]),
+  parentRule: external_exports.enum(["base_model", "previous_release", "seed_release", "accepted_daily_head", "accepted_seed"]),
+  trainableRank: external_exports.number().int().positive().max(1024),
+  correctionPanelIds: external_exports.array(Id).min(1).max(1e3),
+  optimizerGroupsPerTask: external_exports.number().int().positive().max(1e3),
+  trajectoriesPerGroup: external_exports.number().int().min(4).max(1e3)
+}).strict();
+var ContinualBenchCurrencyThresholdsSchema = external_exports.object({
+  revision: external_exports.number().int().positive(),
+  requireAllAttemptsTerminal: external_exports.literal(true),
+  criticalCorrectionPassRate: external_exports.number().min(0).max(1),
+  siblingPassRate: external_exports.number().min(0).max(1),
+  behavioralRetentionRate: external_exports.number().min(0).max(1),
+  maximumRetainedRegressionPoints: external_exports.number().min(0).max(100),
+  blockCriticalPriorRegression: external_exports.boolean(),
+  authorizedClaims: external_exports.array(external_exports.enum(["systems_complete", "correction_absorbed", "issue_generalized", "continually_current", "frontier_pareto_result"])).min(1).max(5)
+}).strict();
+var ContinualBenchmarkProtocolReleaseSchema = external_exports.object({
+  schemaVersion: external_exports.literal("openpond.continualBenchmarkProtocol.v1"),
+  id: Id,
+  revision: external_exports.number().int().positive(),
+  contentHash: Hash,
+  ownerId: Id,
+  createdAt: Timestamp,
+  sealedAt: Timestamp,
+  creationReceipt: ImmutableRef,
+  predecessorSeries: external_exports.object({ id: Id, revision: external_exports.number().int().positive(), contentHash: Hash }).strict().nullable(),
+  scenarioPack: ImmutableRef,
+  issueFamilyLedger: ImmutableRef,
+  issuePacketRelease: ImmutableRef,
+  panels: external_exports.array(ContinualBenchPanelReleaseSchema).min(6).max(1e4),
+  grader: ImmutableRef,
+  judge: external_exports.object({ release: ImmutableRef, rubricRelease: ImmutableRef, calibrationRelease: ImmutableRef, model: ChatModelRef }).strict().nullable(),
+  policies: external_exports.object({ base: ContinualBenchPolicyIdentitySchema, master: ContinualBenchPolicyIdentitySchema.nullable(), externalReferences: external_exports.array(ContinualBenchPolicyIdentitySchema).min(1).max(20) }).strict(),
+  invariants: external_exports.object({
+    systemPromptHash: Hash,
+    toolSchema: ImmutableRef,
+    application: ImmutableRef,
+    harness: ImmutableRef,
+    runtime: ImmutableRef,
+    workerImage: ImmutableRef,
+    autoRefiner: external_exports.object({ enabled: external_exports.boolean(), release: ImmutableRef.nullable() }).strict()
+  }).strict(),
+  schedule: external_exports.array(ContinualBenchScheduleEntrySchema).min(1).max(1e3),
+  evaluation: external_exports.object({ seeds: external_exports.array(external_exports.number().int()).min(3).max(100), repetitions: external_exports.number().int().min(3).max(20), powerRule: ImmutableRef, pairedBootstrapSamples: external_exports.number().int().min(1e3).max(1e6), confidenceLevel: external_exports.literal(0.95) }).strict(),
+  resources: external_exports.object({ maximumTrainingGpuSeconds: external_exports.number().int().positive(), maximumEvaluationGpuSeconds: external_exports.number().int().positive(), maximumProviderSpendUsd: external_exports.number().positive(), maximumTotalSpendUsd: external_exports.number().positive(), maximumConcurrentGroups: external_exports.number().int().positive().max(1e3) }).strict(),
+  currencyThresholds: ContinualBenchCurrencyThresholdsSchema
+}).strict().superRefine((protocol, context) => {
+  const panelIds = protocol.panels.map((panel) => panel.id);
+  if (new Set(panelIds).size !== panelIds.length)
+    context.addIssue({ code: "custom", path: ["panels"], message: "Protocol panel ids must be unique." });
+  for (const role of ["development", "retained", "frozen_final", "training_eligible"]) {
+    if (protocol.panels.filter((panel) => panel.role === role).length !== 1)
+      context.addIssue({ code: "custom", path: ["panels"], message: `A protocol requires exactly one ${role} panel.` });
+  }
+  const ordered = [...protocol.schedule].sort((left, right) => left.ordinal - right.ordinal);
+  if (ordered.some((entry, index) => entry.ordinal !== index))
+    context.addIssue({ code: "custom", path: ["schedule"], message: "Protocol schedule ordinals must be contiguous from zero." });
+  const known = new Set(panelIds);
+  if (protocol.schedule.some((entry) => entry.correctionPanelIds.some((id) => !known.has(id))))
+    context.addIssue({ code: "custom", path: ["schedule"], message: "Every scheduled correction panel must belong to the protocol." });
+});
+
+export {
+  ContinualBenchPanelRoleSchema,
+  ContinualBenchIssuePacketSchema,
+  ContinualBenchmarkProtocolReleaseSchema
+};

package/dist/chunks/{chunk-7C4OIFOC.js → chunk-TGM5IPYO.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   now
-} from "./chunk-NPNIL6SQ.js";
+} from "./chunk-AN2EYCN3.js";
 
 // ../server/src/workspace/workspace-command.ts
 import { spawn, spawnSync } from "node:child_process";
@@ -131,6 +131,7 @@ var MAX_PATCH_CHARS = 24e3;
 var MAX_FILE_CHARS = 8e4;
 var MAX_READABLE_FILE_BYTES = 512 * 1024;
 var MAX_WORKSPACE_IMAGE_BYTES = 15 * 1024 * 1024;
+var MAX_WORKSPACE_DOCUMENT_BYTES = 20 * 1024 * 1024;
 var GENERATED_WORKSPACE_DIRS = /* @__PURE__ */ new Set([
   ".cache",
   ".eggs",
@@ -167,6 +168,8 @@ var BINARY_WORKSPACE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".7z",
   ".avif",
   ".db",
+  ".doc",
+  ".docx",
   ".gif",
   ".gz",
   ".ico",
@@ -198,6 +201,7 @@ var LOCAL_VIDEO_CONTENT_TYPES = /* @__PURE__ */ new Map([
   [".mp4", "video/mp4"],
   [".webm", "video/webm"]
 ]);
+var WORKSPACE_DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([".doc", ".docx", ".pdf"]);
 function safeAppSegment(appId) {
   return appId.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "app";
 }
@@ -253,6 +257,22 @@ async function readWorkspaceFile(repoPath, filePath) {
     return null;
   }
 }
+async function readWorkspaceDocumentPreview(repoPath, filePath) {
+  const normalizedPath = normalizeWorkspaceFilePath(filePath);
+  if (!normalizedPath || !WORKSPACE_DOCUMENT_EXTENSIONS.has(path2.extname(normalizedPath).toLowerCase())) {
+    return null;
+  }
+  const target = path2.resolve(repoPath, normalizedPath);
+  const root = path2.resolve(repoPath);
+  if (target !== root && !target.startsWith(`${root}${path2.sep}`)) return null;
+  try {
+    const stat = await fs2.lstat(target);
+    if (!stat.isFile() || stat.size > MAX_WORKSPACE_DOCUMENT_BYTES) return null;
+    return (await fs2.readFile(target)).toString("base64");
+  } catch {
+    return null;
+  }
+}
 function workspaceImageContentType(filePath) {
   return WORKSPACE_IMAGE_CONTENT_TYPES.get(path2.extname(filePath).toLowerCase()) ?? null;
 }
@@ -1102,10 +1122,17 @@ async function loadWorkspaceFileAtPath(repoPath, filePath) {
   if (isGeneratedWorkspacePath(normalizedPath)) throw new Error("File not found");
   if (initialized) {
     const detail = await loadGitWorkspaceFileAtPath(repoPath, normalizedPath);
-    if (detail) return detail;
+    if (detail) {
+      if (detail.content !== null || detail.status === "deleted") return detail;
+      const documentContent = await readWorkspaceDocumentPreview(
+        repoPath,
+        normalizedPath
+      );
+      return documentContent === null ? detail : { ...detail, content: documentContent };
+    }
   }
   let resolvedPath = normalizedPath;
-  let content = await readWorkspaceFile(repoPath, resolvedPath);
+  let content = await readWorkspaceFile(repoPath, resolvedPath) ?? await readWorkspaceDocumentPreview(repoPath, resolvedPath);
   if (content === null) {
     const basenameMatch = await resolveExplicitMarkdownBasenamePath(repoPath, normalizedPath);
     if (basenameMatch) {
@@ -1210,6 +1237,7 @@ export {
   isGitRepo,
   truncatePatch,
   readWorkspaceFile,
+  readWorkspaceDocumentPreview,
   workspaceImageContentType,
   localVideoContentType,
   readWorkspaceImageFile,