chainlesschain 0.132.0 → 0.145.0

package/src/commands/webfetch.js

@@ -0,0 +1,150 @@
+/**
+ * `cc webfetch` — Web Fetch V2 governance overlay (in-memory, atop lib/web-fetch.js).
+ */
+import {
+  WFET_TARGET_MATURITY_V2,
+  WFET_JOB_LIFECYCLE_V2,
+  setMaxActiveWfetTargetsPerOwnerV2,
+  getMaxActiveWfetTargetsPerOwnerV2,
+  setMaxPendingWfetJobsPerTargetV2,
+  getMaxPendingWfetJobsPerTargetV2,
+  setWfetTargetIdleMsV2,
+  getWfetTargetIdleMsV2,
+  setWfetJobStuckMsV2,
+  getWfetJobStuckMsV2,
+  registerWfetTargetV2,
+  activateWfetTargetV2,
+  degradeWfetTargetV2,
+  retireWfetTargetV2,
+  touchWfetTargetV2,
+  getWfetTargetV2,
+  listWfetTargetsV2,
+  createWfetJobV2,
+  fetchingWfetJobV2,
+  succeedWfetJobV2,
+  failWfetJobV2,
+  cancelWfetJobV2,
+  getWfetJobV2,
+  listWfetJobsV2,
+  autoDegradeIdleWfetTargetsV2,
+  autoFailStuckWfetJobsV2,
+  getWebFetchGovStatsV2,
+  _resetStateWebFetchV2,
+} from "../lib/web-fetch.js";
+
+export function registerWebfetchCommand(program) {
+  const wf = program.command("webfetch").description("Web Fetch V2 governance");
+  wf.command("enums-v2").action(() =>
+    console.log(
+      JSON.stringify(
+        {
+          targetMaturity: WFET_TARGET_MATURITY_V2,
+          jobLifecycle: WFET_JOB_LIFECYCLE_V2,
+        },
+        null,
+        2,
+      ),
+    ),
+  );
+  wf.command("config-v2").action(() =>
+    console.log(
+      JSON.stringify(
+        {
+          maxActiveWfetTargetsPerOwner: getMaxActiveWfetTargetsPerOwnerV2(),
+          maxPendingWfetJobsPerTarget: getMaxPendingWfetJobsPerTargetV2(),
+          wfetTargetIdleMs: getWfetTargetIdleMsV2(),
+          wfetJobStuckMs: getWfetJobStuckMsV2(),
+        },
+        null,
+        2,
+      ),
+    ),
+  );
+  wf.command("set-max-active-v2 <n>").action((n) => {
+    setMaxActiveWfetTargetsPerOwnerV2(Number(n));
+    console.log("ok");
+  });
+  wf.command("set-max-pending-v2 <n>").action((n) => {
+    setMaxPendingWfetJobsPerTargetV2(Number(n));
+    console.log("ok");
+  });
+  wf.command("set-idle-ms-v2 <n>").action((n) => {
+    setWfetTargetIdleMsV2(Number(n));
+    console.log("ok");
+  });
+  wf.command("set-stuck-ms-v2 <n>").action((n) => {
+    setWfetJobStuckMsV2(Number(n));
+    console.log("ok");
+  });
+  wf.command("register-target-v2 <id> <owner>")
+    .option("--baseUrl <u>", "baseUrl")
+    .action((id, owner, o) =>
+      console.log(
+        JSON.stringify(
+          registerWfetTargetV2({ id, owner, baseUrl: o.baseUrl }),
+          null,
+          2,
+        ),
+      ),
+    );
+  wf.command("activate-target-v2 <id>").action((id) =>
+    console.log(JSON.stringify(activateWfetTargetV2(id), null, 2)),
+  );
+  wf.command("degrade-target-v2 <id>").action((id) =>
+    console.log(JSON.stringify(degradeWfetTargetV2(id), null, 2)),
+  );
+  wf.command("retire-target-v2 <id>").action((id) =>
+    console.log(JSON.stringify(retireWfetTargetV2(id), null, 2)),
+  );
+  wf.command("touch-target-v2 <id>").action((id) =>
+    console.log(JSON.stringify(touchWfetTargetV2(id), null, 2)),
+  );
+  wf.command("get-target-v2 <id>").action((id) =>
+    console.log(JSON.stringify(getWfetTargetV2(id), null, 2)),
+  );
+  wf.command("list-targets-v2").action(() =>
+    console.log(JSON.stringify(listWfetTargetsV2(), null, 2)),
+  );
+  wf.command("create-job-v2 <id> <targetId>")
+    .option("--kind <k>", "kind", "GET")
+    .action((id, targetId, o) =>
+      console.log(
+        JSON.stringify(
+          createWfetJobV2({ id, targetId, kind: o.kind }),
+          null,
+          2,
+        ),
+      ),
+    );
+  wf.command("fetching-job-v2 <id>").action((id) =>
+    console.log(JSON.stringify(fetchingWfetJobV2(id), null, 2)),
+  );
+  wf.command("succeed-job-v2 <id>").action((id) =>
+    console.log(JSON.stringify(succeedWfetJobV2(id), null, 2)),
+  );
+  wf.command("fail-job-v2 <id> [reason]").action((id, reason) =>
+    console.log(JSON.stringify(failWfetJobV2(id, reason), null, 2)),
+  );
+  wf.command("cancel-job-v2 <id> [reason]").action((id, reason) =>
+    console.log(JSON.stringify(cancelWfetJobV2(id, reason), null, 2)),
+  );
+  wf.command("get-job-v2 <id>").action((id) =>
+    console.log(JSON.stringify(getWfetJobV2(id), null, 2)),
+  );
+  wf.command("list-jobs-v2").action(() =>
+    console.log(JSON.stringify(listWfetJobsV2(), null, 2)),
+  );
+  wf.command("auto-degrade-idle-v2").action(() =>
+    console.log(JSON.stringify(autoDegradeIdleWfetTargetsV2(), null, 2)),
+  );
+  wf.command("auto-fail-stuck-v2").action(() =>
+    console.log(JSON.stringify(autoFailStuckWfetJobsV2(), null, 2)),
+  );
+  wf.command("gov-stats-v2").action(() =>
+    console.log(JSON.stringify(getWebFetchGovStatsV2(), null, 2)),
+  );
+  wf.command("reset-state-v2").action(() => {
+    _resetStateWebFetchV2();
+    console.log(JSON.stringify({ ok: true }, null, 2));
+  });
+}

