openpond 0.0.69 → 0.1.1

package/dist/chunks/{chunk-OOM2PHBE.js → chunk-O6B6YCMI.js}

@@ -11,7 +11,7 @@ import {
   truncatePatch,
   uniqueSortedPaths,
   workspaceImageContentType
-} from "./chunk-7C4OIFOC.js";
+} from "./chunk-C5TKGE5Y.js";
 import {
   AGENT_PROTOCOL_VERSION,
   AGENT_RPC_METHODS,
@@ -35,13 +35,13 @@ import {
   event,
   now,
   textFromUnknown
-} from "./chunk-NPNIL6SQ.js";
+} from "./chunk-DJL4TJYG.js";
 import {
   getBundledRuntimeVersion,
   loadOpenPondAccountContext,
   loadOpenPondHostedModels,
   streamOpenPondHostedChatTurn
-} from "./chunk-FEOLMLYU.js";
+} from "./chunk-EFET7LB7.js";
 import {
   ActivateRefinerReleaseRequestSchema,
   AppPreferencesSchema,
@@ -58,6 +58,8 @@ import {
   ChatProviderSchema,
   ConnectedAppToolCallRequestSchema,
   ContextUsageSnapshotSchema,
+  ContinualBenchIssueReviewSchema,
+  ContinualLearningDailyBatchSchema,
   CreateHostedSavedWorkRequestSchema,
   CreateImproveActionShapeSchema,
   CreateImproveEvidenceSnapshotSchema,
@@ -94,6 +96,9 @@ import {
   LearnedPreferenceRewardBindingSchema,
   ModelArtifactLineageSchema,
   ModelBindingSchema,
+  ModelComparisonSeriesEntrySchema,
+  ModelComparisonSeriesSchema,
+  ModelCurrencySnapshotSchema,
   ModelProjectSchema as ModelProjectSchema2,
   ModelRunSchema,
   ModelUsageRecordSchema,
@@ -171,7 +176,7 @@ import {
   runProfileSkillCommand,
   sidebarFileBookmarkId,
   workOutputMediaTypesCompatible
-} from "./chunk-MMRJNSWY.js";
+} from "./chunk-6G6MDZLM.js";
 import {
   PROJECT_ACTION_CONFIG_PATH,
   createLocalActionRunner,
@@ -295,7 +300,7 @@ import {
   uniqueEventRefs,
   validateConnectedAppProviderOperationRequest,
   verifyRequiredOutputs
-} from "./chunk-BLFIIAWZ.js";
+} from "./chunk-NTK22KJD.js";
 import {
   DEFAULT_OPENPOND_API_BASE_URL,
   apiFetch,
@@ -851,7 +856,7 @@ function createLogger(options) {
 }
 
 // ../server/src/harness/local-harness-workspace-service.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { constants as fsConstants, promises as fs4 } from "node:fs";
 import path7 from "node:path";
 
@@ -1048,6 +1053,8 @@ async function persistStoreData(data, writer) {
 }
 
 // ../server/src/store/store-taskset-drafts.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { cp, lstat, mkdir as mkdir3, readFile as readFile3, readdir as readdir2, rename, rm, stat } from "node:fs/promises";
 import path6 from "node:path";
 
 // ../../packages/taskset-sdk/dist/drafts.js
@@ -1103,13 +1110,13 @@ function validateGraderFixtures(taskset, issues) {
   const required = /* @__PURE__ */ new Set(["positive", "negative", "boundary", "adversarial", "prompt_injection", "infrastructure_failure"]);
   for (const fixture of taskset.graderFixtures) {
     if (!taskset.datasetArtifact && !taskIds2.has(fixture.taskId))
-      issues.push({ code: "grader_fixture_task_missing", severity: "error", message: `Fixture ${fixture.id} references missing task ${fixture.taskId}.`, path: `graderFixtures.${fixture.id}.taskId` });
+      issues.push({ code: "grader_fixture_task_missing", severity: "warning", message: `Fixture ${fixture.id} references a task outside this Taskset revision (${fixture.taskId}).`, path: `graderFixtures.${fixture.id}.taskId` });
     required.delete(fixture.label);
     if (fixture.label === "infrastructure_failure" && !fixture.infrastructureError)
       issues.push({ code: "infrastructure_fixture_error_missing", severity: "error", message: `Infrastructure fixture ${fixture.id} must declare an infrastructure error.`, path: `graderFixtures.${fixture.id}.infrastructureError` });
   }
   for (const label of required)
-    issues.push({ code: "grader_fixture_missing", severity: "error", message: `Taskset requires a ${label} grader fixture.`, path: "graderFixtures" });
+    issues.push({ code: "grader_fixture_missing", severity: "warning", message: `Taskset does not include the optional ${label} grader calibration fixture.`, path: "graderFixtures" });
 }
 function validateDatasetArtifact(taskset, issues) {
   const artifact = taskset.datasetArtifact;
@@ -1359,10 +1366,10 @@ function validateGraders(taskset, issues) {
       issues.push({ code: "grader_duplicate", severity: "error", message: `Duplicate grader id ${grader.id}.`, path: "graders" });
     ids.add(grader.id);
     if (grader.kind === "model_judge" && grader.rewardEligible && grader.calibrationStatus !== "passed") {
-      issues.push({ code: "judge_not_calibrated", severity: "error", message: `Model judge ${grader.id} cannot contribute reward before calibration passes.`, path: `graders.${grader.id}` });
+      issues.push({ code: "judge_calibration_pending", severity: "warning", message: `Model judge ${grader.id} is selected for reward without a passing advisory calibration report.`, path: `graders.${grader.id}` });
     }
     if (grader.kind === "model_judge" && grader.calibrationStatus === "passed" && typeof grader.metadata.calibrationEvidenceHash !== "string") {
-      issues.push({ code: "judge_calibration_evidence_missing", severity: "error", message: `Model judge ${grader.id} declares calibration without an OpenPond fixture evidence hash.`, path: `graders.${grader.id}.metadata.calibrationEvidenceHash` });
+      issues.push({ code: "judge_calibration_evidence_missing", severity: "warning", message: `Model judge ${grader.id} declares calibration without an OpenPond fixture evidence hash.`, path: `graders.${grader.id}.metadata.calibrationEvidenceHash` });
     }
     if (grader.kind === "human" && grader.rewardEligible) {
       issues.push({ code: "human_online_reward", severity: "error", message: `Human grader ${grader.id} cannot be an online optimizer reward.`, path: `graders.${grader.id}` });
@@ -2538,7 +2545,7 @@ import { promises as fs3 } from "node:fs";
 import path5 from "node:path";
 
 // ../server/src/store/store-schema.ts
-var CURRENT_SQLITE_SCHEMA_VERSION = 50;
+var CURRENT_SQLITE_SCHEMA_VERSION = 56;
 var SQLITE_CREATE_SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
@@ -3065,7 +3072,7 @@ var SQLITE_CREATE_SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS model_runs (
     id TEXT PRIMARY KEY,
     model_id TEXT NOT NULL,
-    model_version_id TEXT NOT NULL,
+    model_version_id TEXT,
     profile_id TEXT NOT NULL,
     taskset_id TEXT NOT NULL,
     status TEXT NOT NULL,
@@ -3077,6 +3084,33 @@ var SQLITE_CREATE_SCHEMA_SQL = `
   CREATE INDEX IF NOT EXISTS model_runs_model_updated_idx ON model_runs(model_id, updated_at DESC);
   CREATE INDEX IF NOT EXISTS model_runs_taskset_updated_idx ON model_runs(taskset_id, updated_at DESC);
 
+  CREATE TABLE IF NOT EXISTS model_comparison_series (
+    id TEXT PRIMARY KEY,
+    profile_id TEXT NOT NULL,
+    model_project_id TEXT NOT NULL,
+    status TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS model_comparison_series_profile_updated_idx ON model_comparison_series(profile_id, updated_at DESC);
+  CREATE INDEX IF NOT EXISTS model_comparison_series_project_updated_idx ON model_comparison_series(model_project_id, updated_at DESC);
+
+  CREATE TABLE IF NOT EXISTS model_comparison_series_entries (
+    id TEXT PRIMARY KEY,
+    series_id TEXT NOT NULL,
+    profile_id TEXT NOT NULL,
+    model_project_id TEXT NOT NULL,
+    ordinal INTEGER NOT NULL,
+    status TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(series_id, ordinal)
+  );
+  CREATE INDEX IF NOT EXISTS model_comparison_entries_series_ordinal_idx ON model_comparison_series_entries(series_id, ordinal ASC);
+  CREATE INDEX IF NOT EXISTS model_comparison_entries_project_updated_idx ON model_comparison_series_entries(model_project_id, updated_at DESC);
+
   CREATE TABLE IF NOT EXISTS reward_model_versions (
     id TEXT PRIMARY KEY,
     model_id TEXT NOT NULL,
@@ -3484,6 +3518,43 @@ async function createSidebarFileBookmarkTables(exec) {
   `);
 }
 
+// ../server/src/store/store-chat-workflow-schema.ts
+async function createChatWorkflowTables(exec) {
+  await exec(`
+    CREATE TABLE IF NOT EXISTS chat_workflows (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      enabled INTEGER NOT NULL,
+      next_run_at TEXT,
+      payload TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS chat_workflows_session_idx
+      ON chat_workflows(session_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS chat_workflows_due_idx
+      ON chat_workflows(enabled, next_run_at);
+
+    CREATE TABLE IF NOT EXISTS chat_workflow_runs (
+      id TEXT PRIMARY KEY,
+      workflow_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      scheduled_for TEXT NOT NULL,
+      trigger TEXT NOT NULL,
+      status TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE UNIQUE INDEX IF NOT EXISTS chat_workflow_runs_occurrence_idx
+      ON chat_workflow_runs(workflow_id, scheduled_for, trigger);
+    CREATE INDEX IF NOT EXISTS chat_workflow_runs_workflow_idx
+      ON chat_workflow_runs(workflow_id, created_at DESC);
+  `);
+}
+
 // ../server/src/store/store-harness-workspace-schema.ts
 async function createHarnessWorkspaceTables(exec) {
   await exec(`
@@ -4041,6 +4112,31 @@ var SQLITE_MIGRATIONS = [
   {
     version: 50,
     run: (store) => store.repairUnverifiableLearnedPreferenceBindings()
+  },
+  {
+    version: 51,
+    run: (store) => store.createTrainingTables()
+  },
+  {
+    version: 52,
+    run: (store) => store.allowModelRunsWithoutVersion()
+  },
+  {
+    version: 53,
+    run: (store) => store.createTrainingTables()
+  },
+  {
+    version: 54,
+    run: (store) => store.createTrainingTables()
+  },
+  {
+    // Add persisted daily Evals intake/review batches to existing stores.
+    version: 55,
+    run: (store) => store.createTrainingTables()
+  },
+  {
+    version: 56,
+    run: (store) => store.createChatWorkflowTables()
   }
 ];
 
@@ -4118,6 +4214,33 @@ async function createModelProjectTables(database) {
     DROP TABLE IF EXISTS model_build_drafts;
   `);
 }
+async function allowModelRunsWithoutVersion(database) {
+  await database.exec(`
+    ALTER TABLE model_runs RENAME TO model_runs_before_nullable_version;
+    CREATE TABLE model_runs (
+      id TEXT PRIMARY KEY,
+      model_id TEXT NOT NULL,
+      model_version_id TEXT,
+      profile_id TEXT NOT NULL,
+      taskset_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    INSERT INTO model_runs (
+      id, model_id, model_version_id, profile_id, taskset_id, status, payload,
+      created_at, updated_at
+    )
+    SELECT id, model_id, model_version_id, profile_id, taskset_id, status,
+      payload, created_at, updated_at
+    FROM model_runs_before_nullable_version;
+    DROP TABLE model_runs_before_nullable_version;
+    CREATE INDEX model_runs_profile_updated_idx ON model_runs(profile_id, updated_at DESC);
+    CREATE INDEX model_runs_model_updated_idx ON model_runs(model_id, updated_at DESC);
+    CREATE INDEX model_runs_taskset_updated_idx ON model_runs(taskset_id, updated_at DESC);
+  `);
+}
 
 // ../server/src/store/store-model-project-training-setup-migration.ts
 var EMPTY_SETUP = {
@@ -4278,7 +4401,7 @@ async function createModelLifecycleTables(database) {
     CREATE TABLE IF NOT EXISTS model_runs (
       id TEXT PRIMARY KEY,
       model_id TEXT NOT NULL,
-      model_version_id TEXT NOT NULL,
+      model_version_id TEXT,
       profile_id TEXT NOT NULL,
       taskset_id TEXT NOT NULL,
       status TEXT NOT NULL,
@@ -4534,10 +4657,23 @@ var TRAINING_TABLES_SQL = `
   CREATE TABLE IF NOT EXISTS model_versions (id TEXT PRIMARY KEY, model_id TEXT NOT NULL, profile_id TEXT NOT NULL, version_number INTEGER NOT NULL, kind TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, UNIQUE(model_id, version_number));
   CREATE INDEX IF NOT EXISTS model_versions_profile_created_idx ON model_versions(profile_id, created_at DESC);
   CREATE INDEX IF NOT EXISTS model_versions_model_idx ON model_versions(model_id, version_number DESC);
-  CREATE TABLE IF NOT EXISTS model_runs (id TEXT PRIMARY KEY, model_id TEXT NOT NULL, model_version_id TEXT NOT NULL, profile_id TEXT NOT NULL, taskset_id TEXT NOT NULL, status TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
+  CREATE TABLE IF NOT EXISTS model_runs (id TEXT PRIMARY KEY, model_id TEXT NOT NULL, model_version_id TEXT, profile_id TEXT NOT NULL, taskset_id TEXT NOT NULL, status TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
   CREATE INDEX IF NOT EXISTS model_runs_profile_updated_idx ON model_runs(profile_id, updated_at DESC);
   CREATE INDEX IF NOT EXISTS model_runs_model_updated_idx ON model_runs(model_id, updated_at DESC);
   CREATE INDEX IF NOT EXISTS model_runs_taskset_updated_idx ON model_runs(taskset_id, updated_at DESC);
+  CREATE TABLE IF NOT EXISTS model_comparison_series (id TEXT PRIMARY KEY, profile_id TEXT NOT NULL, model_project_id TEXT NOT NULL, status TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
+  CREATE INDEX IF NOT EXISTS model_comparison_series_profile_updated_idx ON model_comparison_series(profile_id, updated_at DESC);
+  CREATE INDEX IF NOT EXISTS model_comparison_series_project_updated_idx ON model_comparison_series(model_project_id, updated_at DESC);
+  CREATE TABLE IF NOT EXISTS model_comparison_series_entries (id TEXT PRIMARY KEY, series_id TEXT NOT NULL, profile_id TEXT NOT NULL, model_project_id TEXT NOT NULL, ordinal INTEGER NOT NULL, status TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, UNIQUE(series_id, ordinal));
+  CREATE INDEX IF NOT EXISTS model_comparison_entries_series_ordinal_idx ON model_comparison_series_entries(series_id, ordinal ASC);
+  CREATE INDEX IF NOT EXISTS model_comparison_entries_project_updated_idx ON model_comparison_series_entries(model_project_id, updated_at DESC);
+  CREATE TABLE IF NOT EXISTS model_currency_snapshots (id TEXT PRIMARY KEY, series_id TEXT NOT NULL, entry_id TEXT NOT NULL, evidence_state TEXT NOT NULL, content_hash TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, UNIQUE(entry_id, content_hash));
+  CREATE INDEX IF NOT EXISTS model_currency_snapshots_series_created_idx ON model_currency_snapshots(series_id, created_at DESC);
+  CREATE INDEX IF NOT EXISTS model_currency_snapshots_entry_created_idx ON model_currency_snapshots(entry_id, created_at DESC);
+  CREATE TABLE IF NOT EXISTS continual_bench_issue_reviews (id TEXT PRIMARY KEY, series_id TEXT NOT NULL, pass_label TEXT NOT NULL, status TEXT NOT NULL, revision INTEGER NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, UNIQUE(series_id, pass_label));
+  CREATE INDEX IF NOT EXISTS continual_bench_issue_reviews_series_updated_idx ON continual_bench_issue_reviews(series_id, updated_at DESC);
+  CREATE TABLE IF NOT EXISTS continual_learning_daily_batches (id TEXT PRIMARY KEY, series_id TEXT NOT NULL, schedule_entry_id TEXT NOT NULL, day_ordinal INTEGER NOT NULL, status TEXT NOT NULL, revision INTEGER NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, UNIQUE(series_id, day_ordinal), UNIQUE(series_id, schedule_entry_id));
+  CREATE INDEX IF NOT EXISTS continual_learning_daily_batches_series_ordinal_idx ON continual_learning_daily_batches(series_id, day_ordinal ASC);
   CREATE TABLE IF NOT EXISTS reward_model_versions (id TEXT PRIMARY KEY, model_id TEXT NOT NULL, profile_id TEXT NOT NULL, version_number INTEGER NOT NULL, taskset_id TEXT NOT NULL, status TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL, UNIQUE(model_id, version_number));
   CREATE INDEX IF NOT EXISTS reward_model_versions_profile_created_idx ON reward_model_versions(profile_id, created_at DESC);
   CREATE INDEX IF NOT EXISTS reward_model_versions_taskset_created_idx ON reward_model_versions(taskset_id, created_at DESC);
@@ -4983,6 +5119,9 @@ var SqliteStoreCore = class {
         ON local_agent_schedule_runs(schedule_id, created_at DESC);
     `);
   }
+  async createChatWorkflowTables() {
+    return createChatWorkflowTables((sql) => this.exec(sql));
+  }
   async createSubagentTables() {
     await this.exec(`
       CREATE TABLE IF NOT EXISTS subagent_runs (
@@ -5080,18 +5219,20 @@ var SqliteStoreCore = class {
     `);
   }
   async createModelProjectTables() {
-    await createModelProjectTables({
-      all: (sql, params = []) => this.all(sql, params),
-      exec: (sql) => this.exec(sql),
-      run: (sql, params = []) => this.run(sql, params)
-    });
+    await createModelProjectTables(this.modelProjectMigrationStore());
+  }
+  async allowModelRunsWithoutVersion() {
+    await allowModelRunsWithoutVersion(this.modelProjectMigrationStore());
   }
   async consolidateModelProjectTrainingSetup() {
-    await consolidateModelProjectTrainingSetup({
+    await consolidateModelProjectTrainingSetup(this.modelProjectMigrationStore());
+  }
+  modelProjectMigrationStore() {
+    return {
       all: (sql, params = []) => this.all(sql, params),
       exec: (sql) => this.exec(sql),
       run: (sql, params = []) => this.run(sql, params)
-    });
+    };
   }
   async repairUnverifiableLearnedPreferenceBindings() {
     await repairUnverifiableLearnedPreferenceBindings({
@@ -5443,6 +5584,253 @@ var SqliteStoreCore = class {
 
 // ../server/src/store/store-training-models.ts
 var SqliteTrainingModelStore = class extends SqliteStoreCore {
+  async saveModelCurrencySnapshot(snapshotInput2) {
+    const snapshot = ModelCurrencySnapshotSchema.parse(snapshotInput2);
+    const existing = await this.getModelCurrencySnapshot(snapshot.id);
+    if (existing) {
+      if (existing.contentHash === snapshot.contentHash && JSON.stringify(existing) === JSON.stringify(snapshot)) return existing;
+      throw new Error("An immutable Model Currency Snapshot cannot be replaced.");
+    }
+    await this.upsertPayload(
+      `INSERT INTO model_currency_snapshots
+        (id, series_id, entry_id, evidence_state, content_hash, payload, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [snapshot.id, snapshot.seriesId, snapshot.entryId, snapshot.evidenceState, snapshot.contentHash, JSON.stringify(snapshot), snapshot.projectedAt]
+    );
+    return snapshot;
+  }
+  async getModelCurrencySnapshot(id) {
+    return this.getParsedPayload("SELECT payload FROM model_currency_snapshots WHERE id = ?", [id], ModelCurrencySnapshotSchema.parse);
+  }
+  async listModelCurrencySnapshots(input = {}) {
+    if (input.entryId) return this.listParsedPayloads("SELECT payload FROM model_currency_snapshots WHERE entry_id = ? ORDER BY created_at DESC", [input.entryId], ModelCurrencySnapshotSchema.parse);
+    if (input.seriesId) return this.listParsedPayloads("SELECT payload FROM model_currency_snapshots WHERE series_id = ? ORDER BY created_at DESC", [input.seriesId], ModelCurrencySnapshotSchema.parse);
+    return this.listParsedPayloads("SELECT payload FROM model_currency_snapshots ORDER BY created_at DESC", [], ModelCurrencySnapshotSchema.parse);
+  }
+  async saveModelComparisonSeries(seriesInput) {
+    const series = ModelComparisonSeriesSchema.parse(seriesInput);
+    const existing = await this.getModelComparisonSeries(series.id);
+    if (existing && (existing.profileId !== series.profileId || existing.modelProjectId !== series.modelProjectId || existing.createdAt !== series.createdAt)) {
+      throw new Error("A Model Comparison Series cannot change its immutable ownership.");
+    }
+    if (existing && series.revision !== existing.revision + 1) {
+      if (JSON.stringify(existing) === JSON.stringify(series)) return existing;
+      throw new Error("A Model Comparison Series update requires the next revision.");
+    }
+    if (existing?.scheduleSealedAt && !sameSealedSeriesDefinition(existing, series)) {
+      throw new Error("A sealed Model Comparison Series definition is immutable.");
+    }
+    await this.upsertPayload(
+      `INSERT INTO model_comparison_series
+        (id, profile_id, model_project_id, status, payload, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         status = excluded.status,
+         payload = excluded.payload,
+         updated_at = excluded.updated_at`,
+      [
+        series.id,
+        series.profileId,
+        series.modelProjectId,
+        series.status,
+        JSON.stringify(series),
+        series.createdAt,
+        series.updatedAt
+      ]
+    );
+    return series;
+  }
+  async getModelComparisonSeries(id) {
+    return this.getParsedPayload(
+      "SELECT payload FROM model_comparison_series WHERE id = ?",
+      [id],
+      ModelComparisonSeriesSchema.parse
+    );
+  }
+  async listModelComparisonSeries(input = {}) {
+    if (input.modelProjectId) {
+      return this.listParsedPayloads(
+        "SELECT payload FROM model_comparison_series WHERE model_project_id = ? ORDER BY updated_at DESC",
+        [input.modelProjectId],
+        ModelComparisonSeriesSchema.parse
+      );
+    }
+    if (input.profileId) {
+      return this.listParsedPayloads(
+        "SELECT payload FROM model_comparison_series WHERE profile_id = ? ORDER BY updated_at DESC",
+        [input.profileId],
+        ModelComparisonSeriesSchema.parse
+      );
+    }
+    return this.listParsedPayloads(
+      "SELECT payload FROM model_comparison_series ORDER BY updated_at DESC",
+      [],
+      ModelComparisonSeriesSchema.parse
+    );
+  }
+  async saveModelComparisonSeriesEntry(entryInput) {
+    const entry = ModelComparisonSeriesEntrySchema.parse(entryInput);
+    const existing = await this.getModelComparisonSeriesEntry(entry.id);
+    if (existing && !sameEntryLineage(existing, entry)) {
+      throw new Error("A Model Comparison Series Entry cannot change its immutable release lineage.");
+    }
+    if (existing && !validEntryEvidenceEvolution(existing, entry)) {
+      throw new Error("A Model Comparison Series Entry cannot replace linked evidence or artifact lineage.");
+    }
+    await this.upsertPayload(
+      `INSERT INTO model_comparison_series_entries
+        (id, series_id, profile_id, model_project_id, ordinal, status, payload, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         status = excluded.status,
+         payload = excluded.payload,
+         updated_at = excluded.updated_at`,
+      [
+        entry.id,
+        entry.seriesId,
+        entry.profileId,
+        entry.modelProjectId,
+        entry.ordinal,
+        entry.status,
+        JSON.stringify(entry),
+        entry.createdAt,
+        entry.updatedAt
+      ]
+    );
+    return entry;
+  }
+  async getModelComparisonSeriesEntry(id) {
+    return this.getParsedPayload(
+      "SELECT payload FROM model_comparison_series_entries WHERE id = ?",
+      [id],
+      ModelComparisonSeriesEntrySchema.parse
+    );
+  }
+  async listModelComparisonSeriesEntries(input = {}) {
+    if (input.seriesId) {
+      return this.listParsedPayloads(
+        "SELECT payload FROM model_comparison_series_entries WHERE series_id = ? ORDER BY ordinal ASC",
+        [input.seriesId],
+        ModelComparisonSeriesEntrySchema.parse
+      );
+    }
+    if (input.modelProjectId) {
+      return this.listParsedPayloads(
+        "SELECT payload FROM model_comparison_series_entries WHERE model_project_id = ? ORDER BY updated_at DESC",
+        [input.modelProjectId],
+        ModelComparisonSeriesEntrySchema.parse
+      );
+    }
+    return this.listParsedPayloads(
+      "SELECT payload FROM model_comparison_series_entries ORDER BY updated_at DESC",
+      [],
+      ModelComparisonSeriesEntrySchema.parse
+    );
+  }
+  async commitModelComparisonSeriesMutation(input) {
+    const nextSeries = ModelComparisonSeriesSchema.parse(input.series);
+    const nextEntry = ModelComparisonSeriesEntrySchema.parse(input.entry);
+    await this.ready;
+    let result2 = { series: nextSeries, entry: nextEntry };
+    const write = this.writeQueue.then(async () => {
+      await this.exec("BEGIN IMMEDIATE");
+      try {
+        const seriesRow = await this.get(
+          "SELECT payload FROM model_comparison_series WHERE id = ?",
+          [nextSeries.id]
+        );
+        if (!seriesRow) throw new Error("Model Comparison Series not found.");
+        const currentSeries = ModelComparisonSeriesSchema.parse(JSON.parse(seriesRow.payload));
+        if (currentSeries.revision !== input.expectedSeriesRevision) {
+          throw new Error(`Comparison Series revision changed; expected ${input.expectedSeriesRevision} and found ${currentSeries.revision}.`);
+        }
+        if (nextSeries.revision !== currentSeries.revision + 1) {
+          throw new Error("A Comparison Series mutation must advance exactly one revision.");
+        }
+        if (currentSeries.scheduleSealedAt && !sameSealedSeriesDefinition(currentSeries, nextSeries)) {
+          throw new Error("A sealed Model Comparison Series definition is immutable.");
+        }
+        const entryRow = await this.get(
+          "SELECT payload FROM model_comparison_series_entries WHERE id = ?",
+          [nextEntry.id]
+        );
+        const currentEntry = entryRow ? ModelComparisonSeriesEntrySchema.parse(JSON.parse(entryRow.payload)) : null;
+        if ((currentEntry?.status ?? null) !== input.expectedEntryStatus) {
+          throw new Error("The Comparison Series Entry changed before the mutation could be applied.");
+        }
+        if (currentEntry && !sameEntryLineage(currentEntry, nextEntry)) {
+          throw new Error("A Model Comparison Series Entry cannot change its immutable release lineage.");
+        }
+        if (currentEntry && !validEntryEvidenceEvolution(currentEntry, nextEntry)) {
+          throw new Error("A Model Comparison Series Entry cannot replace linked evidence or artifact lineage.");
+        }
+        await this.run(
+          `INSERT INTO model_comparison_series_entries
+            (id, series_id, profile_id, model_project_id, ordinal, status, payload, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET status = excluded.status, payload = excluded.payload, updated_at = excluded.updated_at`,
+          [
+            nextEntry.id,
+            nextEntry.seriesId,
+            nextEntry.profileId,
+            nextEntry.modelProjectId,
+            nextEntry.ordinal,
+            nextEntry.status,
+            JSON.stringify(nextEntry),
+            nextEntry.createdAt,
+            nextEntry.updatedAt
+          ]
+        );
+        await this.run(
+          `UPDATE model_comparison_series SET status = ?, payload = ?, updated_at = ? WHERE id = ?`,
+          [nextSeries.status, JSON.stringify(nextSeries), nextSeries.updatedAt, nextSeries.id]
+        );
+        await this.exec("COMMIT");
+        result2 = { series: nextSeries, entry: nextEntry };
+      } catch (error) {
+        await this.exec("ROLLBACK").catch(() => void 0);
+        throw error;
+      }
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return result2;
+  }
+  async compareAndSwapModelComparisonSeriesEntry(input) {
+    const next = ModelComparisonSeriesEntrySchema.parse(input.entry);
+    await this.ready;
+    const write = this.writeQueue.then(async () => {
+      await this.exec("BEGIN IMMEDIATE");
+      try {
+        const row = await this.get(
+          "SELECT payload FROM model_comparison_series_entries WHERE id = ?",
+          [next.id]
+        );
+        if (!row) throw new Error("Model Comparison Series Entry not found.");
+        const current = ModelComparisonSeriesEntrySchema.parse(JSON.parse(row.payload));
+        if (current.status !== input.expectedStatus) {
+          throw new Error(`Comparison entry state changed; expected ${input.expectedStatus} and found ${current.status}.`);
+        }
+        if (!sameEntryLineage(current, next)) {
+          throw new Error("A Model Comparison Series Entry cannot change its immutable release lineage.");
+        }
+        if (!validEntryEvidenceEvolution(current, next)) {
+          throw new Error("A Model Comparison Series Entry cannot replace linked evidence or artifact lineage.");
+        }
+        await this.run(
+          "UPDATE model_comparison_series_entries SET status = ?, payload = ?, updated_at = ? WHERE id = ?",
+          [next.status, JSON.stringify(next), next.updatedAt, next.id]
+        );
+        await this.exec("COMMIT");
+      } catch (error) {
+        await this.exec("ROLLBACK").catch(() => void 0);
+        throw error;
+      }
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return next;
+  }
   async saveRewardModelVersion(versionInput) {
     const version = RewardModelVersionSchema.parse(versionInput);
     const existing = await this.getRewardModelVersion(version.id);
@@ -5615,7 +6003,7 @@ var SqliteTrainingModelStore = class extends SqliteStoreCore {
   async saveModelRun(runInput) {
     const modelRun = ModelRunSchema.parse(runInput);
     const existing = await this.getModelRun(modelRun.id);
-    if (existing && (existing.modelId !== modelRun.modelId || existing.modelVersionId !== modelRun.modelVersionId || existing.profileId !== modelRun.profileId || existing.taskset.id !== modelRun.taskset.id)) {
+    if (existing && (existing.modelId !== modelRun.modelId || existing.modelVersionId !== modelRun.modelVersionId || existing.profileId !== modelRun.profileId || existing.taskset.id !== modelRun.taskset.id || JSON.stringify(existing.comparisonSeriesEntry ?? null) !== JSON.stringify(modelRun.comparisonSeriesEntry ?? null))) {
       throw new Error("A Model Run cannot change its immutable lineage.");
     }
     if (existing && ["succeeded", "failed", "cancelled"].includes(existing.status) && JSON.stringify(existing) !== JSON.stringify(modelRun) && !isCheckpointResumeTransition(existing, modelRun)) {
@@ -5852,6 +6240,83 @@ var SqliteTrainingModelStore = class extends SqliteStoreCore {
     return row ? parse2(JSON.parse(row.payload)) : null;
   }
 };
+function sameSealedSeriesDefinition(left, right) {
+  const definition = (series) => ({
+    id: series.id,
+    profileId: series.profileId,
+    modelProjectId: series.modelProjectId,
+    name: series.name,
+    objective: series.objective,
+    productionBinding: series.productionBinding,
+    baseModel: series.baseModel,
+    seedTaskset: series.seedTaskset,
+    eligibleTaskPool: series.eligibleTaskPool,
+    evaluationTasksets: series.evaluationTasksets,
+    grader: series.grader,
+    benchmarkProtocol: series.benchmarkProtocol,
+    automaticEvaluation: series.automaticEvaluation,
+    residualProfile: series.residualProfile,
+    schedule: series.schedule,
+    scheduleSealedAt: series.scheduleSealedAt,
+    advancementPolicy: series.advancementPolicy,
+    executionPolicy: series.executionPolicy,
+    createdBy: series.createdBy,
+    createdAt: series.createdAt
+  });
+  return JSON.stringify(definition(left)) === JSON.stringify(definition(right));
+}
+function sameEntryLineage(left, right) {
+  const lineage = (entry) => ({
+    seriesId: entry.seriesId,
+    profileId: entry.profileId,
+    modelProjectId: entry.modelProjectId,
+    scheduleEntryId: entry.scheduleEntryId,
+    releaseHash: entry.releaseHash,
+    ordinal: entry.ordinal,
+    label: entry.label,
+    role: entry.role,
+    branch: entry.branch,
+    parent: entry.parent,
+    taskset: entry.taskset,
+    sourceTasksets: entry.sourceTasksets,
+    taskSelection: entry.taskSelection,
+    trainableRank: entry.trainableRank,
+    serializedEnvelopeRank: entry.serializedEnvelopeRank,
+    enabledCumulativeRank: entry.enabledCumulativeRank,
+    trainableBlockId: entry.trainableBlockId,
+    residualBlocks: entry.residualBlocks.map(({ artifactLineageId: _artifactLineageId, ...block }) => block),
+    createdAt: entry.createdAt
+  });
+  return JSON.stringify(lineage(left)) === JSON.stringify(lineage(right));
+}
+function validEntryEvidenceEvolution(current, next) {
+  if (validEntryRetryEvolution(current, next)) return true;
+  const appendOnlyId = (before, after) => before === null || before === after;
+  if (current.attemptOrdinal !== next.attemptOrdinal || JSON.stringify(current.priorRunAttempts) !== JSON.stringify(next.priorRunAttempts) || !appendOnlyId(current.trainingPlanId, next.trainingPlanId) || !appendOnlyId(current.modelRunId, next.modelRunId) || !appendOnlyId(current.modelVersionId, next.modelVersionId) || !appendOnlyId(current.promotionBindingId, next.promotionBindingId) || current.decision !== null && JSON.stringify(current.decision) !== JSON.stringify(next.decision)) return false;
+  const nextEvaluations = new Map(next.evaluations.map((evaluation) => [evaluation.evaluationRunId, evaluation]));
+  if (current.evaluations.some((evaluation) => JSON.stringify(nextEvaluations.get(evaluation.evaluationRunId)) !== JSON.stringify(evaluation))) return false;
+  const nextBlocks = new Map(next.residualBlocks.map((block) => [block.id, block]));
+  return current.residualBlocks.every((block) => {
+    if (!block.artifactLineageId) return true;
+    return nextBlocks.get(block.id)?.artifactLineageId === block.artifactLineageId;
+  });
+}
+function validEntryRetryEvolution(current, next) {
+  if (current.status !== "failed" && current.status !== "cancelled" || next.status !== "ready" || current.modelVersionId !== null || current.evaluations.length !== 0 || current.decision !== null || current.promotionBindingId !== null || current.residualBlocks.some(
+    (block) => block.id === current.trainableBlockId && block.artifactLineageId !== null
+  ) || next.trainingPlanId !== null || next.modelRunId !== null || next.modelVersionId !== null || next.evaluations.length !== 0 || next.decision !== null || next.promotionBindingId !== null || next.queuedAt !== null || next.startedAt !== null || next.completedAt !== null || JSON.stringify(current.residualBlocks) !== JSON.stringify(next.residualBlocks)) return false;
+  const hasAttempt = Boolean(current.trainingPlanId || current.modelRunId);
+  const expectedAttempts = hasAttempt ? [...current.priorRunAttempts, {
+    attemptOrdinal: current.attemptOrdinal,
+    trainingPlanId: current.trainingPlanId,
+    modelRunId: current.modelRunId,
+    terminalStatus: current.status,
+    queuedAt: current.queuedAt,
+    startedAt: current.startedAt,
+    completedAt: current.completedAt ?? next.updatedAt
+  }] : current.priorRunAttempts;
+  return next.attemptOrdinal === current.attemptOrdinal + (hasAttempt ? 1 : 0) && JSON.stringify(next.priorRunAttempts) === JSON.stringify(expectedAttempts);
+}
 function isCheckpointResumeTransition(existing, candidate) {
   if (existing.kind !== "evaluation" || !["failed", "cancelled"].includes(existing.status) || candidate.status !== "running" || candidate.receipt !== null || candidate.failure !== null || candidate.completedAt !== null || !existing.evaluation) {
     return false;
@@ -5881,8 +6346,57 @@ function isCheckpointResumeTransition(existing, candidate) {
   }) === JSON.stringify(candidate);
 }
 
+// ../server/src/store/store-continual-support-reviews.ts
+var SqliteContinualBenchReviewStore = class extends SqliteTrainingModelStore {
+  async saveContinualLearningDailyBatch(batchInput) {
+    const batch = ContinualLearningDailyBatchSchema.parse(batchInput);
+    const existing = await this.getContinualLearningDailyBatch(batch.id);
+    if (existing) {
+      if (existing.seriesId !== batch.seriesId || existing.scheduleEntryId !== batch.scheduleEntryId || existing.dayOrdinal !== batch.dayOrdinal || JSON.stringify(existing.sourceTaskset) !== JSON.stringify(batch.sourceTaskset) || batch.revision !== existing.revision + 1) {
+        if (JSON.stringify(existing) === JSON.stringify(batch)) return existing;
+        throw new Error("A daily learning batch update must preserve its intake identity and use the next revision.");
+      }
+    }
+    await this.upsertPayload(
+      `INSERT INTO continual_learning_daily_batches
+        (id, series_id, schedule_entry_id, day_ordinal, status, revision, payload, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET status = excluded.status, revision = excluded.revision, payload = excluded.payload, updated_at = excluded.updated_at`,
+      [batch.id, batch.seriesId, batch.scheduleEntryId, batch.dayOrdinal, batch.status, batch.revision, JSON.stringify(batch), batch.createdAt, batch.updatedAt]
+    );
+    return batch;
+  }
+  async getContinualLearningDailyBatch(id) {
+    return this.getParsedPayload("SELECT payload FROM continual_learning_daily_batches WHERE id = ?", [id], ContinualLearningDailyBatchSchema.parse);
+  }
+  async listContinualLearningDailyBatches(input = {}) {
+    return input.seriesId ? this.listParsedPayloads("SELECT payload FROM continual_learning_daily_batches WHERE series_id = ? ORDER BY day_ordinal ASC", [input.seriesId], ContinualLearningDailyBatchSchema.parse) : this.listParsedPayloads("SELECT payload FROM continual_learning_daily_batches ORDER BY series_id, day_ordinal ASC", [], ContinualLearningDailyBatchSchema.parse);
+  }
+  async saveContinualBenchIssueReview(reviewInput) {
+    const review = ContinualBenchIssueReviewSchema.parse(reviewInput);
+    const existing = await this.getContinualBenchIssueReview(review.id);
+    if (existing && (existing.seriesId !== review.seriesId || existing.passLabel !== review.passLabel || existing.packet.contentHash !== review.packet.contentHash || review.revision !== existing.revision + 1)) {
+      if (JSON.stringify(existing) === JSON.stringify(review)) return existing;
+      throw new Error("A Continual Support review update must preserve its sealed packet and use the next revision.");
+    }
+    await this.upsertPayload(
+      `INSERT INTO continual_bench_issue_reviews (id, series_id, pass_label, status, revision, payload, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET status = excluded.status, revision = excluded.revision, payload = excluded.payload, updated_at = excluded.updated_at`,
+      [review.id, review.seriesId, review.passLabel, review.status, review.revision, JSON.stringify(review), review.createdAt, review.updatedAt]
+    );
+    return review;
+  }
+  async getContinualBenchIssueReview(id) {
+    return this.getParsedPayload("SELECT payload FROM continual_bench_issue_reviews WHERE id = ?", [id], ContinualBenchIssueReviewSchema.parse);
+  }
+  async listContinualBenchIssueReviews(input = {}) {
+    return input.seriesId ? this.listParsedPayloads("SELECT payload FROM continual_bench_issue_reviews WHERE series_id = ? ORDER BY updated_at DESC", [input.seriesId], ContinualBenchIssueReviewSchema.parse) : this.listParsedPayloads("SELECT payload FROM continual_bench_issue_reviews ORDER BY updated_at DESC", [], ContinualBenchIssueReviewSchema.parse);
+  }
+};
+
 // ../server/src/store/store-datasets.ts
-var SqliteDatasetStore = class extends SqliteTrainingModelStore {
+var SqliteDatasetStore = class extends SqliteContinualBenchReviewStore {
   async listDatasetCatalogTasksets(profileId) {
     await this.ready;
     await this.writeQueue;
@@ -6412,6 +6926,91 @@ var SqliteTasksetDraftStore = class extends SqlitePreferenceComparisonStore {
     await this.savePointer(pointer);
     return persistedDraft;
   }
+  async importTasksetDraftPackage(input) {
+    const sourcePath = path6.resolve(input.packagePath);
+    const sourceStats = await stat(sourcePath);
+    const sourceDirectory = sourceStats.isDirectory() ? sourcePath : path6.dirname(sourcePath);
+    await assertRegularPackageTree(sourceDirectory);
+    const sourceHash = await hashTasksetDraftPackage(sourceDirectory);
+    const sourceDraft = await readTasksetDraftPackage(sourceDirectory);
+    const existing = await this.getTasksetDraft(sourceDraft.id);
+    if (existing) {
+      const imported = existing.metadata.importedTasksetPackage;
+      if (imported && typeof imported === "object" && !Array.isArray(imported) && imported.packageHash === sourceHash && existing.profileId === input.profileId) {
+        return existing;
+      }
+      throw new Error(
+        `Taskset draft ${sourceDraft.id} already exists. Import a package with a distinct Taskset id.`
+      );
+    }
+    const importedDraft = TasksetDraftSchema.parse({
+      ...sourceDraft,
+      profileId: input.profileId,
+      status: "draft",
+      revision: 1,
+      publishedTasksetRef: null,
+      metadata: {
+        ...sourceDraft.metadata,
+        importedTasksetPackage: {
+          packageHash: sourceHash,
+          importedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const workspacePath = this.workspacePath(importedDraft.id);
+    const temporaryPath = `${workspacePath}.import-${process.pid}-${Date.now()}`;
+    await mkdir3(path6.dirname(workspacePath), { recursive: true });
+    try {
+      await cp(sourceDirectory, temporaryPath, {
+        recursive: true,
+        errorOnExist: true,
+        force: false,
+        preserveTimestamps: true
+      });
+      await writeTasksetDraftPackage(importedDraft, temporaryPath);
+      await rename(temporaryPath, workspacePath);
+    } catch (error) {
+      await rm(temporaryPath, { recursive: true, force: true });
+      throw error;
+    }
+    const pointer = TasksetDraftPointerSchema.parse({
+      schemaVersion: "openpond.tasksetDraftPointer.v1",
+      id: importedDraft.id,
+      profileId: importedDraft.profileId,
+      status: importedDraft.status,
+      revision: importedDraft.revision,
+      workspacePath,
+      packageHash: await hashTasksetDraftPackage(workspacePath),
+      publishedTasksetRef: importedDraft.publishedTasksetRef,
+      createdAt: importedDraft.createdAt,
+      updatedAt: importedDraft.updatedAt
+    });
+    await this.savePointer(pointer);
+    return importedDraft;
+  }
+  async materializePublishedTasksetPackage(input) {
+    const workspace = await this.getTasksetDraftWorkspace(input.draftId);
+    if (!workspace) {
+      throw new Error(`Taskset draft ${input.draftId} workspace was not found.`);
+    }
+    await assertRegularPackageTree(workspace.workspacePath);
+    const tasksetRoot = path6.join(
+      path6.dirname(this.storePath),
+      "training",
+      "tasksets",
+      input.taskset.id
+    );
+    await mkdir3(tasksetRoot, { recursive: true });
+    await cp(workspace.workspacePath, tasksetRoot, {
+      recursive: true,
+      force: true,
+      preserveTimestamps: true
+    });
+    await buildTaskset(input.taskset, tasksetRoot);
+    await verifyPublishedTasksetAssets(tasksetRoot, input.taskset);
+    return tasksetRoot;
+  }
   async getTasksetDraft(id) {
     const stored = await this.getParsedPayload(
       "SELECT payload FROM taskset_drafts WHERE id = ?",
@@ -6447,7 +7046,24 @@ var SqliteTasksetDraftStore = class extends SqlitePreferenceComparisonStore {
   }
   async deleteTasksetDraft(id) {
     await this.ready;
-    const write = this.writeQueue.then(() => this.run("DELETE FROM taskset_drafts WHERE id = ?", [id]));
+    const workspacePath = this.workspacePath(id);
+    const recoverablePath = `${workspacePath}.delete-${randomUUID2()}`;
+    let movedWorkspace = false;
+    try {
+      await rename(workspacePath, recoverablePath);
+      movedWorkspace = true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const write = this.writeQueue.then(async () => {
+      try {
+        await this.run("DELETE FROM taskset_drafts WHERE id = ?", [id]);
+      } catch (error) {
+        if (movedWorkspace) await rename(recoverablePath, workspacePath).catch(() => void 0);
+        throw error;
+      }
+      if (movedWorkspace) await rm(recoverablePath, { recursive: true, force: true });
+    });
     this.writeQueue = write.catch(() => void 0);
     await write;
   }
@@ -6509,6 +7125,41 @@ var SqliteTasksetDraftStore = class extends SqlitePreferenceComparisonStore {
     );
   }
 };
+async function assertRegularPackageTree(directory) {
+  const entries = await readdir2(directory, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path6.join(directory, entry.name);
+    if (entry.isSymbolicLink()) {
+      throw new Error(`Taskset packages cannot contain symbolic links: ${entryPath}`);
+    }
+    if (entry.isDirectory()) {
+      await assertRegularPackageTree(entryPath);
+      continue;
+    }
+    if (!entry.isFile()) {
+      throw new Error(`Taskset packages may contain only files and directories: ${entryPath}`);
+    }
+  }
+}
+async function verifyPublishedTasksetAssets(tasksetRoot, taskset) {
+  const assetRoot = path6.resolve(tasksetRoot, "assets");
+  for (const task of taskset.tasks) {
+    for (const asset3 of task.assets ?? []) {
+      const assetPath = path6.resolve(tasksetRoot, asset3.artifactRef);
+      if (assetPath === assetRoot || !assetPath.startsWith(`${assetRoot}${path6.sep}`)) {
+        throw new Error(`Taskset asset ${asset3.id} escapes the package assets directory.`);
+      }
+      const status = await lstat(assetPath);
+      if (!status.isFile() || status.isSymbolicLink()) {
+        throw new Error(`Taskset asset ${asset3.id} is not a regular file.`);
+      }
+      const bytes = await readFile3(assetPath);
+      if (bytes.byteLength !== asset3.sizeBytes || sha256(bytes) !== asset3.sha256) {
+        throw new Error(`Taskset asset ${asset3.id} does not match its immutable manifest.`);
+      }
+    }
+  }
+}
 
 // ../server/src/store/store-training-search.ts
 function trainingChatSearchResult(query, offset, limit, total, rows, indexedChats, totalChats) {
@@ -7088,6 +7739,10 @@ var SqliteTrainingStore = class extends SqliteTasksetDraftStore {
   }
   async saveTrainingPlan(planInput) {
     const plan2 = TrainingPlanSchema.parse(planInput);
+    const existing = await this.getTrainingPlan(plan2.id);
+    if (existing && existing.contentHash !== plan2.contentHash) {
+      throw new Error(`Training Plan ${plan2.id} is immutable and already has different content.`);
+    }
     await this.upsertPayload(
       `INSERT INTO training_plans (id, taskset_id, destination_id, payload, created_at) VALUES (?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET taskset_id = excluded.taskset_id, destination_id = excluded.destination_id, payload = excluded.payload`,
@@ -8885,7 +9540,7 @@ async function createLocalHarnessWorkspaceFromInitializer(input) {
   const paths = localHarnessWorkspacePaths(input.storeDir, input.id);
   const parent = path7.dirname(paths.root);
   await fs4.mkdir(parent, { recursive: true });
-  const temporaryRoot = path7.join(parent, `.${path7.basename(paths.root)}.creating-${randomUUID2()}`);
+  const temporaryRoot = path7.join(parent, `.${path7.basename(paths.root)}.creating-${randomUUID3()}`);
   const temporarySource = path7.join(temporaryRoot, "source");
   try {
     await input.initializeSource(temporarySource);
@@ -9032,7 +9687,7 @@ async function materializeLocalHarnessRelease(input) {
   const releasesRoot = path7.join(input.storeDir, "harnesses", "releases");
   const destination = path7.join(releasesRoot, input.compiled.harnessRelease.contentHash);
   await fs4.mkdir(releasesRoot, { recursive: true });
-  const temporary = path7.join(releasesRoot, `.${input.compiled.harnessRelease.contentHash}.materializing-${randomUUID2()}`);
+  const temporary = path7.join(releasesRoot, `.${input.compiled.harnessRelease.contentHash}.materializing-${randomUUID3()}`);
   try {
     await fs4.mkdir(path7.join(temporary, "source"), { recursive: true });
     for (const file of input.compiled.sourceFiles) {
@@ -9404,7 +10059,7 @@ function safeSegment(value) {
 }
 
 // ../server/src/harness/local-harness-refiner.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { promises as fs5 } from "node:fs";
 import { stripTypeScriptTypes } from "node:module";
 import path8 from "node:path";
@@ -9452,7 +10107,7 @@ async function applyLocalHarnessRefinerProposal(input) {
       `Harness source is ${current.sourceRevision}; workspace expects ${workspace.sourceRevision}. Record or revert the source change before refinement.`
     );
   }
-  const candidateSource = path8.join(paths.root, `.source-candidate-${randomUUID3()}`);
+  const candidateSource = path8.join(paths.root, `.source-candidate-${randomUUID4()}`);
   await fs5.cp(paths.source, candidateSource, {
     recursive: true,
     force: false,
@@ -9497,7 +10152,7 @@ async function applyLocalHarnessRefinerProposal(input) {
         now: timestamp
       });
     }
-    const backupSource = path8.join(paths.root, `.source-backup-${randomUUID3()}`);
+    const backupSource = path8.join(paths.root, `.source-backup-${randomUUID4()}`);
     const journalPath = path8.join(paths.root, "source-swap.json");
     await writeSwapJournal(journalPath, {
       schemaVersion: "openpond.localHarnessSourceSwap.v1",
@@ -9572,7 +10227,7 @@ async function rollbackLocalHarnessWorkspaceRelease(input) {
   if (current.sourceRevision !== workspace.sourceRevision) {
     throw new Error("Harness source changed before rollback.");
   }
-  const candidateSource = path8.join(paths.root, `.source-rollback-${randomUUID3()}`);
+  const candidateSource = path8.join(paths.root, `.source-rollback-${randomUUID4()}`);
   await fs5.cp(path8.join(target.bundlePath, "source"), candidateSource, {
     recursive: true,
     force: false,
@@ -9588,7 +10243,7 @@ async function rollbackLocalHarnessWorkspaceRelease(input) {
       throw new Error("Harness rollback bundle does not reproduce its registered source revision.");
     }
     const timestamp = (input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()))();
-    const backupSource = path8.join(paths.root, `.source-backup-${randomUUID3()}`);
+    const backupSource = path8.join(paths.root, `.source-backup-${randomUUID4()}`);
     const journalPath = path8.join(paths.root, "source-swap.json");
     await writeSwapJournal(journalPath, {
       schemaVersion: "openpond.localHarnessSourceSwap.v1",
@@ -9647,7 +10302,7 @@ async function validateLocalHarnessRefinerProposal(input) {
       "Refiner proposal source revision no longer matches the Local Harness workspace."
     );
   }
-  const candidateSource = path8.join(paths.root, `.validation-candidate-${randomUUID3()}`);
+  const candidateSource = path8.join(paths.root, `.validation-candidate-${randomUUID4()}`);
   await fs5.cp(paths.source, candidateSource, {
     recursive: true,
     force: false,
@@ -9999,7 +10654,7 @@ function containedPath(root, relativePath) {
   return target;
 }
 async function writeSwapJournal(filePath, value) {
-  const temporary = `${filePath}.${randomUUID3()}.tmp`;
+  const temporary = `${filePath}.${randomUUID4()}.tmp`;
   await fs5.writeFile(temporary, `${JSON.stringify(value, null, 2)}
 `, { flag: "wx" });
   await fs5.rename(temporary, filePath);
@@ -11530,7 +12185,7 @@ async function loadRefinerReleaseContext(input) {
 }
 
 // ../server/src/refiner/refiner-profile-service.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { promises as fs8 } from "node:fs";
 import path12 from "node:path";
 var CORE_PROMPT_IDENTITY = "OpenPond Refiner Core: evidence admission, privacy, ownership, validation, and immutable activation boundaries.";
@@ -11691,7 +12346,7 @@ async function transition2(paths, release, input) {
   const releaseRef = immutableRef(release);
   const receiptWithoutHash = {
     schemaVersion: "openpond.refinerTransitionReceipt.v1",
-    id: `refiner-transition-${randomUUID4()}`,
+    id: `refiner-transition-${randomUUID5()}`,
     operation: input.operation,
     bindingChanged: input.bindingChanged,
     previousRelease: previous?.release ?? null,
@@ -11746,7 +12401,7 @@ async function exists(filePath) {
 async function atomicWrite(filePath, contents, preserveExisting = false) {
   await fs8.mkdir(path12.dirname(filePath), { recursive: true, mode: 448 });
   if (preserveExisting && await exists(filePath)) return;
-  const temporaryPath = `${filePath}.${randomUUID4()}.tmp`;
+  const temporaryPath = `${filePath}.${randomUUID5()}.tmp`;
   await fs8.writeFile(temporaryPath, contents, { encoding: "utf8", mode: 384 });
   await fs8.rename(temporaryPath, filePath);
 }
@@ -14066,7 +14721,7 @@ function expectedMemoryRevision2(proposal, key) {
 }
 
 // ../server/src/runtime/model-usage-recorder.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 
 // ../server/src/openpond/openai-compatible-provider.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -14603,17 +15258,19 @@ async function* streamOpenAiSubscriptionResponses(input) {
     saveChatGptSubscriptionCredential: input.saveChatGptSubscriptionCredential
   });
   if (!credential.accessToken) throw new Error("OpenAI ChatGPT subscription credential has no access token.");
+  const promptCacheKey = normalizedPromptCacheKey(input.promptCacheKey);
   const requestSignal = createProviderRequestSignal(input.signal, input.requestTimeoutMs);
   try {
     const response = await fetch(OPENAI_CODEX_RESPONSES_ENDPOINT, {
       method: "POST",
-      headers: subscriptionHeaders(credential, input.requestId),
+      headers: subscriptionHeaders(credential, promptCacheKey ?? input.requestId),
       body: JSON.stringify(buildResponsesBody({
         model: input.provider.model,
         messages: input.messages,
         tools: input.tools,
         toolChoice: input.toolChoice,
-        reasoningEffort: input.reasoningEffort
+        reasoningEffort: input.reasoningEffort,
+        promptCacheKey
       })),
       signal: requestSignal.signal
     });
@@ -14733,6 +15390,7 @@ function buildResponsesBody(input) {
     store: false
   };
   if (projected.instructions) body.instructions = projected.instructions;
+  if (input.promptCacheKey) body.prompt_cache_key = input.promptCacheKey;
   body.reasoning = {
     ...input.reasoningEffort ? { effort: input.reasoningEffort } : {},
     summary: "auto"
@@ -14746,6 +15404,11 @@ function buildResponsesBody(input) {
   if (toolChoice !== void 0) body.tool_choice = toolChoice;
   return body;
 }
+function normalizedPromptCacheKey(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length <= 64 ? trimmed : createHash3("sha256").update(trimmed).digest("hex");
+}
 function responsesInputFromMessages(messages) {
   const instructions = [];
   const input = [];
@@ -15430,7 +16093,7 @@ function createProviderRequestUsageRecord(input) {
   const completedAt = input.completedAt;
   const errorMessage4 = input.error ? textFromUnknown(input.error) || null : null;
   return {
-    id: `usage_${randomUUID5()}`,
+    id: `usage_${randomUUID6()}`,
     requestId: input.requestId,
     requestOrdinal: input.requestOrdinal,
     sessionId: input.session.id,
@@ -16060,7 +16723,7 @@ import path15 from "node:path";
 
 // ../server/src/runtime/bundled-authoring-skills.ts
 import { createHash as createHash4 } from "node:crypto";
-import { access as access2, readFile as readFile3 } from "node:fs/promises";
+import { access as access2, readFile as readFile4 } from "node:fs/promises";
 import path14 from "node:path";
 import { fileURLToPath } from "node:url";
 var BUNDLED_AUTHORING_SKILL_NAMES = [
@@ -16125,8 +16788,8 @@ async function readBundledAuthoringProfileSkill(name, repoRoot = process.cwd())
 async function loadBundledAuthoringSkillBundle(name, repoRoot = process.cwd()) {
   const root = await resolveBundledAuthoringSkillRoot(name, repoRoot);
   const [skill, ...references] = await Promise.all([
-    readFile3(path14.join(root, "SKILL.md"), "utf8"),
-    ...REFERENCE_FILES[name].map((relativePath) => readFile3(path14.join(root, relativePath), "utf8"))
+    readFile4(path14.join(root, "SKILL.md"), "utf8"),
+    ...REFERENCE_FILES[name].map((relativePath) => readFile4(path14.join(root, relativePath), "utf8"))
   ]);
   return [
     skill.trim(),
@@ -16489,7 +17152,7 @@ function containedSourcePath2(sourceRoot, relativePath) {
 // ../server/src/openpond/command-access.ts
 var import_shell_quote = __toESM(require_shell_quote(), 1);
 import { spawn } from "node:child_process";
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import path16 from "node:path";
 
 // ../server/src/workspace/workspace-execution-target.ts
@@ -16660,7 +17323,7 @@ function createOpenPondCommandAccessService(deps) {
   }
   async function requestCommandApproval(input) {
     const approval = {
-      id: `approval_${randomUUID6()}`,
+      id: `approval_${randomUUID7()}`,
       sessionId: input.input.session.id,
       turnId: input.input.turnId ?? null,
       providerRequestId: input.input.providerRequestId ?? input.input.turnId ?? input.input.session.id,
@@ -17183,6 +17846,13 @@ function errorMessage(error) {
 import { promises as fs13 } from "node:fs";
 import path20 from "node:path";
 
+// ../server/src/work/managed-local-work.ts
+function isManagedLocalWorkSession(session) {
+  return Boolean(
+    session.experience === "work" && !session.workspaceKind && !session.localProjectId && !session.cloudProjectId && session.metadata?.workspaceTarget === "local" && session.cwd
+  );
+}
+
 // ../server/src/openpond/context-usage.ts
 var ESTIMATED_CHARS_PER_TOKEN = 4;
 var DEFAULT_HOSTED_CONTEXT_TOKENS = 128e3;
@@ -18137,8 +18807,8 @@ function buildRepositoryInstructionContext(resolution) {
 async function canonicalDirectory(inputPath) {
   try {
     const resolved = await fs12.realpath(path19.resolve(inputPath));
-    const stat = await fs12.stat(resolved);
-    return stat.isDirectory() ? resolved : null;
+    const stat2 = await fs12.stat(resolved);
+    return stat2.isDirectory() ? resolved : null;
   } catch {
     return null;
   }
@@ -18188,14 +18858,14 @@ async function readInstructionCandidate(input) {
     };
   }
   try {
-    const stat = await fs12.stat(realPath);
-    if (!stat.isFile()) {
+    const stat2 = await fs12.stat(realPath);
+    if (!stat2.isFile()) {
       return {
         status: "rejected",
         diagnostic: `Skipped repository instruction path that is not a file: ${candidatePath}`
       };
     }
-    if (stat.size > MAX_REPOSITORY_INSTRUCTION_FILE_BYTES) {
+    if (stat2.size > MAX_REPOSITORY_INSTRUCTION_FILE_BYTES) {
       return {
         status: "rejected",
         diagnostic: `Skipped repository instruction file larger than ${MAX_REPOSITORY_INSTRUCTION_FILE_BYTES} bytes: ${candidatePath}`
@@ -18227,7 +18897,12 @@ function isWithinDirectory(rootPath, candidatePath) {
 }
 
 // ../server/src/runtime/experience-policy.ts
-var CHAT_MODEL_TOOLS = /* @__PURE__ */ new Set(["view_image", "web_fetch", "web_search"]);
+var CHAT_MODEL_TOOLS = /* @__PURE__ */ new Set([
+  "schedule_work",
+  "view_image",
+  "web_fetch",
+  "web_search"
+]);
 var WORK_MODEL_TOOLS = /* @__PURE__ */ new Set([
   "ask_user",
   "connected_app_read",
@@ -18409,7 +19084,7 @@ function createHostedTurnHelpers(deps) {
       }
       repositoryInstructionContext = buildRepositoryInstructionContext(resolution);
     }
-    const workspaceContext = experience === "chat" ? buildChatExperienceContext() : experience === "work" && !repositoryWork ? buildWorkExperienceContext(session) : session.workspaceKind === "local_project" ? await looksLikeSandboxTemplateRepo(session.cwd) ? buildLocalSandboxTemplateTurnContext(
+    const workspaceContext = experience === "chat" ? buildChatExperienceContext() : experience === "work" && !repositoryWork ? buildWorkExperienceContext(session) : isManagedLocalWorkSession(session) ? buildManagedLocalWorkTurnContext(session.cwd) : session.workspaceKind === "local_project" ? await looksLikeSandboxTemplateRepo(session.cwd) ? buildLocalSandboxTemplateTurnContext(
       session.cwd,
       toolInstructionMode
     ) : buildLocalProjectTurnContext(session.cwd, toolInstructionMode) : session.workspaceKind === "sandbox" || session.workspaceKind === "sandbox_template" ? isHybridSession ? buildHybridSandboxTurnContext(
@@ -18513,6 +19188,7 @@ function buildOpenPondCapabilityIndexContext(input = {}) {
     ] : [],
     "- web_fetch: fetch and read a known HTTP(S) URL when the user provides a link or exact page; use web_search for discovery by query.",
     "- web_search: search current or external information when web search is available and the answer depends on current facts.",
+    "- schedule_work: create a durable one-time or recurring workflow attached to the current chat when the user asks to schedule work. Resolve the exact cadence, local date/time, and timezone, then call schedule_work; future runs and their output return to the attached chat. This is an app-native tool, not a profile skill.",
     "- action_run: search and run scoped project or profile actions from the allowed action catalog.",
     "- profile_skill: load existing profile skills for reusable instruction workflows, not app-native controls or permissions.",
     "- Capability names are not slash commands. Use available native tools or server-confirmed workflow state, and do not claim a workflow started unless server state confirms it."
@@ -18656,6 +19332,16 @@ function buildWorkExperienceContext(session) {
     "- Repository, git, interactive terminal, source-promotion, and deployment capabilities require repository-aware Work and are not available in this projectless run."
   ].join("\n");
 }
+function buildManagedLocalWorkTurnContext(workspacePath) {
+  return [
+    "Local Work experience:",
+    workspacePath ? `- Managed task workspace: ${workspacePath}.` : null,
+    "- Work directly in this app-managed task directory. It is not a user-selected software repository.",
+    "- Keep scratch files organized, and do not read or write outside this task directory unless the user explicitly asks.",
+    "- In the final response, link every finished file the user should keep or download. Linked files are validated and copied into durable Outputs storage at turn completion.",
+    "- Do not label a file as downloadable unless it exists in this task directory and is ready for review."
+  ].filter(Boolean).join("\n");
+}
 function buildLocalProjectTurnContext(workspacePath, toolInstructionMode) {
   if (toolInstructionMode !== "full_text_fallback") {
     return [
@@ -22707,7 +23393,7 @@ function hostedWebBaseUrl(env = process.env) {
 }
 
 // ../server/src/api/server-payload-helpers.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 
 // ../server/src/openpond/organizations.ts
 var DEFAULT_OPENPOND_API_BASE_URL3 = "https://api.openpond.ai";
@@ -22951,25 +23637,25 @@ async function selectLocalProjectSourceFiles(project) {
       continue;
     }
     try {
-      const stat = await fs14.lstat(absolutePath);
-      if (!stat.isFile()) {
+      const stat2 = await fs14.lstat(absolutePath);
+      if (!stat2.isFile()) {
         skipped.push({ path: normalizedPath, reason: "not_file" });
         continue;
       }
-      if (stat.size > MAX_SOURCE_UPLOAD_FILE_BYTES) {
-        skipped.push({ path: normalizedPath, reason: "too_large", sizeBytes: stat.size });
+      if (stat2.size > MAX_SOURCE_UPLOAD_FILE_BYTES) {
+        skipped.push({ path: normalizedPath, reason: "too_large", sizeBytes: stat2.size });
         continue;
       }
-      if (totalBytes + stat.size > MAX_SOURCE_UPLOAD_TOTAL_BYTES) {
-        skipped.push({ path: normalizedPath, reason: "total_limit", sizeBytes: stat.size });
+      if (totalBytes + stat2.size > MAX_SOURCE_UPLOAD_TOTAL_BYTES) {
+        skipped.push({ path: normalizedPath, reason: "total_limit", sizeBytes: stat2.size });
         continue;
       }
       files.push({
         path: normalizedPath,
         absolutePath,
-        sizeBytes: stat.size
+        sizeBytes: stat2.size
       });
-      totalBytes += stat.size;
+      totalBytes += stat2.size;
     } catch {
       skipped.push({ path: normalizedPath, reason: "read_error" });
     }
@@ -23438,7 +24124,7 @@ function codexHistoryThreadReadOptions(requestUrl) {
   };
 }
 function nextCodexHistoryTurnId(sessionId) {
-  return `${sessionId}_turn_attachment_${randomUUID7()}`;
+  return `${sessionId}_turn_attachment_${randomUUID8()}`;
 }
 function positiveIntegerParam(value) {
   if (!value) return void 0;
@@ -24707,7 +25393,7 @@ function stringValue4(value) {
 }
 
 // ../server/src/runtime/background-worker-queue.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 var MAX_RETAINED_RECEIPTS = 200;
 function createBackgroundWorkerQueue(options) {
   const maxRetainedReceipts = options.maxRetainedReceipts ?? MAX_RETAINED_RECEIPTS;
@@ -24716,7 +25402,7 @@ function createBackgroundWorkerQueue(options) {
   let tail = Promise.resolve();
   function enqueue(job, work) {
     const receipt = {
-      id: randomUUID8(),
+      id: randomUUID9(),
       queueId: options.queueId,
       label: job.label,
       enqueuedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -24783,12 +25469,17 @@ function createServerWorkQueues(logger) {
     queueId: "local-agent-schedule",
     logger
   });
+  const chatWorkflow = createBackgroundWorkerQueue({
+    queueId: "chat-workflow",
+    logger
+  });
   const subagent = createBackgroundWorkerQueue({ queueId: "subagent", logger });
   const subagentLifecycle = createBackgroundWorkerQueue({ queueId: "subagent-lifecycle", logger });
   const byId = {
     "turn-follow-up": turnFollowUp,
     "checkpoint-diff": checkpointDiff,
     "provider-runtime-ingestion": providerRuntimeIngestion,
+    "chat-workflow": chatWorkflow,
     "local-agent-schedule": localAgentSchedule,
     subagent,
     "subagent-lifecycle": subagentLifecycle
@@ -24797,6 +25488,7 @@ function createServerWorkQueues(logger) {
     turnFollowUp,
     checkpointDiff,
     providerRuntimeIngestion,
+    chatWorkflow,
     localAgentSchedule,
     subagent,
     subagentLifecycle,
@@ -24880,8 +25572,8 @@ async function nearestExistingParent(targetPath, root) {
   while (current !== path23.dirname(current)) {
     if (current === resolvedRoot || current.startsWith(`${resolvedRoot}${path23.sep}`)) {
       try {
-        const stat = await fs16.lstat(current);
-        if (stat.isDirectory()) return current;
+        const stat2 = await fs16.lstat(current);
+        if (stat2.isDirectory()) return current;
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -24927,8 +25619,8 @@ async function readWorkspaceFiles(repoPath, paths) {
   const files = [];
   for (const filePath of paths) {
     const { relativePath, targetPath } = await resolveForRead(repoPath, filePath);
-    const stat = await fs16.lstat(targetPath);
-    if (!stat.isFile()) throw new Error(`Not a file: ${relativePath}`);
+    const stat2 = await fs16.lstat(targetPath);
+    if (!stat2.isFile()) throw new Error(`Not a file: ${relativePath}`);
     const content = await fs16.readFile(targetPath, "utf8");
     files.push({
       path: relativePath,
@@ -24981,8 +25673,8 @@ async function editWorkspaceFile(repoPath, filePath, oldText, newText, options =
 }
 async function deleteWorkspaceFile(repoPath, filePath) {
   const { relativePath, targetPath } = await resolveForRead(repoPath, filePath);
-  const stat = await fs16.lstat(targetPath);
-  if (!stat.isFile()) throw new Error(`Not a file: ${relativePath}`);
+  const stat2 = await fs16.lstat(targetPath);
+  if (!stat2.isFile()) throw new Error(`Not a file: ${relativePath}`);
   await fs16.unlink(targetPath);
   return { path: relativePath };
 }
@@ -24994,8 +25686,8 @@ import path24 from "node:path";
 async function readExistingFile(repoPath, filePath) {
   const { targetPath } = await resolveForPreview(repoPath, filePath);
   try {
-    const stat = await fs17.lstat(targetPath);
-    if (!stat.isFile()) throw new Error(`Not a file: ${filePath}`);
+    const stat2 = await fs17.lstat(targetPath);
+    if (!stat2.isFile()) throw new Error(`Not a file: ${filePath}`);
     return await fs17.readFile(targetPath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
@@ -25083,8 +25775,8 @@ async function previewWorkspaceEditFile(repoPath, filePath, oldText, newText, op
 }
 async function previewWorkspaceDeleteFile(repoPath, filePath) {
   const { relativePath, targetPath } = await resolveForRead(repoPath, filePath);
-  const stat = await fs17.lstat(targetPath);
-  if (!stat.isFile()) throw new Error(`Not a file: ${relativePath}`);
+  const stat2 = await fs17.lstat(targetPath);
+  if (!stat2.isFile()) throw new Error(`Not a file: ${relativePath}`);
   const file = await previewFileChange(repoPath, relativePath, null);
   return {
     filesChanged: 1,
@@ -25151,9 +25843,9 @@ async function ensureWorkspaceGitRepository(repoPath, branch = "main") {
     if (init.code !== 0) {
       throw new Error(init.stderr.trim() || init.stdout.trim() || "git init failed");
     }
-    const rename = await runCommand("git", ["branch", "-M", branch], repoPath);
-    if (rename.code !== 0) {
-      throw new Error(rename.stderr.trim() || rename.stdout.trim() || "git branch setup failed");
+    const rename2 = await runCommand("git", ["branch", "-M", branch], repoPath);
+    if (rename2.code !== 0) {
+      throw new Error(rename2.stderr.trim() || rename2.stdout.trim() || "git branch setup failed");
     }
   }
 }
@@ -25180,8 +25872,8 @@ async function lastFetchAt(repoPath) {
   const fetchHead = await runCommand("git", ["rev-parse", "--git-path", "FETCH_HEAD"], repoPath);
   const fetchHeadPath = fetchHead.code === 0 && fetchHead.stdout.trim() ? path25.resolve(repoPath, fetchHead.stdout.trim()) : path25.join(repoPath, ".git", "FETCH_HEAD");
   try {
-    const stat = await fs18.stat(fetchHeadPath);
-    return stat.mtime.toISOString();
+    const stat2 = await fs18.stat(fetchHeadPath);
+    return stat2.mtime.toISOString();
   } catch {
     return null;
   }
@@ -25641,10 +26333,10 @@ async function readWorkspaceSearchText(repoPath, filePath) {
   if (BINARY_EXTENSIONS.has(path26.extname(filePath).toLowerCase())) return null;
   try {
     const { targetPath } = await resolveForRead(repoPath, filePath);
-    const stat = await fs19.lstat(targetPath);
-    if (!stat.isFile()) return null;
-    const text = await readTextSample(targetPath, stat.size);
-    return text.includes("\0") ? null : { text, truncated: stat.size > WORKSPACE_SEARCH_MAX_BYTES };
+    const stat2 = await fs19.lstat(targetPath);
+    if (!stat2.isFile()) return null;
+    const text = await readTextSample(targetPath, stat2.size);
+    return text.includes("\0") ? null : { text, truncated: stat2.size > WORKSPACE_SEARCH_MAX_BYTES };
   } catch {
     return null;
   }
@@ -26197,15 +26889,15 @@ function parseResourceRef(ref) {
 async function readWorkspaceFileResource(repoPath, identifier, request) {
   const filePath = normalizeRequiredWorkspacePath(identifier);
   const targetPath = await resolveWorkspacePath(repoPath, filePath);
-  const stat = await fs20.lstat(targetPath);
-  if (!stat.isFile()) throw new Error(`Not a file resource: ${filePath}`);
+  const stat2 = await fs20.lstat(targetPath);
+  if (!stat2.isFile()) throw new Error(`Not a file resource: ${filePath}`);
   const contentType = contentTypeForPath(filePath);
   const maxBytes = normalizeMaxBytes(request.maxBytes);
   const binary = await isBinaryFile(targetPath, filePath);
   const metadata = {
     path: filePath,
-    sizeBytes: stat.size,
-    modifiedAt: stat.mtime.toISOString(),
+    sizeBytes: stat2.size,
+    modifiedAt: stat2.mtime.toISOString(),
     binary
   };
   if (request.mode === "metadata" || binary) {
@@ -26218,13 +26910,13 @@ async function readWorkspaceFileResource(repoPath, identifier, request) {
       relatedRefs: [],
       truncation: {
         truncated: false,
-        originalBytes: stat.size,
+        originalBytes: stat2.size,
         returnedBytes: 0,
         reason: binary ? "binary" : void 0
       }
     };
   }
-  const content = await readTextWithLimit(targetPath, stat.size, maxBytes);
+  const content = await readTextWithLimit(targetPath, stat2.size, maxBytes);
   return {
     ref: workspaceFileRef2(filePath),
     kind: "workspace.file",
@@ -26242,8 +26934,8 @@ async function readWorkspaceFileResource(repoPath, identifier, request) {
 async function readWorkspaceDirectoryResource(repoPath, identifier, request) {
   const dirPath = normalizeOptionalWorkspacePath(identifier);
   const targetPath = await resolveWorkspacePath(repoPath, dirPath);
-  const stat = await fs20.lstat(targetPath);
-  if (!stat.isDirectory()) throw new Error(`Not a directory resource: ${dirPath || "."}`);
+  const stat2 = await fs20.lstat(targetPath);
+  if (!stat2.isDirectory()) throw new Error(`Not a directory resource: ${dirPath || "."}`);
   const entries = await fs20.readdir(targetPath, { withFileTypes: true });
   const visible = entries.map((entry) => {
     const entryPath = dirPath ? `${dirPath}/${entry.name}` : entry.name;
@@ -26268,7 +26960,7 @@ async function readWorkspaceDirectoryResource(repoPath, identifier, request) {
       path: dirPath,
       entryCount: visible.length,
       entries: visible,
-      modifiedAt: stat.mtime.toISOString()
+      modifiedAt: stat2.mtime.toISOString()
     },
     relatedRefs: visible.slice(0, 50).map((entry) => entry.ref),
     truncation: content.truncation
@@ -27701,13 +28393,13 @@ function notificationMethod(name) {
 }
 
 // ../server/src/harness/local-harness-evaluation-review-model.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 function createLocalHarnessEvaluationReviewModelStream(streamOpenPondHostedChatTurn2) {
   return async function* ({ messages, signal }) {
     for await (const delta of streamOpenPondHostedChatTurn2({
       model: DEFAULT_HARNESS_REFINER_MODEL,
       messages,
-      requestId: `harness-continuous-review:${randomUUID9()}`,
+      requestId: `harness-continuous-review:${randomUUID10()}`,
       reasoningEffort: "medium",
       maxTokens: DEFAULT_EVALUATION_REVIEW_MAX_OUTPUT_TOKENS,
       signal
@@ -27956,7 +28648,7 @@ function uniqueObjects(values) {
 }
 
 // ../server/src/training/task-authoring-skill.ts
-import { access as access3, readFile as readFile4 } from "node:fs/promises";
+import { access as access3, readFile as readFile5 } from "node:fs/promises";
 import { createHash as createHash5 } from "node:crypto";
 import path29 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -27969,7 +28661,7 @@ async function loadTasksetAuthoringSkillBundle(repoRoot = process.cwd()) {
 async function loadTasksetAuthoringSkillArtifact(repoRoot = process.cwd()) {
   const skillRoot = await resolveTasksetAuthoringSkillRoot(repoRoot);
   const parsed = JSON.parse(
-    await readFile4(path29.join(skillRoot, SKILL_ARTIFACT_FILE), "utf8")
+    await readFile5(path29.join(skillRoot, SKILL_ARTIFACT_FILE), "utf8")
   );
   if (parsed.schemaVersion !== 1 || parsed.skillName !== SKILL_DIRECTORY || !parsed.artifactVersion || !parsed.bundle || !/^[a-f0-9]{64}$/.test(parsed.contentHash)) {
     throw new Error("Bundled Taskset Authoring artifact is invalid.");
@@ -28038,7 +28730,7 @@ async function resolveTasksetAuthoringSkillRoot(repoRoot = process.cwd(), execut
 }
 
 // ../server/src/training/task-creator.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import path31 from "node:path";
 
 // ../server/src/training/privacy.ts
@@ -28128,7 +28820,7 @@ import { Buffer as Buffer3 } from "node:buffer";
 import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 import { tmpdir } from "node:os";
 import readline from "node:readline";
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { promisify as promisify2 } from "node:util";
 var execFileAsync2 = promisify2(execFile2);
 var DEFAULT_MAX_MEMORY_BYTES = 256 * 1024 * 1024;
@@ -28234,7 +28926,7 @@ var PersistentPythonSandbox = class {
     if (this.closed) throw new Error("Python sandbox is closed.");
     if (Buffer.byteLength(code, "utf8") > 1e4) throw new Error("Python code exceeds the 10,000-byte limit.");
     if (signal?.aborted) throw abortError(signal);
-    const id = `python_${randomUUID10()}`;
+    const id = `python_${randomUUID11()}`;
     const result2 = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -30548,7 +31240,7 @@ function createTaskCreatorService(deps) {
         state: "failed",
         blockedReason: "OpenPond restarted during Taskset authoring. The reviewed evidence and proposal were preserved; start authoring again to continue.",
         transcript: [...snapshot.transcript, {
-          id: `task_message_${randomUUID11()}`,
+          id: `task_message_${randomUUID12()}`,
           role: "assistant",
           text: "Taskset authoring stopped when OpenPond restarted. The reviewed evidence and any completed proposal were preserved.",
           createdAt: timestamp
@@ -30567,7 +31259,7 @@ function createTaskCreatorService(deps) {
     const timestamp = now();
     const source = TrainingSourceRefSchema.parse({
       schemaVersion: "openpond.trainingSource.v1",
-      id: `training_source_${randomUUID11()}`,
+      id: `training_source_${randomUUID12()}`,
       profileId: input.profileId,
       sessionId: input.sessionId,
       turnIds,
@@ -30622,10 +31314,10 @@ function createTaskCreatorService(deps) {
     const sources = await requireSources(input.profileId, input.sourceIds);
     assertSourcesEligible(sources);
     const timestamp = now();
-    const disclosureApprovalId = input.analysisModel && sources.length ? `task_disclosure_${randomUUID11()}` : null;
+    const disclosureApprovalId = input.analysisModel && sources.length ? `task_disclosure_${randomUUID12()}` : null;
     const request = TaskCreationRequestSchema.parse({
       schemaVersion: "openpond.taskCreationRequest.v1",
-      id: `task_creation_request_${randomUUID11()}`,
+      id: `task_creation_request_${randomUUID12()}`,
       profileId: input.profileId,
       surface: input.surface,
       mode: input.mode,
@@ -30660,13 +31352,13 @@ function createTaskCreatorService(deps) {
     });
     const needsDisclosure = request.disclosure.status === "pending";
     const blockingQuestions = [
-      ...!request.objective && request.mode === "customize" ? [{ id: `task_question_${randomUUID11()}`, kind: "objective", prompt: "What repeatable capability should this Taskset teach or evaluate?", answer: null }] : [],
-      ...!sources.length && !input.buildSpecification ? [{ id: `task_question_${randomUUID11()}`, kind: "success_signal", prompt: "Add at least one successful example, correction, reviewer choice, or outcome-bearing run so the authoring model can ground this capability without fabricating demonstrations.", answer: null }] : []
+      ...!request.objective && request.mode === "customize" ? [{ id: `task_question_${randomUUID12()}`, kind: "objective", prompt: "What repeatable capability should this Taskset teach or evaluate?", answer: null }] : [],
+      ...!sources.length && !input.buildSpecification ? [{ id: `task_question_${randomUUID12()}`, kind: "success_signal", prompt: "Add at least one successful example, correction, reviewer choice, or outcome-bearing run so the authoring model can ground this capability without fabricating demonstrations.", answer: null }] : []
     ];
     const initialState = blockingQuestions.length ? "awaiting_questions" : needsDisclosure ? "awaiting_disclosure_approval" : "planning";
     let snapshot = TaskCreationSnapshotSchema.parse({
       schemaVersion: "openpond.taskCreationSnapshot.v1",
-      id: `task_creation_${randomUUID11()}`,
+      id: `task_creation_${randomUUID12()}`,
       request,
       state: initialState,
       proposal: null,
@@ -30674,7 +31366,7 @@ function createTaskCreatorService(deps) {
       disclosureApprovalId,
       materializationApprovalId: null,
       blockingQuestions,
-      transcript: [{ id: `task_message_${randomUUID11()}`, role: "user", text: request.objective ?? "Create a Taskset from the selected conversations.", createdAt: timestamp }],
+      transcript: [{ id: `task_message_${randomUUID12()}`, role: "user", text: request.objective ?? "Create a Taskset from the selected conversations.", createdAt: timestamp }],
       blockedReason: null,
       createdAt: timestamp,
       updatedAt: timestamp
@@ -30717,7 +31409,7 @@ function createTaskCreatorService(deps) {
       state: "planning",
       blockedReason: null,
       transcript: [...snapshot.transcript, {
-        id: `task_message_${randomUUID11()}`,
+        id: `task_message_${randomUUID12()}`,
         role: "user",
         text: "Retry Taskset authoring with the same approved evidence and authoring configuration.",
         createdAt: timestamp
@@ -30770,7 +31462,7 @@ function createTaskCreatorService(deps) {
       );
       applying = await persist({ ...applying, proposal, updatedAt: now() });
       const taskset = await materializeTaskset(applying, proposal, sources);
-      return persist({ ...applying, state: "ready", materializedTasksetId: taskset.id, blockedReason: null, updatedAt: now(), transcript: [...applying.transcript, { id: `task_message_${randomUUID11()}`, role: "assistant", text: `Materialized ${taskset.name} with ${taskset.tasks.length} tasks and ${taskset.graders.length} graders.`, createdAt: now() }] });
+      return persist({ ...applying, state: "ready", materializedTasksetId: taskset.id, blockedReason: null, updatedAt: now(), transcript: [...applying.transcript, { id: `task_message_${randomUUID12()}`, role: "assistant", text: `Materialized ${taskset.name} with ${taskset.tasks.length} tasks and ${taskset.graders.length} graders.`, createdAt: now() }] });
     } catch (error) {
       return persist({ ...applying, state: "failed", blockedReason: error instanceof Error ? error.message : String(error), updatedAt: now() });
     }
@@ -30782,7 +31474,7 @@ function createTaskCreatorService(deps) {
     if (!snapshot.request.analysisModel || !deps.authorProposal) throw new Error("Task Creator chat requires a configured authoring model.");
     if (["materializing", "validating", "ready", "cancelled"].includes(snapshot.state)) throw new Error(`Task Creator cannot revise a ${snapshot.state} creation.`);
     const timestamp = now();
-    const chatting = TaskCreationSnapshotSchema.parse({ ...snapshot, state: "planning", blockedReason: null, transcript: [...snapshot.transcript, { id: `task_message_${randomUUID11()}`, role: "user", text: instruction, createdAt: timestamp }], updatedAt: timestamp });
+    const chatting = TaskCreationSnapshotSchema.parse({ ...snapshot, state: "planning", blockedReason: null, transcript: [...snapshot.transcript, { id: `task_message_${randomUUID12()}`, role: "user", text: instruction, createdAt: timestamp }], updatedAt: timestamp });
     await persist(chatting);
     const sources = await requireSources(snapshot.request.profileId, snapshot.request.sourceIds);
     try {
@@ -30796,7 +31488,7 @@ function createTaskCreatorService(deps) {
       });
     }
   }
-  async function rename(id, name) {
+  async function rename2(id, name) {
     const snapshot = await requireSnapshot(id);
     if (!snapshot.proposal) throw new Error("Task Creator has no proposal to rename.");
     if (["materializing", "validating", "ready", "cancelled"].includes(snapshot.state)) throw new Error(`Task Creator cannot rename a ${snapshot.state} creation.`);
@@ -30820,7 +31512,7 @@ function createTaskCreatorService(deps) {
       ...manual ? [manual.evidence] : []
     ];
     if (snapshot.request.analysisModel) assertHostedAuthoringEvidenceBudget(evidence);
-    const proposalId = `task_proposal_${randomUUID11()}`;
+    const proposalId = `task_proposal_${randomUUID12()}`;
     const authored = snapshot.request.analysisModel && deps.authorProposal ? await deps.authorProposal({ id: proposalId, model: snapshot.request.analysisModel, reasoningEffort: snapshot.request.analysisReasoningEffort, evidence, buildIntent: snapshot.request.buildIntent, buildSpecification: snapshot.request.buildSpecification, methodHint: snapshot.request.methodHint, signal, instruction: instruction ?? snapshot.request.objective, currentProposal }) : heuristicProposal(proposalId, snapshot, effectiveSources, evidence);
     const proposal = "proposal" in authored ? authored.proposal : authored;
     const repairHistory = "proposal" in authored ? authored.repairHistory : [];
@@ -30842,8 +31534,8 @@ function createTaskCreatorService(deps) {
       proposal: reviewed,
       blockedReason: null,
       repairHistory: [...snapshot.repairHistory, ...repairHistory],
-      materializationApprovalId: `task_materialization_${randomUUID11()}`,
-      transcript: [...snapshot.transcript, { id: `task_message_${randomUUID11()}`, role: "assistant", text: `Proposed \u201C${reviewed.name}\u201D. Review what should be learned, what should remain context, and the evidence before creating a Taskset.`, createdAt: now() }],
+      materializationApprovalId: `task_materialization_${randomUUID12()}`,
+      transcript: [...snapshot.transcript, { id: `task_message_${randomUUID12()}`, role: "assistant", text: `Proposed \u201C${reviewed.name}\u201D. Review what should be learned, what should remain context, and the evidence before creating a Taskset.`, createdAt: now() }],
       updatedAt: now()
     });
   }
@@ -31002,7 +31694,7 @@ function createTaskCreatorService(deps) {
       });
     }));
   }
-  return { reconcileInterruptedCreations, addSessionSource, estimateSessionSources, start, approveDisclosure, retry, answerQuestions, approveMaterialization, chat, rename, cancel };
+  return { reconcileInterruptedCreations, addSessionSource, estimateSessionSources, start, approveDisclosure, retry, answerQuestions, approveMaterialization, chat, rename: rename2, cancel };
 }
 function assertHostedAuthoringEvidenceBudget(evidence) {
   const estimatedTokens = evidence.reduce(
@@ -31295,6 +31987,7 @@ function artifactSplit(fixture) {
 function buildTasksetReadiness(input) {
   const validation = validateTaskset(input.taskset);
   const blockers = validation.issues.filter((issue) => issue.severity === "error").map((issue) => ({ code: issue.code, message: issue.message, path: issue.path }));
+  const advisories = validation.issues.filter((issue) => issue.severity === "warning").map((issue) => ({ code: issue.code, message: issue.message, path: issue.path }));
   const authoredMethod = typeof input.taskset.metadata.trainingMethod === "string" ? input.taskset.metadata.trainingMethod : null;
   const authoredTrainingMethod = trainingPathMethod(authoredMethod);
   const requiresApprovedDemonstrations = authoredTrainingMethod === "sft";
@@ -31329,23 +32022,28 @@ function buildTasksetReadiness(input) {
   }
   const unapprovedTrainCount = artifact ? requiresApprovedDemonstrations && !artifactSignalApproved ? artifactTrainCount : 0 : unapprovedTrainTasks.length;
   if (requiresApprovedDemonstrations && unapprovedTrainCount) blockers.push({ code: "sft_demonstrations_unapproved", message: `${unapprovedTrainCount} training example${unapprovedTrainCount === 1 ? " is" : "s are"} not explicitly approved.`, path: artifact ? "metadata.approvedArtifactSignals" : "learningSignals.demonstrations" });
-  if (frozenTaskCount === 0) blockers.push({ code: "frozen_eval_missing", message: "At least one independent evaluation example is required.", path: artifact ? "datasetArtifact.splitCounts.frozen_eval" : "tasks" });
+  if (frozenTaskCount === 0) advisories.push({ code: "frozen_eval_missing", message: "At least one independent evaluation example is recommended before making quality claims.", path: artifact ? "datasetArtifact.splitCounts.frozen_eval" : "tasks" });
   const trainClusters = new Set(trainTasks.map((task) => task.clusterKey));
   const frozenClusters = new Set(frozenTasks.map((task) => task.clusterKey));
   const artifactSplitIsolation = artifact && input.taskset.metadata.splitIsolationVerified === true;
-  if (artifact ? !artifactSplitIsolation || trainTaskCount === 0 || frozenTaskCount === 0 : trainClusters.size === 0 || frozenClusters.size === 0 || [...trainClusters].some((cluster) => frozenClusters.has(cluster))) blockers.push({ code: "independent_evaluation_missing", message: "Training and evaluation must use independent source clusters.", path: artifact ? "metadata.splitIsolationVerified" : "tasks" });
+  if (artifact ? !artifactSplitIsolation || trainTaskCount === 0 || frozenTaskCount === 0 : trainClusters.size === 0 || frozenClusters.size === 0 || [...trainClusters].some((cluster) => frozenClusters.has(cluster))) advisories.push({ code: "independent_evaluation_missing", message: "Independent source clusters are recommended before using evaluation results for quality claims.", path: artifact ? "metadata.splitIsolationVerified" : "tasks" });
   if (artifact ? input.taskset.metadata.artifactRowsVerified !== true : input.taskset.tasks.some((task) => typeof task.metadata.exampleOrigin !== "string")) blockers.push({ code: "example_provenance_missing", message: "Every training and evaluation example must record whether it was extracted, corrected, synthetic, or expert-authored.", path: artifact ? "metadata.artifactRowsVerified" : "tasks.metadata.exampleOrigin" });
   const diagnosis = metadataRecord2(input.taskset.metadata.diagnosis);
-  if (!diagnosis || typeof diagnosis.summary !== "string" || !Array.isArray(diagnosis.stableBehavior)) blockers.push({ code: "capability_diagnosis_missing", message: "The Taskset must separate stable behavior from changing knowledge before training.", path: "metadata.diagnosis" });
-  if (diagnosis?.trainingEligible === false) blockers.push({ code: "training_not_recommended", message: "The capability diagnosis does not recommend storing this behavior in model weights.", path: "metadata.diagnosis.trainingEligible" });
-  if (!input.graderAudit) blockers.push({ code: "grader_audit_missing", message: "Run the positive, negative, boundary, adversarial, prompt-injection, and infrastructure grader fixtures.", path: "graderFixtures" });
-  if (input.graderAudit && input.graderAudit.tasksetHash !== input.taskset.contentHash) blockers.push({ code: "grader_audit_stale", message: "The Taskset changed after this grader audit. Run it again.", path: "graderFixtures" });
-  if (input.graderAudit && !input.graderAudit.passed) blockers.push({ code: "grader_audit_failed", message: "The evaluation grader did not pass all calibration fixtures.", path: "graderFixtures" });
-  if (input.graderAudit && !input.graderAudit.hackingChecksPassed) blockers.push({ code: "grader_hacking", message: "Grader hacking or prompt-injection checks failed.", path: "graders" });
-  if (input.graderAudit && !input.graderAudit.leakageChecksPassed) blockers.push({ code: "environment_leakage", message: "Environment or privileged-state leakage checks failed.", path: "environment" });
-  if (input.graderAudit && !input.graderAudit.infrastructureSafetyPassed) blockers.push({ code: "infrastructure_reward", message: "An infrastructure failure produced a score or eligible reward.", path: "graderFixtures" });
-  const hasRewardEligibleGrader = input.taskset.graders.some((grader) => grader.rewardEligible && (grader.kind !== "model_judge" || grader.calibrationStatus === "passed"));
-  if (requiresOnlineReward && !hasRewardEligibleGrader) blockers.push({ code: "online_reward_grader_missing", message: `${authoredTrainingMethod?.toUpperCase()} requires a calibrated reward-eligible grader.`, path: "graders" });
+  if (!diagnosis || typeof diagnosis.summary !== "string" || !Array.isArray(diagnosis.stableBehavior)) advisories.push({ code: "capability_diagnosis_missing", message: "A capability diagnosis is recommended to separate stable behavior from changing knowledge.", path: "metadata.diagnosis" });
+  if (diagnosis?.trainingEligible === false) advisories.push({ code: "training_not_recommended", message: "The capability diagnosis does not recommend storing this behavior in model weights.", path: "metadata.diagnosis.trainingEligible" });
+  const graderAuditRequired = input.taskset.graders.some(
+    (grader) => grader.rewardEligible && (grader.kind !== "model_judge" || grader.metadata.calibrationIsAdvisory !== true)
+  );
+  if (graderAuditRequired && !input.graderAudit) advisories.push({ code: "grader_audit_missing", message: "Optional grader calibration evidence has not been recorded.", path: "graderFixtures" });
+  if (graderAuditRequired && input.graderAudit && input.graderAudit.tasksetHash !== input.taskset.contentHash) advisories.push({ code: "grader_audit_stale", message: "Optional grader calibration evidence predates this immutable Taskset revision.", path: "graderFixtures" });
+  if (graderAuditRequired && input.graderAudit && !input.graderAudit.passed) advisories.push({ code: "grader_audit_failed", message: "The grader did not match every optional calibration fixture's expected outcome.", path: "graderFixtures" });
+  if (graderAuditRequired && input.graderAudit && !input.graderAudit.hackingChecksPassed) advisories.push({ code: "grader_adversarial_calibration_failed", message: "Adversarial or prompt-injection calibration fixtures did not match their expected grader outcomes.", path: "graders" });
+  if (graderAuditRequired && input.graderAudit && !input.graderAudit.leakageChecksPassed) blockers.push({ code: "environment_leakage", message: "Environment or privileged-state leakage checks failed.", path: "environment" });
+  if (graderAuditRequired && input.graderAudit && !input.graderAudit.infrastructureSafetyPassed) blockers.push({ code: "infrastructure_reward", message: "An infrastructure failure produced a score or eligible reward.", path: "graderFixtures" });
+  const hasRewardEligibleGrader = input.taskset.graders.some(
+    (grader) => grader.rewardEligible
+  );
+  if (requiresOnlineReward && !hasRewardEligibleGrader) blockers.push({ code: "online_reward_grader_missing", message: `${authoredTrainingMethod?.toUpperCase()} requires a user-selected reward-eligible grader.`, path: "graders" });
   const recommendedMethod = authoredTrainingMethod ?? (trainTaskCount > 0 && input.taskset.capabilities.compatibleMethods.includes("sft") ? "sft" : "none");
   const demonstrationRefs = input.taskset.learningSignals.demonstrations.filter((signal) => signal.approved).map((signal) => signal.id);
   const trainingPath = recommendedMethod === "none" ? null : {
@@ -31407,6 +32105,7 @@ function buildTasksetReadiness(input) {
     methodReadiness,
     compatibleDestinationClasses: ready ? recommendedMethod === "grpo" ? ["export", "custom", "hosted_managed"] : ["export", "custom"] : ["export"],
     blockers,
+    advisories,
     warnings: [
       ...validation.issues.filter((issue) => issue.severity === "warning").map((issue) => issue.message),
       ...recommendedMethod === "grpo" ? ["GRPO is readiness-compatible but not executable in the local CPU fixture."] : [],
@@ -31427,14 +32126,14 @@ function metadataStrings(value) {
 }
 
 // ../server/src/training/sandboxed-verifier.ts
-import { readFile as readFile5, realpath } from "node:fs/promises";
+import { readFile as readFile6, realpath } from "node:fs/promises";
 import path32 from "node:path";
 import vm from "node:vm";
 async function runSandboxedVerifier(input) {
   const root = await realpath(input.allowedRoot);
   const modulePath = await realpath(path32.resolve(root, input.grader.module));
   if (modulePath !== root && !modulePath.startsWith(`${root}${path32.sep}`)) throw new Error("Verifier module is outside the approved Taskset root.");
-  const source = await readFile5(modulePath, "utf8");
+  const source = await readFile6(modulePath, "utf8");
   assertSandboxableSource(source);
   const functionSource = verifierFunctionSource(source, input.grader.exportName);
   const context = vm.createContext(Object.freeze({
@@ -31673,7 +32372,7 @@ function failureClassFor(outcome) {
 
 // ../server/src/training/task-attempt-artifact-service.ts
 import path33 from "node:path";
-import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile3 } from "node:fs/promises";
 async function persistJsonTaskAttemptArtifact(input) {
   const directory = path33.join(
     input.storeDir,
@@ -31691,7 +32390,7 @@ async function persistJsonTaskAttemptArtifact(input) {
     ...input.payload
   }, null, 2)}
 `, "utf8");
-  await mkdir3(directory, { recursive: true });
+  await mkdir4(directory, { recursive: true });
   await writeFile3(file, bytes, { mode: 384 });
   return saveArtifact({
     ...input,
@@ -31706,7 +32405,7 @@ async function persistBinaryTaskAttemptArtifact(input) {
     throw new Error("Task Attempt artifact extension is invalid.");
   }
   const directory = path33.join(input.storeDir, "training", "evaluation-artifacts", input.tasksetId);
-  await mkdir3(directory, { recursive: true });
+  await mkdir4(directory, { recursive: true });
   const file = path33.join(directory, `${input.attemptId}-${safeFileLabel(input.fileLabel)}.${extension}`);
   await writeFile3(file, input.bytes, { mode: 384 });
   return saveArtifact({ ...input, file });
@@ -31717,7 +32416,7 @@ function safeFileLabel(value) {
   return normalized;
 }
 async function persistTaskAttemptOutputArtifact(input) {
-  const bytes = await readFile6(input.path);
+  const bytes = await readFile7(input.path);
   const checksum = sha256(bytes);
   if (bytes.byteLength !== input.expectedSizeBytes || checksum !== input.expectedSha256) {
     throw new Error(
@@ -32012,15 +32711,15 @@ async function discoverCommandArtifacts(result2, limit = 12) {
     );
     if (!contentType) continue;
     try {
-      const stat = await fs21.stat(resolved);
-      if (!stat.isFile()) continue;
+      const stat2 = await fs21.stat(resolved);
+      if (!stat2.isFile()) continue;
       seen.add(resolved);
       artifacts.push({
         artifactRef: resolved,
         path: resolved,
         title: path34.basename(resolved),
         contentType,
-        sizeBytes: stat.size,
+        sizeBytes: stat2.size,
         binary: true
       });
       if (artifacts.length >= limit) break;
@@ -33748,7 +34447,7 @@ function numberValue3(value) {
 }
 
 // ../server/src/openpond/work-tool-registry.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 
 // ../server/src/openpond/work-runtime-service.ts
 import { createHash as createHash7 } from "node:crypto";
@@ -34008,13 +34707,14 @@ function createWorkModelToolDefinitions(deps) {
     ...deps.createScheduledWork ? [
       {
         name: "schedule_work",
-        description: "Create durable recurring Work through the OpenPond control plane when the user directly asks to schedule the current or another task and provides an exact cadence, local date/time, and timezone. This capability does not depend on a scheduler daemon inside the sandbox. Use the conversation context to preserve the task prompt and ask only for genuinely unavailable required scheduling details. Delivery is not required: unless the user explicitly requests an external destination or format, default to managed in-app Work outputs; report-like work should create a polished PDF plus a concise in-app summary. The scheduled prompt must describe only the work to perform when the schedule fires, not the scheduling request itself.",
+        description: "Create a durable recurring workflow attached to the current chat when the user directly asks to schedule the current or another task and provides an exact cadence, local date/time, and timezone. Every scheduled run is sent through the attached chat so its output appears in that conversation. Use the conversation context to preserve the task prompt and ask only for genuinely unavailable required scheduling details. The scheduled prompt must describe only the work to perform when the schedule fires, not the scheduling request itself.",
         parameters: savedWorkScheduleParameters(),
         execute: async (context) => {
           const input = CreateHostedSavedWorkRequestSchema.parse({
             ...context.args,
             clientRequestId: `${context.turnId}:${context.callId}`,
             sourceTurnId: context.turnId,
+            targetSessionId: context.session.id,
             modelId: context.provider === "openpond" ? context.model : "openpond-chat"
           });
           const data = await deps.createScheduledWork(input);
@@ -34519,7 +35219,7 @@ function createWorkModelToolDefinitions(deps) {
         const url = validHttpUrl(context.args.url);
         const validation = Array.isArray(context.args.validation) ? context.args.validation : [];
         const identity = {
-          id: randomUUID12(),
+          id: randomUUID13(),
           title,
           sourceTaskId: context.session.id,
           sourceTurnId: context.turnId,
@@ -34743,7 +35443,7 @@ function asRecord9(value) {
 
 // ../server/src/training/taskset-work-assets.ts
 import { createHash as createHash8 } from "node:crypto";
-import { lstat, readFile as readFile7 } from "node:fs/promises";
+import { lstat as lstat2, readFile as readFile8 } from "node:fs/promises";
 import path36 from "node:path";
 var DEFAULT_MAX_WORK_INPUT_BYTES = 25e7;
 var MAX_WORK_INPUT_BYTES2 = 1e9;
@@ -34786,11 +35486,11 @@ async function resolveTasksetWorkAssets(input) {
         `Work asset ${asset3.id} must resolve inside the Taskset assets directory.`
       );
     }
-    const status = await lstat(target);
+    const status = await lstat2(target);
     if (!status.isFile() || status.isSymbolicLink()) {
       throw new Error(`Work asset ${asset3.id} must be a regular file.`);
     }
-    const bytes = await readFile7(target);
+    const bytes = await readFile8(target);
     const sha2562 = createHash8("sha256").update(bytes).digest("hex");
     if (bytes.byteLength !== asset3.sizeBytes) {
       throw new Error(
@@ -34826,6 +35526,44 @@ async function resolveTasksetWorkAssets(input) {
   }
   return resolved;
 }
+async function resolveTasksetTrainingAssetBytes(input) {
+  const result2 = /* @__PURE__ */ new Map();
+  for (const task of input.taskset.tasks.filter((candidate) => candidate.split === "train")) {
+    for (const asset3 of await resolveTasksetWorkAssets({
+      storeDir: input.storeDir,
+      taskset: input.taskset,
+      task
+    })) {
+      if (result2.has(asset3.artifactRef)) {
+        throw new Error(
+          `Training asset path ${asset3.artifactRef} is shared by multiple tasks.`
+        );
+      }
+      result2.set(asset3.artifactRef, asset3.bytes);
+    }
+  }
+  return result2;
+}
+async function resolveTasksetEvaluationAssetBytes(input) {
+  const result2 = /* @__PURE__ */ new Map();
+  for (const task of input.taskset.tasks.filter(
+    (candidate) => candidate.split === "validation" || candidate.split === "frozen_eval"
+  )) {
+    for (const asset3 of await resolveTasksetWorkAssets({
+      storeDir: input.storeDir,
+      taskset: input.taskset,
+      task
+    })) {
+      if (result2.has(asset3.artifactRef)) {
+        throw new Error(
+          `Evaluation asset path ${asset3.artifactRef} is shared by multiple tasks.`
+        );
+      }
+      result2.set(asset3.artifactRef, asset3.bytes);
+    }
+  }
+  return result2;
+}
 function assertEligibleSource(source, asset3) {
   if (isTrainingSourceRef(source)) {
     if (source.consent.status !== "granted") {
@@ -34861,7 +35599,7 @@ function assertEligibleSource(source, asset3) {
 
 // ../server/src/training/taskset-work-attempt-support.ts
 import path37 from "node:path";
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 var DEFAULT_MAX_WORK_TOOL_TURNS = 24;
 var MAX_WORK_TOOL_TURNS = 100;
 var MAX_MISSING_OUTPUT_RECOVERY_TURNS = 10;
@@ -34951,7 +35689,7 @@ async function validateSavedOutput(input) {
     }
     try {
       parsedJson = JSON.parse(
-        await readFile8(input.saved.artifactPath, "utf8")
+        await readFile9(input.saved.artifactPath, "utf8")
       );
     } catch {
       return {
@@ -37803,32 +38541,20 @@ async function qualifyHarnessModelImprovement(input) {
   });
   return receipt;
 }
-async function requireQualifiedModelImprovement(input) {
+async function resolveModelImprovementQualificationEvidence(input) {
+  if (!input.qualificationRef) return null;
+  const qualificationRef = input.qualificationRef;
   const receipt = (await input.store.listHarnessImprovementArtifacts(
     input.workspaceId,
     "training_qualification",
     1e3
   )).find(
-    (candidate) => candidate.id === input.qualificationRef.id && candidate.contentHash === input.qualificationRef.contentHash
+    (candidate) => candidate.id === qualificationRef.id && candidate.contentHash === qualificationRef.contentHash
   );
-  if (!receipt || receipt.decision === "no_training") {
-    throw new Error("A qualified model-improvement receipt is required before planning training.");
-  }
-  const taskset = await input.store.getTaskset(input.tasksetId);
-  if (!taskset || taskset.metadata.harnessEvaluationReview === void 0) {
-    throw new Error("Qualified Taskset was not found.");
-  }
-  if (receipt.metadata.sourceTasksetId !== taskset.id || receipt.metadata.sourceTasksetHash !== taskset.contentHash) {
-    throw new Error("Model-improvement qualification does not match the current immutable Taskset.");
-  }
-  if (!recipeMatches(receipt.decision, input.recipe.method)) {
-    throw new Error("Training recipe method does not match the qualification decision.");
-  }
-  if (receipt.model.model !== input.baseModelId) {
-    throw new Error("Training base Model does not match the qualified baseline Model.");
-  }
-  if (input.maximumCostUsd !== null && input.maximumCostUsd !== void 0 && input.maximumCostUsd > receipt.maximumCostUsd) {
-    throw new Error("Training approval exceeds the qualified maximum cost.");
+  if (!receipt) {
+    throw new Error(
+      "The supplied model-improvement qualification was not found at its immutable identity."
+    );
   }
   return receipt;
 }
@@ -37983,12 +38709,6 @@ function hashMetadata(baseline, key) {
   if (typeof value !== "string") throw new Error(`Baseline Evaluation is missing ${key}.`);
   return value;
 }
-function recipeMatches(decision, method) {
-  if (decision === "sft") return method === "sft";
-  if (decision === "preference") return method === "dpo";
-  if (decision === "rl") return method === "grpo" || method === "ppo";
-  return false;
-}
 function sameRef(value, expected) {
   return isRecord5(value) && value.id === expected.id && value.contentHash === expected.contentHash;
 }
@@ -38482,6 +39202,8 @@ function createRuntimeEventBus({
   }
   async function openEventSubscriber(input) {
     const subscriber = {
+      backpressured: false,
+      drainListener: null,
       response: input.response,
       sessionId: input.sessionId,
       ready: false,
@@ -38516,7 +39238,14 @@ function createRuntimeEventBus({
     }
   }
   function addLiveSubscriber(response, sessionId = null) {
-    const subscriber = { response, sessionId, ready: true, pending: [] };
+    const subscriber = {
+      backpressured: false,
+      drainListener: null,
+      response,
+      sessionId,
+      ready: true,
+      pending: []
+    };
     subscribers.add(subscriber);
     return () => disconnectSubscriber(subscriber, false);
   }
@@ -38601,6 +39330,9 @@ function createRuntimeEventBus({
       subscribers.delete(subscriber);
       return false;
     }
+    if (subscriber.backpressured) {
+      return queueSubscriberEvent(subscriber, event2);
+    }
     const encoded = `id: ${event2.sequence ?? ""}
 event: runtime
 data: ${JSON.stringify(event2)}
@@ -38608,8 +39340,14 @@ data: ${JSON.stringify(event2)}
 `;
     try {
       if (!subscriber.response.write(encoded)) {
-        disconnectSubscriber(subscriber);
-        return false;
+        subscriber.backpressured = true;
+        const onDrain = () => {
+          subscriber.drainListener = null;
+          subscriber.backpressured = false;
+          flushSubscriberQueue(subscriber);
+        };
+        subscriber.drainListener = onDrain;
+        subscriber.response.once("drain", onDrain);
       }
       return true;
     } catch {
@@ -38619,9 +39357,26 @@ data: ${JSON.stringify(event2)}
   }
   function disconnectSubscriber(subscriber, destroy = true) {
     subscribers.delete(subscriber);
+    if (subscriber.drainListener) {
+      subscriber.response.off("drain", subscriber.drainListener);
+      subscriber.drainListener = null;
+    }
+    subscriber.backpressured = false;
     subscriber.pending = [];
     if (destroy && !subscriber.response.destroyed) subscriber.response.destroy();
   }
+  function queueSubscriberEvent(subscriber, runtimeEvent) {
+    subscriber.pending.push(runtimeEvent);
+    if (subscriber.pending.length <= MAX_PENDING_SUBSCRIBER_EVENTS) return true;
+    disconnectSubscriber(subscriber);
+    return false;
+  }
+  function flushSubscriberQueue(subscriber) {
+    while (subscribers.has(subscriber) && !subscriber.backpressured && subscriber.pending.length > 0) {
+      const runtimeEvent = subscriber.pending.shift();
+      if (!runtimeEvent || !writeSubscriberEvent(subscriber, runtimeEvent)) return;
+    }
+  }
 }
 function isCoalescibleAssistantDelta(runtimeEvent) {
   return runtimeEvent.name === "assistant.delta" && Boolean(runtimeEvent.output) && !runtimeEvent.action && !runtimeEvent.args && !runtimeEvent.status && !runtimeEvent.error && !runtimeEvent.relatedDeploymentId && runtimeEvent.data === void 0;
@@ -38636,7 +39391,7 @@ function assistantDeltaKey(runtimeEvent) {
 }
 
 // ../server/src/runtime/turn-runner.ts
-import { createHash as createHash9, randomUUID as randomUUID17 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID18 } from "node:crypto";
 
 // ../server/src/chat-attachments.ts
 import { promises as fs23 } from "node:fs";
@@ -38841,14 +39596,14 @@ async function readChatAttachmentImageFile(input) {
   if (target !== turnDir && !target.startsWith(`${turnDir}${path42.sep}`))
     return null;
   try {
-    const stat = await fs23.lstat(target);
-    if (!stat.isFile() || stat.size > MAX_CHAT_ATTACHMENT_IMAGE_BYTES)
+    const stat2 = await fs23.lstat(target);
+    if (!stat2.isFile() || stat2.size > MAX_CHAT_ATTACHMENT_IMAGE_BYTES)
       return null;
     return {
       path: storageName,
       contentType,
       bytes: await fs23.readFile(target),
-      sizeBytes: stat.size
+      sizeBytes: stat2.size
     };
   } catch {
     return null;
@@ -38859,14 +39614,14 @@ async function readChatAttachmentTextFile(input) {
   if (!target || !chatAttachmentTextPreviewSupported(input.contentType, input.storageName))
     return null;
   try {
-    const stat = await fs23.lstat(target.absolutePath);
-    if (!stat.isFile() || stat.size > CHAT_ATTACHMENT_TEXT_PREVIEW_MAX_BYTES)
+    const stat2 = await fs23.lstat(target.absolutePath);
+    if (!stat2.isFile() || stat2.size > CHAT_ATTACHMENT_TEXT_PREVIEW_MAX_BYTES)
       return null;
     return {
       path: target.storageName,
       contentType: input.contentType,
       content: await fs23.readFile(target.absolutePath, "utf8"),
-      sizeBytes: stat.size
+      sizeBytes: stat2.size
     };
   } catch {
     return null;
@@ -40117,7 +40872,7 @@ function resolveContextCompactionAdapter(provider) {
 }
 
 // ../server/src/openpond/context-compaction/index.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 
 // ../server/src/openpond/context-compaction/file-paths.ts
 function extractCompactionFilePaths(value) {
@@ -40978,7 +41733,7 @@ async function runHostedContextCompaction(input) {
     [
       ...projectionEvents,
       {
-        id: `compaction-projection-${randomUUID13()}`,
+        id: `compaction-projection-${randomUUID14()}`,
         name: "session.compaction.completed",
         data: {
           summary: result2.summary,
@@ -41023,7 +41778,7 @@ function hostedCompactionContextLimit(provider, model, maxContextTokens) {
 }
 async function streamCompactionSummary(input) {
   let text = "";
-  const requestId = `compact-${randomUUID13()}`;
+  const requestId = `compact-${randomUUID14()}`;
   const streamCompactionChatTurn = input.streamCompactionChatTurn ?? defaultOpenPondCompactionStream;
   for await (const delta of streamCompactionChatTurn({
     provider: input.provider,
@@ -44960,7 +45715,7 @@ function assertCreateImproveMutationApproved(input) {
 }
 
 // ../server/src/runtime/create-pipeline-planner.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 var PlannerQuestionOptionSchema = external_exports.object({
   id: external_exports.string().trim().min(1).optional(),
   label: external_exports.string().trim().min(1),
@@ -45130,8 +45885,8 @@ function createQuestionRun(run, decision, modelRef) {
 }
 function createPlanRun(run, decision, modelRef) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const planId = `create_improve_plan_${randomUUID14()}`;
-  const approvalId = `approval_${randomUUID14()}`;
+  const planId = `create_improve_plan_${randomUUID15()}`;
+  const approvalId = `approval_${randomUUID15()}`;
   const target = plannedTarget(run.target, decision, run.objective);
   const sourceRoot = sourceRootForTarget(target);
   const actionShape = decision.actionShape;
@@ -45214,7 +45969,7 @@ function workflowCaptureForRun(run) {
   );
   return CreateImproveWorkflowCaptureSchema.parse({
     schemaVersion: "openpond.createImprove.workflowCapture.v1",
-    id: `workflow_capture_${randomUUID14()}`,
+    id: `workflow_capture_${randomUUID15()}`,
     runId: run.id,
     command: run.command,
     objective: run.objective,
@@ -45662,12 +46417,12 @@ var KeyedRegistry = class {
 
 // ../server/src/runtime/local-create-pipeline.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { cp, mkdir as mkdir4, readFile as readFile10 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir5, readFile as readFile11 } from "node:fs/promises";
 import path46 from "node:path";
 
 // ../server/src/runtime/local-create-pipeline-checks.ts
 import { existsSync } from "node:fs";
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 import path45 from "node:path";
 async function runLocalCreatePipelineChecks(input) {
   await assertLocalCreateSourceLayout(input.target);
@@ -45759,7 +46514,7 @@ async function assertLocalCreateSourceLayout(target) {
       `Codex did not update the profile manifest: ${profileManifestPath}`
     );
   }
-  const rootManifest = JSON.parse(await readFile9(rootManifestPath, "utf8"));
+  const rootManifest = JSON.parse(await readFile10(rootManifestPath, "utf8"));
   const profileEntry = rootManifest.profiles?.[target.activeProfile];
   if (!profileEntry) {
     throw new Error(
@@ -45771,7 +46526,7 @@ async function assertLocalCreateSourceLayout(target) {
       `openpond-profile.json does not enable generated agent ${target.agentId}.`
     );
   }
-  const profileYaml = await readFile9(profileManifestPath, "utf8");
+  const profileYaml = await readFile10(profileManifestPath, "utf8");
   if (!profileYaml.includes(`id: ${target.agentId}`) && !profileYaml.includes(`id: "${target.agentId}"`)) {
     throw new Error(
       `settings/profile.yaml does not register generated agent ${target.agentId}.`
@@ -45805,7 +46560,7 @@ async function assertGeneratedSdkArtifacts(target, requireEvalPass = true) {
       `Generated source did not produce eval results: ${evalResultsPath}`
     );
   }
-  const registry = JSON.parse(await readFile9(registryPath, "utf8"));
+  const registry = JSON.parse(await readFile10(registryPath, "utf8"));
   const actions = Array.isArray(registry.actions) ? registry.actions : [];
   const actionIds = new Set(
     actions.map((action) => typeof action.id === "string" ? action.id : null).filter((id) => Boolean(id))
@@ -45838,7 +46593,7 @@ async function assertGeneratedSdkArtifacts(target, requireEvalPass = true) {
       )}. Mark built-in/local fixture requirements ready or optional when they are satisfied, or leave the pipeline blocked until the setup is configured.`
     );
   }
-  const evalResults = JSON.parse(await readFile9(evalResultsPath, "utf8"));
+  const evalResults = JSON.parse(await readFile10(evalResultsPath, "utf8"));
   if (typeof evalResults.summary?.total !== "number" || evalResults.summary.total < 1) {
     throw new Error(
       "Generated source must define at least one deterministic SDK eval."
@@ -46310,7 +47065,7 @@ async function applyPreparedHarnessSourceApplication(snapshot, target, env = pro
     HARNESS_PREPARED_SOURCE_MANIFEST
   );
   if (!existsSync2(manifestPath)) return false;
-  const manifest = JSON.parse(await readFile10(manifestPath, "utf8"));
+  const manifest = JSON.parse(await readFile11(manifestPath, "utf8"));
   const root = asRecord16(manifest);
   if (root?.schema !== "openpond.harnessPreparedSource.v1") {
     throw new Error(
@@ -46333,8 +47088,8 @@ async function applyPreparedHarnessSourceApplication(snapshot, target, env = pro
       `Prepared harness source does not exist: ${operation.source}`
     );
   }
-  await mkdir4(target.sourceRoot, { recursive: true });
-  await cp(sourcePath, target.sourceRoot, { recursive: true, force: true });
+  await mkdir5(target.sourceRoot, { recursive: true });
+  await cp2(sourcePath, target.sourceRoot, { recursive: true, force: true });
   for (const registration of operation.registrations ?? []) {
     const registrationSource = resolveHarnessManifestPath(
       target.workspaceRoot,
@@ -46351,8 +47106,8 @@ async function applyPreparedHarnessSourceApplication(snapshot, target, env = pro
         `Prepared harness registration source does not exist: ${registration.source}`
       );
     }
-    await mkdir4(path46.dirname(registrationTarget), { recursive: true });
-    await cp(registrationSource, registrationTarget, { force: true });
+    await mkdir5(path46.dirname(registrationTarget), { recursive: true });
+    await cp2(registrationSource, registrationTarget, { force: true });
   }
   return true;
 }
@@ -46426,7 +47181,7 @@ async function sourceLayoutFingerprint(target) {
   ];
   const parts = await Promise.all(
     paths.map(async (filePath) => {
-      const content = await readFile10(filePath, "utf8");
+      const content = await readFile11(filePath, "utf8");
       return `${filePath}:${content.length}:${content}`;
     })
   );
@@ -46918,13 +47673,13 @@ function stringArray5(value) {
 
 // ../server/src/runtime/create-pipeline/agent-improvement-git.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir6, realpath as realpath3, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir7, realpath as realpath3, rm as rm3, writeFile as writeFile5 } from "node:fs/promises";
 import os4 from "node:os";
 import path49 from "node:path";
 
 // ../server/src/runtime/create-pipeline/agent-improvement-git-helpers.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { cp as cp2, lstat as lstat2, mkdir as mkdir5, rm, symlink, writeFile as writeFile4 } from "node:fs/promises";
+import { cp as cp3, lstat as lstat3, mkdir as mkdir6, rm as rm2, symlink, writeFile as writeFile4 } from "node:fs/promises";
 import path48 from "node:path";
 function allowedAgentImprovementPaths(run, target) {
   const profilePath = normalizeRepoPath(target.profileRelativePath);
@@ -47016,7 +47771,7 @@ async function linkCandidateDependencies(target, worktreePath) {
     const destinationPath = path48.join(worktreePath, ...relativePath.split("/"));
     if (!await directoryExists(sourcePath) || existsSync3(destinationPath))
       continue;
-    await mkdir5(path48.dirname(destinationPath), { recursive: true });
+    await mkdir6(path48.dirname(destinationPath), { recursive: true });
     await symlink(
       sourcePath,
       destinationPath,
@@ -47043,7 +47798,7 @@ async function snapshotActiveProfileChanges(input) {
       applied,
       "Unable to apply active Profile changes to the candidate baseline."
     );
-    await rm(patchPath, { force: true });
+    await rm2(patchPath, { force: true });
   }
   const untracked = await input.command(
     "git",
@@ -47057,8 +47812,8 @@ async function snapshotActiveProfileChanges(input) {
       input.worktreePath,
       ...relativePath.split("/")
     );
-    await mkdir5(path48.dirname(destination), { recursive: true });
-    await cp2(source, destination, {
+    await mkdir6(path48.dirname(destination), { recursive: true });
+    await cp3(source, destination, {
       recursive: true,
       preserveTimestamps: true
     });
@@ -47102,7 +47857,7 @@ function gitIdentityEnv() {
 }
 async function directoryExists(value) {
   try {
-    return (await lstat2(value)).isDirectory();
+    return (await lstat3(value)).isDirectory();
   } catch {
     return false;
   }
@@ -47281,7 +48036,7 @@ async function prepareAgentImprovementWorkspace(input) {
     safePathSegment(input.run.id)
   );
   const worktreePath = path49.join(workspaceRoot, "repo");
-  await mkdir6(workspaceRoot, { recursive: true });
+  await mkdir7(workspaceRoot, { recursive: true });
   const existingBranch = await command(
     "git",
     ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`],
@@ -47298,8 +48053,8 @@ async function prepareAgentImprovementWorkspace(input) {
         ["worktree", "remove", "--force", worktreePath],
         repoPath
       );
-      await rm2(workspaceRoot, { recursive: true, force: true });
-      await mkdir6(workspaceRoot, { recursive: true });
+      await rm3(workspaceRoot, { recursive: true, force: true });
+      await mkdir7(workspaceRoot, { recursive: true });
     }
   }
   if (!existsSync4(worktreePath)) {
@@ -47734,7 +48489,7 @@ async function applyAgentImprovementCandidateLocally(input) {
     }
     throw error;
   } finally {
-    await rm2(patchPath, { force: true }).catch(() => void 0);
+    await rm3(patchPath, { force: true }).catch(() => void 0);
   }
 }
 async function cleanupAgentImprovementWorkspace(input) {
@@ -47750,7 +48505,7 @@ async function cleanupAgentImprovementWorkspace(input) {
     await command("git", ["branch", "-D", input.git.branch], input.repoPath);
   }
   if (input.git.worktreePath) {
-    await rm2(path49.dirname(input.git.worktreePath), {
+    await rm3(path49.dirname(input.git.worktreePath), {
       recursive: true,
       force: true
     }).catch(() => void 0);
@@ -48861,7 +49616,7 @@ function uniqueEvidence2(run, evidence) {
 }
 async function verifyAppliedProfileCommit(input) {
   const command = input.command ?? (async (name, args, cwd, env) => {
-    const { runWorkspaceCommand } = await import("./workspaces-WXM72UZF.js");
+    const { runWorkspaceCommand } = await import("./workspaces-IJQPWX3H.js");
     return runWorkspaceCommand(name, args, cwd, env);
   });
   const result2 = await command("git", ["rev-parse", "HEAD"], input.repoPath);
@@ -49202,6 +49957,7 @@ function createCreateImproveRuntime(deps) {
           modelId,
           messages,
           requestId: `${input.turn.id}:create-improve-planner`,
+          promptCacheKey: input.session.id,
           signal: input.signal
         })
       });
@@ -50282,8 +51038,8 @@ function createSubagentWorkspaceRuntime(deps) {
     }
     const existing = [];
     for (const relDir of relDirs) {
-      const stat = await safeLstat(path52.join(parentRepoPath, ...relDir.split("/").filter(Boolean)));
-      if (stat?.isDirectory()) existing.push(relDir);
+      const stat2 = await safeLstat(path52.join(parentRepoPath, ...relDir.split("/").filter(Boolean)));
+      if (stat2?.isDirectory()) existing.push(relDir);
     }
     return existing;
   }
@@ -51348,7 +52104,7 @@ function sandboxRank(sandbox) {
 }
 
 // ../server/src/runtime/subagents/messaging-runtime.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 function subagentActiveTurnIsDurablyTerminal(active, durableTurn) {
   return Boolean(
     active && durableTurn?.id === active.turn.id && durableTurn.status !== "in_progress"
@@ -51392,7 +52148,7 @@ function createSubagentMessagingRuntime(deps) {
       reason: delivered ? null : input.toRunId || input.toRole ? "No matching active child run was available for delivery." : "No target run or role was supplied."
     };
     let message = SubagentMessageSchema.parse({
-      id: randomUUID15(),
+      id: randomUUID16(),
       fromRunId,
       toRunId: input.toRunId ?? null,
       toRole: input.toRole ?? null,
@@ -51467,7 +52223,7 @@ function createSubagentMessagingRuntime(deps) {
       reason: input.run.childSessionId ? null : "The child run has no child conversation."
     });
     const message = SubagentMessageSchema.parse({
-      id: randomUUID15(),
+      id: randomUUID16(),
       fromRunId: input.context.session.subagentRunId ?? `parent:${input.context.session.id}`,
       toRunId: input.run.id,
       toRole: input.run.roleId,
@@ -52296,7 +53052,7 @@ function completionNotifications(run) {
 }
 
 // ../server/src/runtime/subagents/tool-runtime.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 function createSubagentToolRuntime(deps) {
   const SUBAGENT_JOIN_WAIT_MS = 6e4;
   const SUBAGENT_JOIN_POLL_MS = 250;
@@ -52390,7 +53146,7 @@ function createSubagentToolRuntime(deps) {
           );
         }
       }
-      const runId = randomUUID16();
+      const runId = randomUUID17();
       const createdAt = now();
       const childTurnPermissions = subagentChildTurnPermissions(
         context.turnPermissions,
@@ -53737,7 +54493,7 @@ function createTurnRunner(deps) {
       } : {}
     };
     const turn = {
-      id: randomUUID17(),
+      id: randomUUID18(),
       sessionId,
       providerTurnId: null,
       modelRef: turnModelRef,
@@ -54075,6 +54831,7 @@ function createTurnRunner(deps) {
             modelId: runtimeModel,
             messages: streamInput.messages,
             requestId: streamInput.requestId,
+            promptCacheKey: session.id,
             reasoningEffort: turnPermissions.codexReasoningEffort,
             signal: streamInput.signal ?? controller.signal
           })) {
@@ -54125,6 +54882,7 @@ function createTurnRunner(deps) {
               toolChoice: options?.toolChoice,
               maxOutputTokens: options?.maxOutputTokens,
               requestId: options?.requestId ?? turn.id,
+              promptCacheKey: session.id,
               signal: controller.signal
             })) {
               if (delta.text) yield { text: delta.text, raw: delta.raw };
@@ -54364,7 +55122,7 @@ function createImproveLimit(value) {
 }
 
 // ../server/src/store/session-store.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function createSessionStore(deps) {
   const {
     store,
@@ -54377,7 +55135,7 @@ function createSessionStore(deps) {
   async function createSession(payload) {
     const input = CreateSessionRequestSchema.parse(payload);
     const createdAt = now();
-    const sessionId = randomUUID18();
+    const sessionId = randomUUID19();
     const sessionCount = await store.sessionCount();
     const workspaceKind = input.workspaceKind ?? (input.appId ? "sandbox_app" : void 0);
     const openPondCommandAccessMode = input.openPondCommandAccessMode ?? (loadAppPreferences ? (await loadAppPreferences()).openPondCommandAccessMode : DEFAULT_OPENPOND_COMMAND_ACCESS_MODE);
@@ -54580,7 +55338,7 @@ function normalizeSession(session, sidebarPatch) {
 }
 
 // ../server/src/session-title-service.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 var SESSION_TITLE_MODEL = "accounts/fireworks/models/deepseek-v4-flash";
 var SESSION_TITLE_REASONING_EFFORT = "low";
 var TITLE_TIMEOUT_MS = 12e3;
@@ -54644,7 +55402,7 @@ function createSessionTitleService(deps) {
         reasoningEffort: SESSION_TITLE_REASONING_EFFORT,
         maxTokens: 32,
         temperature: 0.2,
-        requestId: `session-title-${randomUUID19()}`,
+        requestId: `session-title-${randomUUID20()}`,
         signal: controller.signal
       })) {
         if (delta.type === "text_delta" && delta.text) generated += delta.text;
@@ -54923,6 +55681,147 @@ var SqliteWorkEvidenceStore = class extends SqliteHarnessWorkspaceStore {
   }
 };
 
+// ../server/src/store/store-chat-workflows.ts
+var SqliteChatWorkflowStore = class extends SqliteWorkEvidenceStore {
+  async listChatWorkflows(query = {}) {
+    await this.ready;
+    await this.writeQueue;
+    const rows = await this.all(
+      `SELECT * FROM chat_workflows
+       ${query.sessionId ? "WHERE session_id = ?" : ""}
+       ORDER BY created_at DESC`,
+      query.sessionId ? [query.sessionId] : []
+    );
+    return rows.map((row) => JSON.parse(row.payload));
+  }
+  async listDueChatWorkflows(nowIso, limit = 25) {
+    await this.ready;
+    await this.writeQueue;
+    const rows = await this.all(
+      `SELECT * FROM chat_workflows
+       WHERE enabled = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?
+       ORDER BY next_run_at ASC LIMIT ?`,
+      [nowIso, Math.max(1, Math.min(100, Math.trunc(limit)))]
+    );
+    return rows.map((row) => JSON.parse(row.payload));
+  }
+  async getChatWorkflow(id) {
+    await this.ready;
+    await this.writeQueue;
+    const row = await this.get("SELECT * FROM chat_workflows WHERE id = ?", [id]);
+    return row ? JSON.parse(row.payload) : null;
+  }
+  async upsertChatWorkflow(workflow) {
+    await this.ready;
+    const write = this.writeQueue.then(async () => {
+      await this.run(
+        `INSERT INTO chat_workflows
+         (id, session_id, enabled, next_run_at, payload, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           session_id = excluded.session_id,
+           enabled = excluded.enabled,
+           next_run_at = excluded.next_run_at,
+           payload = excluded.payload,
+           updated_at = excluded.updated_at`,
+        [
+          workflow.id,
+          workflow.sessionId,
+          workflow.enabled ? 1 : 0,
+          workflow.nextRunAt,
+          JSON.stringify(workflow),
+          workflow.createdAt,
+          workflow.updatedAt
+        ]
+      );
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return await this.getChatWorkflow(workflow.id) ?? workflow;
+  }
+  async patchChatWorkflow(id, updater) {
+    await this.ready;
+    let updated = null;
+    const write = this.writeQueue.then(async () => {
+      const row = await this.get("SELECT * FROM chat_workflows WHERE id = ?", [id]);
+      if (!row) return;
+      updated = updater(JSON.parse(row.payload));
+      await this.run(
+        "UPDATE chat_workflows SET enabled = ?, next_run_at = ?, payload = ?, updated_at = ? WHERE id = ?",
+        [updated.enabled ? 1 : 0, updated.nextRunAt, JSON.stringify(updated), updated.updatedAt, id]
+      );
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return updated;
+  }
+  async deleteChatWorkflow(id) {
+    await this.ready;
+    let changed = false;
+    const write = this.writeQueue.then(async () => {
+      const existing = await this.get("SELECT id FROM chat_workflows WHERE id = ?", [id]);
+      if (!existing) return;
+      await this.run("DELETE FROM chat_workflows WHERE id = ?", [id]);
+      changed = true;
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return changed;
+  }
+  async insertChatWorkflowRun(run) {
+    await this.ready;
+    const write = this.writeQueue.then(async () => {
+      await this.run(
+        `INSERT INTO chat_workflow_runs
+         (id, workflow_id, session_id, scheduled_for, trigger, status, payload, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          run.id,
+          run.workflowId,
+          run.sessionId,
+          run.scheduledFor,
+          run.trigger,
+          run.status,
+          JSON.stringify(run),
+          run.createdAt,
+          run.updatedAt
+        ]
+      );
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return run;
+  }
+  async listChatWorkflowRuns(workflowId, limit = 100) {
+    await this.ready;
+    await this.writeQueue;
+    const boundedLimit = Math.max(1, Math.min(500, Math.trunc(limit)));
+    const rows = await this.all(
+      `SELECT * FROM chat_workflow_runs
+       ${workflowId ? "WHERE workflow_id = ?" : ""}
+       ORDER BY created_at DESC LIMIT ?`,
+      workflowId ? [workflowId, boundedLimit] : [boundedLimit]
+    );
+    return rows.map((row) => JSON.parse(row.payload));
+  }
+  async patchChatWorkflowRun(id, updater) {
+    await this.ready;
+    let updated = null;
+    const write = this.writeQueue.then(async () => {
+      const row = await this.get("SELECT * FROM chat_workflow_runs WHERE id = ?", [id]);
+      if (!row) return;
+      updated = updater(JSON.parse(row.payload));
+      await this.run(
+        "UPDATE chat_workflow_runs SET status = ?, payload = ?, updated_at = ? WHERE id = ?",
+        [updated.status, JSON.stringify(updated), updated.updatedAt, id]
+      );
+    });
+    this.writeQueue = write.catch(() => void 0);
+    await write;
+    return updated;
+  }
+};
+
 // ../server/src/store/session-runtime-summary.ts
 function sessionRuntimeSummaries(turns) {
   const mutableBySessionId = /* @__PURE__ */ new Map();
@@ -54968,7 +55867,7 @@ var NON_TERMINAL_SUBAGENT_STATUSES = [
   "running",
   "needs_resume"
 ];
-var SqliteStore = class extends SqliteWorkEvidenceStore {
+var SqliteStore = class extends SqliteChatWorkflowStore {
   async snapshot() {
     await this.ready;
     await this.writeQueue;
@@ -56666,6 +57565,7 @@ export {
   createOpenPondCommandAccessService,
   commandResultForModel,
   createCloudConnectedAppToolExecutor,
+  isManagedLocalWorkSession,
   trustedProviderContextLimit,
   appDataDir,
   providersConfigPath,
@@ -56732,17 +57632,21 @@ export {
   readTasksetAuthoringProfileSkill,
   createCrossSystemExpertBootstrapService,
   createTaskCreatorService,
+  buildTasksetReadiness,
   persistBinaryTaskAttemptArtifact,
+  NativeToolCallAccumulator,
   createWebFetchModelToolDefinition,
   createWebSearchModelToolDefinition,
   waitForWorkReceiptSettlement,
+  resolveTasksetTrainingAssetBytes,
+  resolveTasksetEvaluationAssetBytes,
   hostedTokenPricingFromValue,
   hostedUsageCostUsd,
   compileDesktopHarnessContext,
   persistCanonicalEvaluationEvidence,
   createTaskEvaluationService,
   qualifyHarnessModelImprovement,
-  requireQualifiedModelImprovement,
+  resolveModelImprovementQualificationEvidence,
   retryableHostedError,
   hostedRetryDelayMs,
   abortableDelay,