principles-disciple 1.197.1 → 1.197.3

package/dist/core/principle-training-state.js

@@ -1,511 +0,0 @@
-// ../principles-core/dist/principle-tree-ledger.js
-import * as fs from "fs";
-import * as path from "path";
-
-// ../principles-core/dist/runtime-v2/types/ledger-store.js
-var TREE_NAMESPACE = "_tree";
-
-// ../principles-core/dist/runtime-v2/principle-tree/ledger-codec.js
-var VALID_EVALUABILITIES = ["deterministic", "weak_heuristic", "manual_only"];
-var VALID_INTERNALIZATION_STATUSES = [
-  "prompt_only",
-  "needs_training",
-  "in_training",
-  "deployed_pending_eval",
-  "internalized",
-  "regressed"
-];
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((e) => typeof e === "string") : [];
-}
-function clampFloat(value, opts) {
-  if (typeof value !== "number" || !Number.isFinite(value))
-    return opts.fallback;
-  return Math.max(opts.min, Math.min(opts.max, value));
-}
-function clampInt(value, opts) {
-  if (typeof value !== "number" || !Number.isFinite(value))
-    return opts.fallback;
-  return Math.max(opts.min, Math.min(opts.max, Math.round(value)));
-}
-function parseLegacyTrainingStore(raw) {
-  if (!isRecord(raw))
-    return {};
-  const result = {};
-  for (const [principleId, candidate] of Object.entries(raw)) {
-    if (principleId === TREE_NAMESPACE || !isRecord(candidate))
-      continue;
-    if (candidate.principleId !== principleId)
-      continue;
-    result[principleId] = {
-      principleId,
-      evaluability: VALID_EVALUABILITIES.includes(candidate.evaluability) ? candidate.evaluability : "manual_only",
-      applicableOpportunityCount: clampInt(candidate.applicableOpportunityCount, { min: 0, max: Infinity, fallback: 0 }),
-      observedViolationCount: clampInt(candidate.observedViolationCount, { min: 0, max: Infinity, fallback: 0 }),
-      complianceRate: clampFloat(candidate.complianceRate, { min: 0, max: 1, fallback: 0 }),
-      violationTrend: clampFloat(candidate.violationTrend, { min: -1, max: 1, fallback: 0 }),
-      generatedSampleCount: clampInt(candidate.generatedSampleCount, { min: 0, max: Infinity, fallback: 0 }),
-      approvedSampleCount: clampInt(candidate.approvedSampleCount, { min: 0, max: Infinity, fallback: 0 }),
-      includedTrainRunIds: stringArray(candidate.includedTrainRunIds),
-      deployedCheckpointIds: stringArray(candidate.deployedCheckpointIds),
-      lastEvalScore: typeof candidate.lastEvalScore === "number" && Number.isFinite(candidate.lastEvalScore) ? clampFloat(candidate.lastEvalScore, { min: 0, max: 1, fallback: 0 }) : void 0,
-      internalizationStatus: VALID_INTERNALIZATION_STATUSES.includes(candidate.internalizationStatus) ? candidate.internalizationStatus : "prompt_only"
-    };
-  }
-  return result;
-}
-function parsePrinciples(raw) {
-  if (!isRecord(raw))
-    return {};
-  const principles = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value))
-      continue;
-    principles[id] = {
-      ...value,
-      id,
-      ruleIds: stringArray(value.ruleIds),
-      conflictsWithPrincipleIds: stringArray(value.conflictsWithPrincipleIds),
-      derivedFromPainIds: stringArray(value.derivedFromPainIds)
-    };
-  }
-  return principles;
-}
-function parseRules(raw) {
-  if (!isRecord(raw))
-    return {};
-  const rules = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value))
-      continue;
-    rules[id] = {
-      ...value,
-      id,
-      principleId: typeof value.principleId === "string" ? value.principleId : "",
-      implementationIds: stringArray(value.implementationIds)
-    };
-  }
-  return rules;
-}
-function parseImplementations(raw) {
-  if (!isRecord(raw))
-    return {};
-  const implementations = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value) || typeof value.ruleId !== "string")
-      continue;
-    implementations[id] = { ...value, id, ruleId: value.ruleId };
-  }
-  return implementations;
-}
-function parseMetrics(raw) {
-  if (!isRecord(raw))
-    return {};
-  const metrics = {};
-  for (const [id, value] of Object.entries(raw)) {
-    if (!isRecord(value))
-      continue;
-    metrics[id] = { ...value, principleId: typeof value.principleId === "string" ? value.principleId : id };
-  }
-  return metrics;
-}
-function createEmptyTree() {
-  return { principles: {}, rules: {}, implementations: {}, metrics: {}, lastUpdated: (/* @__PURE__ */ new Date(0)).toISOString() };
-}
-function parseTree(raw) {
-  if (!isRecord(raw))
-    return createEmptyTree();
-  return {
-    principles: parsePrinciples(raw.principles),
-    rules: parseRules(raw.rules),
-    implementations: parseImplementations(raw.implementations),
-    metrics: parseMetrics(raw.metrics),
-    lastUpdated: typeof raw.lastUpdated === "string" ? raw.lastUpdated : (/* @__PURE__ */ new Date(0)).toISOString()
-  };
-}
-function parseHybridLedger(raw) {
-  if (!isRecord(raw))
-    return { trainingStore: {}, tree: createEmptyTree() };
-  const trainingStoreRaw = raw.trainingStore ?? raw;
-  const treeRaw = raw[TREE_NAMESPACE] ?? raw.tree;
-  return {
-    trainingStore: parseLegacyTrainingStore(trainingStoreRaw),
-    tree: parseTree(treeRaw)
-  };
-}
-function serializeLedger(store) {
-  return JSON.stringify({
-    ...store.trainingStore,
-    [TREE_NAMESPACE]: { ...store.tree, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }
-  }, null, 2);
-}
-
-// ../principles-core/dist/principle-tree-ledger.js
-var PRINCIPLE_TRAINING_FILE = "principle_training_state.json";
-var RENAME_MAX_RETRIES = 3;
-var RENAME_BASE_DELAY_MS = 50;
-function atomicWriteFileSync(filePath, data) {
-  const targetDir = path.dirname(filePath);
-  const tmpDir = fs.mkdtempSync(path.join(targetDir, ".pd-write-"));
-  const tmpPath = path.join(tmpDir, "tmp");
-  try {
-    fs.writeFileSync(tmpPath, data, { encoding: "utf8", mode: 384 });
-    let lastError;
-    for (let attempt = 0; attempt < RENAME_MAX_RETRIES; attempt++) {
-      try {
-        fs.renameSync(tmpPath, filePath);
-        return;
-      } catch (err) {
-        lastError = err;
-        const { code } = err;
-        if (code === "EPERM" || code === "EBUSY" || code === "EACCES") {
-          if (attempt < RENAME_MAX_RETRIES - 1) {
-            const delay = RENAME_BASE_DELAY_MS * Math.pow(2, attempt);
-            const waitUntil = Date.now() + delay;
-            while (Date.now() < waitUntil) {
-              try {
-                fs.accessSync(tmpPath);
-              } catch {
-              }
-            }
-          }
-          continue;
-        }
-        break;
-      }
-    }
-    throw lastError ?? new Error("atomicWriteFileSync: rename failed");
-  } finally {
-    try {
-      fs.unlinkSync(tmpPath);
-    } catch {
-    }
-    try {
-      fs.rmdirSync(tmpDir);
-    } catch {
-    }
-  }
-}
-function getLedgerFilePath(stateDir) {
-  return path.join(stateDir, PRINCIPLE_TRAINING_FILE);
-}
-function readLedgerFromFile(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return { trainingStore: {}, tree: createEmptyTree() };
-  }
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    if (!content || content.trim() === "") {
-      return { trainingStore: {}, tree: createEmptyTree() };
-    }
-    const parsed = JSON.parse(content);
-    return parseHybridLedger(parsed);
-  } catch {
-    return { trainingStore: {}, tree: createEmptyTree() };
-  }
-}
-var LockAcquisitionError = class extends Error {
-  filePath;
-  lockPath;
-  constructor(message, filePath, lockPath) {
-    super(message);
-    this.name = "LockAcquisitionError";
-    this.filePath = filePath;
-    this.lockPath = lockPath;
-  }
-};
-var DEFAULT_LOCK_OPTIONS = {
-  maxRetries: 50,
-  baseRetryDelayMs: 10,
-  maxRetryDelayMs: 500,
-  lockStaleMs: 1e4,
-  lockSuffix: ".lock"
-};
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isErrnoException(value) {
-  return typeof value === "object" && value !== null && Object.hasOwn(value, "code");
-}
-function tryAcquireLock(lockPath, pid) {
-  try {
-    const lockDir = path.dirname(lockPath);
-    if (!fs.existsSync(lockDir)) {
-      fs.mkdirSync(lockDir, { recursive: true });
-    }
-    const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL;
-    const fd = fs.openSync(lockPath, flags, 384);
-    fs.writeSync(fd, String(pid));
-    fs.fsyncSync(fd);
-    fs.closeSync(fd);
-    return true;
-  } catch (err) {
-    if (isErrnoException(err) && err.code === "EEXIST") {
-      return false;
-    }
-    throw err;
-  }
-}
-function readLockPid(lockPath) {
-  try {
-    const content = fs.readFileSync(lockPath, "utf8");
-    const pid = parseInt(content.trim(), 10);
-    return Number.isNaN(pid) ? null : pid;
-  } catch {
-    return null;
-  }
-}
-function safeReleaseLock(lockPath, expectedPid) {
-  try {
-    if (readLockPid(lockPath) === expectedPid) {
-      fs.unlinkSync(lockPath);
-    }
-  } catch {
-  }
-}
-function cleanupStaleLock(lockPath, _staleMs) {
-  try {
-    const pid = readLockPid(lockPath);
-    const isDead = pid === null || !isProcessAlive(pid);
-    if (isDead) {
-      try {
-        fs.unlinkSync(lockPath);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function calculateBackoff(attempt, baseMs, maxMs) {
-  const exponentialDelay = Math.min(baseMs * Math.pow(2, attempt), maxMs);
-  const jitter = exponentialDelay * 0.2 * Math.random();
-  return Math.floor(exponentialDelay + jitter);
-}
-function sleepSync(ms) {
-  if (ms <= 0)
-    return;
-  const shared = new Int32Array(new SharedArrayBuffer(4));
-  Atomics.wait(shared, 0, 0, ms);
-}
-function tryAcquireWithStaleCleanup(filePath, opts, pid) {
-  const lockPath = filePath + opts.lockSuffix;
-  if (tryAcquireLock(lockPath, pid) && readLockPid(lockPath) === pid) {
-    return { lockPath, pid, acquiredAt: Date.now() };
-  }
-  cleanupStaleLock(lockPath, opts.lockStaleMs);
-  if (tryAcquireLock(lockPath, pid) && readLockPid(lockPath) === pid) {
-    return { lockPath, pid, acquiredAt: Date.now() };
-  }
-  return null;
-}
-function buildLockError(filePath, opts) {
-  const lockPath = filePath + opts.lockSuffix;
-  const holderPid = readLockPid(lockPath);
-  const holderStatus = holderPid !== null ? isProcessAlive(holderPid) ? `alive (PID ${holderPid})` : `dead (PID ${holderPid})` : "unknown";
-  return new LockAcquisitionError(`Failed to acquire lock for ${filePath}. Lock holder: ${holderStatus}.`, filePath, lockPath);
-}
-function acquireLock(filePath, options = {}) {
-  const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
-  const { pid } = process;
-  for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-    const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
-    if (ctx)
-      return ctx;
-    if (attempt < opts.maxRetries - 1) {
-      sleepSync(calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs));
-    }
-  }
-  throw buildLockError(filePath, opts);
-}
-async function acquireLockAsync(filePath, options = {}) {
-  const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
-  const { pid } = process;
-  for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-    const ctx = tryAcquireWithStaleCleanup(filePath, opts, pid);
-    if (ctx)
-      return ctx;
-    if (attempt < opts.maxRetries - 1) {
-      await new Promise((resolve) => setTimeout(resolve, calculateBackoff(attempt, opts.baseRetryDelayMs, opts.maxRetryDelayMs)));
-    }
-  }
-  throw buildLockError(filePath, opts);
-}
-function releaseLock(ctx) {
-  safeReleaseLock(ctx.lockPath, ctx.pid);
-}
-function withLock(filePath, fn, options) {
-  const ctx = acquireLock(filePath, options);
-  try {
-    return fn();
-  } finally {
-    releaseLock(ctx);
-  }
-}
-async function withLockAsync(filePath, fn, options) {
-  const ctx = await acquireLockAsync(filePath, options);
-  try {
-    return await fn();
-  } finally {
-    releaseLock(ctx);
-  }
-}
-function mutateLedger(stateDir, mutate) {
-  const filePath = getLedgerFilePath(stateDir);
-  return withLock(filePath, () => {
-    const store = readLedgerFromFile(filePath);
-    const result = mutate(store);
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir))
-      fs.mkdirSync(dir, { recursive: true });
-    atomicWriteFileSync(filePath, serializeLedger(store));
-    return result;
-  });
-}
-async function mutateLedgerAsync(stateDir, mutate) {
-  const filePath = getLedgerFilePath(stateDir);
-  return withLockAsync(filePath, async () => {
-    const store = readLedgerFromFile(filePath);
-    const result = await mutate(store);
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir))
-      fs.mkdirSync(dir, { recursive: true });
-    atomicWriteFileSync(filePath, serializeLedger(store));
-    return result;
-  });
-}
-function loadLedger(stateDir) {
-  return readLedgerFromFile(getLedgerFilePath(stateDir));
-}
-function saveLedger(stateDir, store) {
-  mutateLedger(stateDir, (current) => {
-    current.trainingStore = store.trainingStore;
-    current.tree = store.tree;
-  });
-}
-async function saveLedgerAsync(stateDir, store) {
-  await mutateLedgerAsync(stateDir, async (current) => {
-    current.trainingStore = store.trainingStore;
-    current.tree = store.tree;
-  });
-}
-function updateTrainingStore(stateDir, mutate) {
-  mutateLedger(stateDir, (store) => {
-    mutate(store.trainingStore);
-  });
-}
-
-// src/core/principle-training-state.ts
-var PRINCIPLE_TRAINING_FILE2 = "principle_training_state.json";
-function createDefaultPrincipleState(principleId) {
-  return {
-    principleId,
-    evaluability: "manual_only",
-    applicableOpportunityCount: 0,
-    observedViolationCount: 0,
-    complianceRate: 0,
-    violationTrend: 0,
-    generatedSampleCount: 0,
-    approvedSampleCount: 0,
-    includedTrainRunIds: [],
-    deployedCheckpointIds: [],
-    internalizationStatus: "prompt_only"
-  };
-}
-function loadStore(stateDir) {
-  return ledgerTrainingStore(stateDir);
-}
-function saveStore(stateDir, store) {
-  const ledger = loadLedger(stateDir);
-  saveLedger(stateDir, {
-    ...ledger,
-    trainingStore: store
-  });
-}
-async function loadStoreAsync(stateDir) {
-  return ledgerTrainingStore(stateDir);
-}
-async function saveStoreAsync(stateDir, store) {
-  const ledger = loadLedger(stateDir);
-  await saveLedgerAsync(stateDir, {
-    ...ledger,
-    trainingStore: store
-  });
-}
-function getPrincipleState(stateDir, principleId) {
-  const store = loadStore(stateDir);
-  return store[principleId] ?? createDefaultPrincipleState(principleId);
-}
-function setPrincipleState(stateDir, state) {
-  updateTrainingStore(stateDir, (store) => {
-    store[state.principleId] = state;
-  });
-}
-function removePrincipleState(stateDir, principleId) {
-  updateTrainingStore(stateDir, (store) => {
-    delete store[principleId];
-  });
-}
-function listPrincipleIds(stateDir) {
-  return Object.keys(loadStore(stateDir));
-}
-function listPrinciplesByStatus(stateDir, status) {
-  return Object.values(loadStore(stateDir)).filter((state) => state.internalizationStatus === status);
-}
-function listEvaluablePrinciples(stateDir) {
-  return Object.values(loadStore(stateDir)).filter(
-    (state) => state.evaluability !== "manual_only" && state.internalizationStatus !== "prompt_only"
-  );
-}
-var VALID_TRANSITIONS = {
-  prompt_only: ["needs_training", "regressed"],
-  needs_training: ["in_training", "regressed"],
-  in_training: ["deployed_pending_eval", "regressed"],
-  deployed_pending_eval: ["internalized", "regressed"],
-  internalized: ["regressed"],
-  regressed: ["needs_training"]
-};
-function transitionInternalizationStatus(stateDir, principleId, nextStatus) {
-  updateTrainingStore(stateDir, (store) => {
-    const state = store[principleId];
-    if (!state) {
-      throw new Error(`Cannot transition: principle ${principleId} not found in training store`);
-    }
-    const allowed = VALID_TRANSITIONS[state.internalizationStatus] ?? [];
-    if (!allowed.includes(nextStatus)) {
-      throw new Error(
-        `Invalid transition: ${state.internalizationStatus} \u2192 ${nextStatus}. Allowed: ${allowed.join(", ") || "none (terminal state)"}`
-      );
-    }
-    state.internalizationStatus = nextStatus;
-  });
-}
-function ledgerTrainingStore(stateDir) {
-  return loadLedger(stateDir).trainingStore;
-}
-export {
-  PRINCIPLE_TRAINING_FILE2 as PRINCIPLE_TRAINING_FILE,
-  createDefaultPrincipleState,
-  getPrincipleState,
-  listEvaluablePrinciples,
-  listPrincipleIds,
-  listPrinciplesByStatus,
-  loadStore,
-  loadStoreAsync,
-  removePrincipleState,
-  saveStore,
-  saveStoreAsync,
-  setPrincipleState,
-  transitionInternalizationStatus
-};