package/src/commands/zkp.js

@@ -835,4 +835,222 @@ export function registerZkpCommand(program) {
         process.exit(1);
       }
     });
+  registerZkpV2Command(zkp);
+}
+
+import {
+  ZKP_CIRCUIT_MATURITY_V2,
+  ZKP_PROOF_LIFECYCLE_V2,
+  registerZkpCircuitV2,
+  activateZkpCircuitV2,
+  deprecateZkpCircuitV2,
+  archiveZkpCircuitV2,
+  touchZkpCircuitV2,
+  getZkpCircuitV2,
+  listZkpCircuitsV2,
+  createZkpProofV2,
+  startZkpProofV2,
+  verifyZkpProofV2,
+  failZkpProofV2,
+  cancelZkpProofV2,
+  getZkpProofV2,
+  listZkpProofsV2,
+  setMaxActiveZkpCircuitsPerOwnerV2,
+  getMaxActiveZkpCircuitsPerOwnerV2,
+  setMaxPendingZkpProofsPerCircuitV2,
+  getMaxPendingZkpProofsPerCircuitV2,
+  setZkpCircuitIdleMsV2,
+  getZkpCircuitIdleMsV2,
+  setZkpProofStuckMsV2,
+  getZkpProofStuckMsV2,
+  autoDeprecateIdleZkpCircuitsV2,
+  autoFailStuckZkpProofsV2,
+  getZkpEngineGovStatsV2,
+} from "../lib/zkp-engine.js";
+
+export function registerZkpV2Command(zkp) {
+  zkp
+    .command("enums-v2")
+    .description("Show V2 governance enums")
+    .action(() => {
+      console.log(
+        JSON.stringify(
+          { ZKP_CIRCUIT_MATURITY_V2, ZKP_PROOF_LIFECYCLE_V2 },
+          null,
+          2,
+        ),
+      );
+    });
+  zkp
+    .command("register-circuit-v2")
+    .description("Register a zkp circuit profile (pending)")
+    .requiredOption("--id <id>")
+    .requiredOption("--owner <owner>")
+    .option("--scheme <scheme>")
+    .action((o) => {
+      console.log(
+        JSON.stringify(
+          registerZkpCircuitV2({ id: o.id, owner: o.owner, scheme: o.scheme }),
+          null,
+          2,
+        ),
+      );
+    });
+  zkp
+    .command("activate-circuit-v2 <id>")
+    .description("Activate circuit")
+    .action((id) => {
+      console.log(JSON.stringify(activateZkpCircuitV2(id), null, 2));
+    });
+  zkp
+    .command("deprecate-circuit-v2 <id>")
+    .description("Deprecate circuit")
+    .action((id) => {
+      console.log(JSON.stringify(deprecateZkpCircuitV2(id), null, 2));
+    });
+  zkp
+    .command("archive-circuit-v2 <id>")
+    .description("Archive circuit (terminal)")
+    .action((id) => {
+      console.log(JSON.stringify(archiveZkpCircuitV2(id), null, 2));
+    });
+  zkp
+    .command("touch-circuit-v2 <id>")
+    .description("Refresh lastTouchedAt")
+    .action((id) => {
+      console.log(JSON.stringify(touchZkpCircuitV2(id), null, 2));
+    });
+  zkp
+    .command("get-circuit-v2 <id>")
+    .description("Get circuit")
+    .action((id) => {
+      console.log(JSON.stringify(getZkpCircuitV2(id), null, 2));
+    });
+  zkp
+    .command("list-circuits-v2")
+    .description("List circuits")
+    .action(() => {
+      console.log(JSON.stringify(listZkpCircuitsV2(), null, 2));
+    });
+  zkp
+    .command("create-proof-v2")
+    .description("Create a zkp proof (queued)")
+    .requiredOption("--id <id>")
+    .requiredOption("--circuit-id <circuitId>")
+    .option("--inputs <inputs>")
+    .action((o) => {
+      console.log(
+        JSON.stringify(
+          createZkpProofV2({
+            id: o.id,
+            circuitId: o.circuitId,
+            inputs: o.inputs,
+          }),
+          null,
+          2,
+        ),
+      );
+    });
+  zkp
+    .command("start-proof-v2 <id>")
+    .description("Transition proof to proving")
+    .action((id) => {
+      console.log(JSON.stringify(startZkpProofV2(id), null, 2));
+    });
+  zkp
+    .command("verify-proof-v2 <id>")
+    .description("Transition proof to verified")
+    .action((id) => {
+      console.log(JSON.stringify(verifyZkpProofV2(id), null, 2));
+    });
+  zkp
+    .command("fail-proof-v2 <id>")
+    .description("Fail proof")
+    .option("--reason <r>")
+    .action((id, o) => {
+      console.log(JSON.stringify(failZkpProofV2(id, o.reason), null, 2));
+    });
+  zkp
+    .command("cancel-proof-v2 <id>")
+    .description("Cancel proof")
+    .option("--reason <r>")
+    .action((id, o) => {
+      console.log(JSON.stringify(cancelZkpProofV2(id, o.reason), null, 2));
+    });
+  zkp
+    .command("get-proof-v2 <id>")
+    .description("Get proof")
+    .action((id) => {
+      console.log(JSON.stringify(getZkpProofV2(id), null, 2));
+    });
+  zkp
+    .command("list-proofs-v2")
+    .description("List proofs")
+    .action(() => {
+      console.log(JSON.stringify(listZkpProofsV2(), null, 2));
+    });
+  zkp
+    .command("set-max-active-circuits-v2 <n>")
+    .description("Set per-owner active cap")
+    .action((n) => {
+      setMaxActiveZkpCircuitsPerOwnerV2(Number(n));
+      console.log(
+        JSON.stringify(
+          { maxActiveZkpCircuitsPerOwner: getMaxActiveZkpCircuitsPerOwnerV2() },
+          null,
+          2,
+        ),
+      );
+    });
+  zkp
+    .command("set-max-pending-proofs-v2 <n>")
+    .description("Set per-circuit pending cap")
+    .action((n) => {
+      setMaxPendingZkpProofsPerCircuitV2(Number(n));
+      console.log(
+        JSON.stringify(
+          {
+            maxPendingZkpProofsPerCircuit: getMaxPendingZkpProofsPerCircuitV2(),
+          },
+          null,
+          2,
+        ),
+      );
+    });
+  zkp
+    .command("set-circuit-idle-ms-v2 <n>")
+    .description("Set idle threshold")
+    .action((n) => {
+      setZkpCircuitIdleMsV2(Number(n));
+      console.log(
+        JSON.stringify({ zkpCircuitIdleMs: getZkpCircuitIdleMsV2() }, null, 2),
+      );
+    });
+  zkp
+    .command("set-proof-stuck-ms-v2 <n>")
+    .description("Set stuck threshold")
+    .action((n) => {
+      setZkpProofStuckMsV2(Number(n));
+      console.log(
+        JSON.stringify({ zkpProofStuckMs: getZkpProofStuckMsV2() }, null, 2),
+      );
+    });
+  zkp
+    .command("auto-deprecate-idle-circuits-v2")
+    .description("Auto-deprecate idle circuits")
+    .action(() => {
+      console.log(JSON.stringify(autoDeprecateIdleZkpCircuitsV2(), null, 2));
+    });
+  zkp
+    .command("auto-fail-stuck-proofs-v2")
+    .description("Auto-fail stuck proving proofs")
+    .action(() => {
+      console.log(JSON.stringify(autoFailStuckZkpProofsV2(), null, 2));
+    });
+  zkp
+    .command("gov-stats-v2")
+    .description("V2 governance aggregate stats")
+    .action(() => {
+      console.log(JSON.stringify(getZkpEngineGovStatsV2(), null, 2));
+    });
 }

package/src/harness/prompt-compressor.js

@@ -414,3 +414,334 @@ export class PromptCompressor {
     return result;
   }
 }
+
+
+// =====================================================================
+// Prompt Compressor V2 governance overlay
+// =====================================================================
+export const PCOMP_PROFILE_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  STALE: "stale",
+  ARCHIVED: "archived",
+});
+export const PCOMP_RUN_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  COMPRESSING: "compressing",
+  COMPRESSED: "compressed",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+const _pcompPTrans = new Map([
+  [
+    PCOMP_PROFILE_MATURITY_V2.PENDING,
+    new Set([
+      PCOMP_PROFILE_MATURITY_V2.ACTIVE,
+      PCOMP_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [
+    PCOMP_PROFILE_MATURITY_V2.ACTIVE,
+    new Set([
+      PCOMP_PROFILE_MATURITY_V2.STALE,
+      PCOMP_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [
+    PCOMP_PROFILE_MATURITY_V2.STALE,
+    new Set([
+      PCOMP_PROFILE_MATURITY_V2.ACTIVE,
+      PCOMP_PROFILE_MATURITY_V2.ARCHIVED,
+    ]),
+  ],
+  [PCOMP_PROFILE_MATURITY_V2.ARCHIVED, new Set()],
+]);
+const _pcompPTerminal = new Set([PCOMP_PROFILE_MATURITY_V2.ARCHIVED]);
+const _pcompRTrans = new Map([
+  [
+    PCOMP_RUN_LIFECYCLE_V2.QUEUED,
+    new Set([
+      PCOMP_RUN_LIFECYCLE_V2.COMPRESSING,
+      PCOMP_RUN_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [
+    PCOMP_RUN_LIFECYCLE_V2.COMPRESSING,
+    new Set([
+      PCOMP_RUN_LIFECYCLE_V2.COMPRESSED,
+      PCOMP_RUN_LIFECYCLE_V2.FAILED,
+      PCOMP_RUN_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [PCOMP_RUN_LIFECYCLE_V2.COMPRESSED, new Set()],
+  [PCOMP_RUN_LIFECYCLE_V2.FAILED, new Set()],
+  [PCOMP_RUN_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+const _pcompPsV2 = new Map();
+const _pcompRsV2 = new Map();
+let _pcompMaxActive = 8,
+  _pcompMaxPending = 20,
+  _pcompIdleMs = 30 * 24 * 60 * 60 * 1000,
+  _pcompStuckMs = 60 * 1000;
+function _pcompPos(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0)
+    throw new Error(`${label} must be positive integer`);
+  return v;
+}
+function _pcompCheckP(from, to) {
+  const a = _pcompPTrans.get(from);
+  if (!a || !a.has(to))
+    throw new Error(`invalid pcomp profile transition ${from} → ${to}`);
+}
+function _pcompCheckR(from, to) {
+  const a = _pcompRTrans.get(from);
+  if (!a || !a.has(to))
+    throw new Error(`invalid pcomp run transition ${from} → ${to}`);
+}
+function _pcompCountActive(owner) {
+  let c = 0;
+  for (const p of _pcompPsV2.values())
+    if (p.owner === owner && p.status === PCOMP_PROFILE_MATURITY_V2.ACTIVE) c++;
+  return c;
+}
+function _pcompCountPending(profileId) {
+  let c = 0;
+  for (const r of _pcompRsV2.values())
+    if (
+      r.profileId === profileId &&
+      (r.status === PCOMP_RUN_LIFECYCLE_V2.QUEUED ||
+        r.status === PCOMP_RUN_LIFECYCLE_V2.COMPRESSING)
+    )
+      c++;
+  return c;
+}
+export function setMaxActivePcompProfilesPerOwnerV2(n) {
+  _pcompMaxActive = _pcompPos(n, "maxActivePcompProfilesPerOwner");
+}
+export function getMaxActivePcompProfilesPerOwnerV2() {
+  return _pcompMaxActive;
+}
+export function setMaxPendingPcompRunsPerProfileV2(n) {
+  _pcompMaxPending = _pcompPos(n, "maxPendingPcompRunsPerProfile");
+}
+export function getMaxPendingPcompRunsPerProfileV2() {
+  return _pcompMaxPending;
+}
+export function setPcompProfileIdleMsV2(n) {
+  _pcompIdleMs = _pcompPos(n, "pcompProfileIdleMs");
+}
+export function getPcompProfileIdleMsV2() {
+  return _pcompIdleMs;
+}
+export function setPcompRunStuckMsV2(n) {
+  _pcompStuckMs = _pcompPos(n, "pcompRunStuckMs");
+}
+export function getPcompRunStuckMsV2() {
+  return _pcompStuckMs;
+}
+export function _resetStatePromptCompressorV2() {
+  _pcompPsV2.clear();
+  _pcompRsV2.clear();
+  _pcompMaxActive = 8;
+  _pcompMaxPending = 20;
+  _pcompIdleMs = 30 * 24 * 60 * 60 * 1000;
+  _pcompStuckMs = 60 * 1000;
+}
+export function registerPcompProfileV2({ id, owner, variant, metadata } = {}) {
+  if (!id || !owner) throw new Error("id and owner required");
+  if (_pcompPsV2.has(id)) throw new Error(`pcomp profile ${id} already exists`);
+  const now = Date.now();
+  const p = {
+    id,
+    owner,
+    variant: variant || "default",
+    status: PCOMP_PROFILE_MATURITY_V2.PENDING,
+    createdAt: now,
+    updatedAt: now,
+    lastTouchedAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: { ...(metadata || {}) },
+  };
+  _pcompPsV2.set(id, p);
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function activatePcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  const isInitial = p.status === PCOMP_PROFILE_MATURITY_V2.PENDING;
+  _pcompCheckP(p.status, PCOMP_PROFILE_MATURITY_V2.ACTIVE);
+  if (isInitial && _pcompCountActive(p.owner) >= _pcompMaxActive)
+    throw new Error(`max active pcomp profiles for owner ${p.owner} reached`);
+  const now = Date.now();
+  p.status = PCOMP_PROFILE_MATURITY_V2.ACTIVE;
+  p.updatedAt = now;
+  p.lastTouchedAt = now;
+  if (!p.activatedAt) p.activatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function stalePcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  _pcompCheckP(p.status, PCOMP_PROFILE_MATURITY_V2.STALE);
+  p.status = PCOMP_PROFILE_MATURITY_V2.STALE;
+  p.updatedAt = Date.now();
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function archivePcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  _pcompCheckP(p.status, PCOMP_PROFILE_MATURITY_V2.ARCHIVED);
+  const now = Date.now();
+  p.status = PCOMP_PROFILE_MATURITY_V2.ARCHIVED;
+  p.updatedAt = now;
+  if (!p.archivedAt) p.archivedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function touchPcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) throw new Error(`pcomp profile ${id} not found`);
+  if (_pcompPTerminal.has(p.status))
+    throw new Error(`cannot touch terminal pcomp profile ${id}`);
+  const now = Date.now();
+  p.lastTouchedAt = now;
+  p.updatedAt = now;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function getPcompProfileV2(id) {
+  const p = _pcompPsV2.get(id);
+  if (!p) return null;
+  return { ...p, metadata: { ...p.metadata } };
+}
+export function listPcompProfilesV2() {
+  return [..._pcompPsV2.values()].map((p) => ({
+    ...p,
+    metadata: { ...p.metadata },
+  }));
+}
+export function createPcompRunV2({ id, profileId, input, metadata } = {}) {
+  if (!id || !profileId) throw new Error("id and profileId required");
+  if (_pcompRsV2.has(id)) throw new Error(`pcomp run ${id} already exists`);
+  if (!_pcompPsV2.has(profileId))
+    throw new Error(`pcomp profile ${profileId} not found`);
+  if (_pcompCountPending(profileId) >= _pcompMaxPending)
+    throw new Error(`max pending pcomp runs for profile ${profileId} reached`);
+  const now = Date.now();
+  const r = {
+    id,
+    profileId,
+    input: input || "",
+    status: PCOMP_RUN_LIFECYCLE_V2.QUEUED,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: null,
+    settledAt: null,
+    metadata: { ...(metadata || {}) },
+  };
+  _pcompRsV2.set(id, r);
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function compressingPcompRunV2(id) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.COMPRESSING);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.COMPRESSING;
+  r.updatedAt = now;
+  if (!r.startedAt) r.startedAt = now;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function compressPcompRunV2(id) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.COMPRESSED);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.COMPRESSED;
+  r.updatedAt = now;
+  if (!r.settledAt) r.settledAt = now;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function failPcompRunV2(id, reason) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.FAILED);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.FAILED;
+  r.updatedAt = now;
+  if (!r.settledAt) r.settledAt = now;
+  if (reason) r.metadata.failReason = String(reason);
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function cancelPcompRunV2(id, reason) {
+  const r = _pcompRsV2.get(id);
+  if (!r) throw new Error(`pcomp run ${id} not found`);
+  _pcompCheckR(r.status, PCOMP_RUN_LIFECYCLE_V2.CANCELLED);
+  const now = Date.now();
+  r.status = PCOMP_RUN_LIFECYCLE_V2.CANCELLED;
+  r.updatedAt = now;
+  if (!r.settledAt) r.settledAt = now;
+  if (reason) r.metadata.cancelReason = String(reason);
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function getPcompRunV2(id) {
+  const r = _pcompRsV2.get(id);
+  if (!r) return null;
+  return { ...r, metadata: { ...r.metadata } };
+}
+export function listPcompRunsV2() {
+  return [..._pcompRsV2.values()].map((r) => ({
+    ...r,
+    metadata: { ...r.metadata },
+  }));
+}
+export function autoStaleIdlePcompProfilesV2({ now } = {}) {
+  const t = now ?? Date.now();
+  const flipped = [];
+  for (const p of _pcompPsV2.values())
+    if (
+      p.status === PCOMP_PROFILE_MATURITY_V2.ACTIVE &&
+      t - p.lastTouchedAt >= _pcompIdleMs
+    ) {
+      p.status = PCOMP_PROFILE_MATURITY_V2.STALE;
+      p.updatedAt = t;
+      flipped.push(p.id);
+    }
+  return { flipped, count: flipped.length };
+}
+export function autoFailStuckPcompRunsV2({ now } = {}) {
+  const t = now ?? Date.now();
+  const flipped = [];
+  for (const r of _pcompRsV2.values())
+    if (
+      r.status === PCOMP_RUN_LIFECYCLE_V2.COMPRESSING &&
+      r.startedAt != null &&
+      t - r.startedAt >= _pcompStuckMs
+    ) {
+      r.status = PCOMP_RUN_LIFECYCLE_V2.FAILED;
+      r.updatedAt = t;
+      if (!r.settledAt) r.settledAt = t;
+      r.metadata.failReason = "auto-fail-stuck";
+      flipped.push(r.id);
+    }
+  return { flipped, count: flipped.length };
+}
+export function getPromptCompressorGovStatsV2() {
+  const profilesByStatus = {};
+  for (const v of Object.values(PCOMP_PROFILE_MATURITY_V2))
+    profilesByStatus[v] = 0;
+  for (const p of _pcompPsV2.values()) profilesByStatus[p.status]++;
+  const runsByStatus = {};
+  for (const v of Object.values(PCOMP_RUN_LIFECYCLE_V2)) runsByStatus[v] = 0;
+  for (const r of _pcompRsV2.values()) runsByStatus[r.status]++;
+  return {
+    totalPcompProfilesV2: _pcompPsV2.size,
+    totalPcompRunsV2: _pcompRsV2.size,
+    maxActivePcompProfilesPerOwner: _pcompMaxActive,
+    maxPendingPcompRunsPerProfile: _pcompMaxPending,
+    pcompProfileIdleMs: _pcompIdleMs,
+    pcompRunStuckMs: _pcompStuckMs,
+    profilesByStatus,
+    runsByStatus,
+  };
+}