chainlesschain 0.66.0 → 0.132.0

package/src/commands/privacy.js

@@ -23,6 +23,32 @@ import {
   dpPublish,
   heQuery,
   getPrivacyReport,
+  // V2 surface
+  FL_STATUS_V2,
+  MPC_STATUS_V2,
+  DP_MECHANISM_V2,
+  HE_SCHEME_V2,
+  MPC_PROTOCOL_V2,
+  PRIVACY_DEFAULT_MAX_ACTIVE_MPC_COMPUTATIONS,
+  setMaxActiveMpcComputations,
+  getMaxActiveMpcComputations,
+  getActiveMpcCount,
+  setPrivacyBudgetLimit,
+  getPrivacyBudgetLimit,
+  getPrivacyBudgetSpent,
+  resetPrivacyBudget,
+  createModelV2,
+  trainRoundV2,
+  aggregateRound,
+  failModelV2,
+  setFLStatusV2,
+  createComputationV2,
+  submitShareV2,
+  failComputation,
+  setMPCStatusV2,
+  dpPublishV2,
+  heQueryV2,
+  getPrivacyStatsV2,
 } from "../lib/privacy-computing.js";
 
 function _dbFromCtx(cmd) {
@@ -341,5 +367,300 @@ export function registerPrivacyCommand(program) {
       );
     });
 
+  /* ──────────────────────────────────────────────────────────
+   *  V2 — Phase 91
+   * ────────────────────────────────────────────────────────── */
+
+  pc.command("fl-statuses-v2")
+    .description("List V2 FL statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(FL_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("mpc-statuses-v2")
+    .description("List V2 MPC statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(MPC_STATUS_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("dp-mechanisms-v2")
+    .description("List V2 DP mechanisms")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(DP_MECHANISM_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("he-schemes-v2")
+    .description("List V2 HE schemes")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(HE_SCHEME_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("mpc-protocols-v2")
+    .description("List V2 MPC protocols")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(MPC_PROTOCOL_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      v.forEach((s) => console.log(s));
+    });
+
+  pc.command("default-max-active-mpc")
+    .description("Show V2 default max active MPC computations")
+    .action(() =>
+      console.log(String(PRIVACY_DEFAULT_MAX_ACTIVE_MPC_COMPUTATIONS)),
+    );
+
+  pc.command("max-active-mpc")
+    .description("Show current max active MPC computations")
+    .action(() => console.log(String(getMaxActiveMpcComputations())));
+
+  pc.command("active-mpc-count")
+    .description("Show currently-active MPC computation count")
+    .action(() => console.log(String(getActiveMpcCount())));
+
+  pc.command("set-max-active-mpc <n>")
+    .description("Set max concurrent active MPC computations")
+    .action((n) => {
+      setMaxActiveMpcComputations(Number(n));
+      console.log(`max-active-mpc = ${getMaxActiveMpcComputations()}`);
+    });
+
+  pc.command("budget-limit")
+    .description("Show privacy budget limit")
+    .action(() => console.log(String(getPrivacyBudgetLimit())));
+
+  pc.command("budget-spent")
+    .description("Show privacy budget spent")
+    .action(() => console.log(String(getPrivacyBudgetSpent())));
+
+  pc.command("set-budget-limit <n>")
+    .description("Set privacy budget limit")
+    .action((n) => {
+      setPrivacyBudgetLimit(Number(n));
+      console.log(`budget-limit = ${getPrivacyBudgetLimit()}`);
+    });
+
+  pc.command("reset-budget")
+    .description("Reset privacy budget spent counter to 0")
+    .action(() => {
+      resetPrivacyBudget();
+      console.log("budget reset");
+    });
+
+  pc.command("create-model-v2 <name>")
+    .description("V2 create FL model (throws on invalid input)")
+    .option("-t, --total-rounds <n>", "Total rounds (default 10)")
+    .option("-l, --learning-rate <n>", "Learning rate (default 0.01)")
+    .option("-a, --architecture <arch>", "Architecture")
+    .option("-m, --model-type <type>", "Model type")
+    .option("--json", "JSON output")
+    .action((name, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = createModelV2(db, {
+        name,
+        totalRounds: opts.totalRounds ? Number(opts.totalRounds) : undefined,
+        learningRate: opts.learningRate ? Number(opts.learningRate) : undefined,
+        architecture: opts.architecture,
+        modelType: opts.modelType,
+      });
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model: ${m.id} (${m.name}, rounds=${m.total_rounds})`);
+    });
+
+  pc.command("train-round-v2 <model-id>")
+    .description("V2 train one FL round (auto initializing → training)")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = trainRoundV2(db, id);
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(
+        `Round ${m.current_round}/${m.total_rounds}  status=${m.status}  acc=${m.accuracy}`,
+      );
+    });
+
+  pc.command("aggregate-round <model-id>")
+    .description("Aggregate FL round (training → training next / completed)")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = aggregateRound(db, id);
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model ${m.id} status=${m.status} round=${m.current_round}`);
+    });
+
+  pc.command("fail-model-v2 <model-id>")
+    .description("V2 fail FL model (any non-terminal → failed)")
+    .option("-e, --error <msg>", "Error message")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const m = failModelV2(db, id, { error: opts.error });
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model ${m.id} failed: ${m.error_message || ""}`);
+    });
+
+  pc.command("set-fl-status <model-id> <status>")
+    .description("V2 state-machine guarded FL status setter")
+    .option("-a, --accuracy <n>")
+    .option("-l, --loss <n>")
+    .option("-e, --error <msg>")
+    .option("--json", "JSON output")
+    .action((id, status, opts) => {
+      const db = _dbFromCtx(pc);
+      const patch = {};
+      if (opts.accuracy !== undefined) patch.accuracy = Number(opts.accuracy);
+      if (opts.loss !== undefined) patch.loss = Number(opts.loss);
+      if (opts.error !== undefined) patch.errorMessage = opts.error;
+      const m = setFLStatusV2(db, id, status, patch);
+      if (opts.json) return console.log(JSON.stringify(m, null, 2));
+      console.log(`Model ${m.id} status=${m.status}`);
+    });
+
+  pc.command("create-computation-v2 <type>")
+    .description("V2 create MPC computation (throws on invalid input)")
+    .option("-p, --protocol <proto>", "Protocol (shamir|beaver|gmw)")
+    .option("-i, --participants <csv>", "Comma-separated participant IDs")
+    .option("-s, --shares-required <n>", "Shares required")
+    .option("--json", "JSON output")
+    .action((type, opts) => {
+      const db = _dbFromCtx(pc);
+      const ids = opts.participants
+        ? opts.participants
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
+      const c = createComputationV2(db, {
+        computationType: type,
+        protocol: opts.protocol,
+        participantIds: ids,
+        sharesRequired: opts.sharesRequired
+          ? Number(opts.sharesRequired)
+          : undefined,
+      });
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(
+        `Computation: ${c.id}  protocol=${c.protocol}  required=${c.shares_required}`,
+      );
+    });
+
+  pc.command("submit-share-v2 <comp-id>")
+    .description("V2 submit MPC share (state-guarded)")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const c = submitShareV2(db, id);
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(
+        `Comp ${c.id} shares=${c.shares_received}/${c.shares_required} status=${c.status}`,
+      );
+    });
+
+  pc.command("fail-computation <comp-id>")
+    .description("Fail MPC computation (any non-terminal → failed)")
+    .option("-e, --error <msg>")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const db = _dbFromCtx(pc);
+      const c = failComputation(db, id, { error: opts.error });
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(`Comp ${c.id} failed: ${c.error_message || ""}`);
+    });
+
+  pc.command("set-mpc-status <comp-id> <status>")
+    .description("V2 state-machine guarded MPC status setter")
+    .option("-h, --result-hash <hash>")
+    .option("-e, --error <msg>")
+    .option("--json", "JSON output")
+    .action((id, status, opts) => {
+      const db = _dbFromCtx(pc);
+      const patch = {};
+      if (opts.resultHash !== undefined) patch.resultHash = opts.resultHash;
+      if (opts.error !== undefined) patch.errorMessage = opts.error;
+      const c = setMPCStatusV2(db, id, status, patch);
+      if (opts.json) return console.log(JSON.stringify(c, null, 2));
+      console.log(`Comp ${c.id} status=${c.status}`);
+    });
+
+  pc.command("dp-publish-v2")
+    .description("V2 DP publish (throws on invalid input / exceeded budget)")
+    .requiredOption("-d, --data <n>", "Data value", Number)
+    .option("-e, --epsilon <n>", "Epsilon", Number)
+    .option("--delta <n>", "Delta", Number)
+    .option("-m, --mechanism <mech>", "Mechanism")
+    .option("-s, --sensitivity <n>", "Sensitivity", Number)
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(pc);
+      const r = dpPublishV2(db, {
+        data: opts.data,
+        epsilon: opts.epsilon,
+        delta: opts.delta,
+        mechanism: opts.mechanism,
+        sensitivity: opts.sensitivity,
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(
+        `Published: orig=${r.originalValue}  noised=${r.noisedValue}  ε=${r.epsilon}`,
+      );
+    });
+
+  pc.command("he-query-v2")
+    .description("V2 HE query (throws on invalid input)")
+    .requiredOption("-o, --operation <op>", "sum|product|mean|count")
+    .requiredOption("-d, --data <json>", "JSON array of numbers")
+    .option("-s, --scheme <scheme>", "Scheme")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      let data;
+      try {
+        data = JSON.parse(opts.data);
+      } catch (_e) {
+        throw new Error("Invalid --data JSON");
+      }
+      const r = heQueryV2({
+        data,
+        operation: opts.operation,
+        scheme: opts.scheme,
+      });
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(
+        `Result: ${r.result}  (${r.operation} over ${r.inputCount} items, scheme=${r.scheme})`,
+      );
+    });
+
+  pc.command("stats-v2")
+    .description("V2 all-enum-key zero-init stats")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const s = getPrivacyStatsV2();
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(
+        `Models: ${s.totalModels}  Computations: ${s.totalComputations}`,
+      );
+      console.log(
+        `Active MPC: ${s.activeMpcCount}/${s.maxActiveMpcComputations}`,
+      );
+      console.log(
+        `Budget: ${s.budget.spent}/${s.budget.limit} (${s.budget.remaining} remaining)`,
+      );
+      console.log(
+        `Avg accuracy: ${s.avgAccuracy}  Avg comp time ms: ${s.avgComputationTimeMs}`,
+      );
+    });
+
   program.addCommand(pc);
 }

package/src/commands/quantization.js

@@ -20,8 +20,51 @@ import {
   cancelJob,
   deleteJob,
   getQuantizationStats,
+  /* V2 (Phase 20) */
+  MODEL_MATURITY_V2,
+  JOB_TICKET_V2,
+  getDefaultMaxActiveModelsPerOwnerV2,
+  getMaxActiveModelsPerOwnerV2,
+  setMaxActiveModelsPerOwnerV2,
+  getDefaultMaxRunningJobsPerOwnerV2,
+  getMaxRunningJobsPerOwnerV2,
+  setMaxRunningJobsPerOwnerV2,
+  getDefaultModelIdleMsV2,
+  getModelIdleMsV2,
+  setModelIdleMsV2,
+  getDefaultJobStuckMsV2,
+  getJobStuckMsV2,
+  setJobStuckMsV2,
+  registerModelV2,
+  getModelV2,
+  setModelMaturityV2,
+  activateModel,
+  deprecateModel,
+  retireModel,
+  touchModelUsage,
+  enqueueJobTicketV2,
+  getJobTicketV2,
+  setJobTicketStatusV2,
+  startJobTicket,
+  completeJobTicket,
+  failJobTicket,
+  cancelJobTicket,
+  getActiveModelCount,
+  getRunningJobCount,
+  autoRetireIdleModels,
+  autoFailStuckJobTickets,
+  getQuantizationStatsV2,
 } from "../lib/quantization.js";
 
+function _parseMetaV2(s) {
+  if (!s) return undefined;
+  try {
+    return JSON.parse(s);
+  } catch {
+    throw new Error(`--metadata must be valid JSON`);
+  }
+}
+
 function _dbFromCtx(cmd) {
   const root = cmd?.parent?.parent ?? cmd?.parent;
   return root?._db;
@@ -276,5 +319,313 @@ export function registerQuantizationCommand(program) {
         console.log(`Avg duration: ${s.avgDurationMs}ms`);
     });
 
+  /* ═════════════════════════════════════════════════════ *
+   *  Phase 20 V2 — Model Maturity + Job Ticket Lifecycle
+   * ═════════════════════════════════════════════════════ */
+
+  quant
+    .command("model-maturities-v2")
+    .description("List Phase 20 V2 model maturity states")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(MODEL_MATURITY_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      for (const s of v) console.log(s);
+    });
+
+  quant
+    .command("job-ticket-lifecycles-v2")
+    .description("List Phase 20 V2 job-ticket lifecycle states")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(JOB_TICKET_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      for (const s of v) console.log(s);
+    });
+
+  quant
+    .command("default-max-active-models-per-owner")
+    .description("Show default V2 per-owner active-model cap")
+    .action(() => console.log(getDefaultMaxActiveModelsPerOwnerV2()));
+
+  quant
+    .command("max-active-models-per-owner")
+    .description("Show current V2 per-owner active-model cap")
+    .action(() => console.log(getMaxActiveModelsPerOwnerV2()));
+
+  quant
+    .command("set-max-active-models-per-owner <n>")
+    .description("Set V2 per-owner active-model cap")
+    .action((n) => console.log(setMaxActiveModelsPerOwnerV2(n)));
+
+  quant
+    .command("default-max-running-jobs-per-owner")
+    .description("Show default V2 per-owner running-job cap")
+    .action(() => console.log(getDefaultMaxRunningJobsPerOwnerV2()));
+
+  quant
+    .command("max-running-jobs-per-owner")
+    .description("Show current V2 per-owner running-job cap")
+    .action(() => console.log(getMaxRunningJobsPerOwnerV2()));
+
+  quant
+    .command("set-max-running-jobs-per-owner <n>")
+    .description("Set V2 per-owner running-job cap")
+    .action((n) => console.log(setMaxRunningJobsPerOwnerV2(n)));
+
+  quant
+    .command("default-model-idle-ms")
+    .description("Show default V2 model-idle threshold")
+    .action(() => console.log(getDefaultModelIdleMsV2()));
+
+  quant
+    .command("model-idle-ms")
+    .description("Show current V2 model-idle threshold")
+    .action(() => console.log(getModelIdleMsV2()));
+
+  quant
+    .command("set-model-idle-ms <ms>")
+    .description("Set V2 model-idle threshold (ms)")
+    .action((ms) => console.log(setModelIdleMsV2(ms)));
+
+  quant
+    .command("default-job-stuck-ms")
+    .description("Show default V2 job-stuck threshold")
+    .action(() => console.log(getDefaultJobStuckMsV2()));
+
+  quant
+    .command("job-stuck-ms")
+    .description("Show current V2 job-stuck threshold")
+    .action(() => console.log(getJobStuckMsV2()));
+
+  quant
+    .command("set-job-stuck-ms <ms>")
+    .description("Set V2 job-stuck threshold (ms)")
+    .action((ms) => console.log(setJobStuckMsV2(ms)));
+
+  quant
+    .command("active-model-count")
+    .description("Count active V2 models (optionally scoped by owner)")
+    .option("-o, --owner <id>", "Owner ID")
+    .action((opts) => console.log(getActiveModelCount(opts.owner)));
+
+  quant
+    .command("running-job-count")
+    .description("Count running V2 job tickets (optionally scoped by owner)")
+    .option("-o, --owner <id>", "Owner ID")
+    .action((opts) => console.log(getRunningJobCount(opts.owner)));
+
+  quant
+    .command("register-model-v2 <model-id>")
+    .description("Register a V2 model")
+    .requiredOption("-o, --owner <id>", "Owner ID")
+    .option("-f, --family <name>", "Model family (e.g. llama)")
+    .option("-i, --initial-status <status>", "Initial status")
+    .option("-m, --metadata <json>", "Metadata JSON")
+    .option("--json", "JSON output")
+    .action((modelId, opts) => {
+      const db = _dbFromCtx(quant);
+      const rec = registerModelV2(db, {
+        modelId,
+        ownerId: opts.owner,
+        family: opts.family,
+        initialStatus: opts.initialStatus,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`Registered model ${modelId} (${rec.status})`);
+    });
+
+  quant
+    .command("model-v2 <model-id>")
+    .description("Show a V2 model")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const rec = getModelV2(id);
+      if (!rec) {
+        console.error(`Unknown model: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`${rec.modelId} [${rec.status}] owner=${rec.ownerId}`);
+    });
+
+  quant
+    .command("set-model-maturity-v2 <model-id> <status>")
+    .description("Transition V2 model maturity")
+    .option("-r, --reason <text>", "Reason")
+    .option("-m, --metadata <json>", "Metadata patch (JSON)")
+    .action((id, status, opts) => {
+      const db = _dbFromCtx(quant);
+      const rec = setModelMaturityV2(db, id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("activate-model <model-id>")
+    .description("Transition a V2 model to ACTIVE")
+    .option("-r, --reason <text>", "Reason")
+    .action((id, opts) => {
+      const rec = activateModel(_dbFromCtx(quant), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("deprecate-model <model-id>")
+    .description("Transition a V2 model to DEPRECATED")
+    .option("-r, --reason <text>", "Reason")
+    .action((id, opts) => {
+      const rec = deprecateModel(_dbFromCtx(quant), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("retire-model <model-id>")
+    .description("Transition a V2 model to RETIRED")
+    .option("-r, --reason <text>", "Reason")
+    .action((id, opts) => {
+      const rec = retireModel(_dbFromCtx(quant), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("touch-model-usage <model-id>")
+    .description("Bump lastUsedAt for a V2 model")
+    .action((id) => {
+      const rec = touchModelUsage(id);
+      console.log(`${id} lastUsedAt=${rec.lastUsedAt}`);
+    });
+
+  quant
+    .command("enqueue-job-ticket-v2 <ticket-id>")
+    .description("Enqueue a V2 quantization job ticket")
+    .requiredOption("-o, --owner <id>", "Owner ID")
+    .requiredOption("-M, --model <id>", "Model ID")
+    .requiredOption("-t, --quant-type <type>", "Quant type (gguf/gptq)")
+    .option("-l, --level <lvl>", "Level (e.g. Q4_K_M)")
+    .option("-m, --metadata <json>", "Metadata JSON")
+    .option("--json", "JSON output")
+    .action((ticketId, opts) => {
+      const db = _dbFromCtx(quant);
+      const rec = enqueueJobTicketV2(db, {
+        ticketId,
+        ownerId: opts.owner,
+        modelId: opts.model,
+        quantType: opts.quantType,
+        level: opts.level,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`Enqueued ticket ${ticketId} (${rec.status})`);
+    });
+
+  quant
+    .command("job-ticket-v2 <ticket-id>")
+    .description("Show a V2 job ticket")
+    .option("--json", "JSON output")
+    .action((id, opts) => {
+      const rec = getJobTicketV2(id);
+      if (!rec) {
+        console.error(`Unknown ticket: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`${rec.ticketId} [${rec.status}] owner=${rec.ownerId}`);
+    });
+
+  quant
+    .command("set-job-ticket-status-v2 <ticket-id> <status>")
+    .description("Transition V2 job ticket status")
+    .option("-r, --reason <text>", "Reason")
+    .option("-m, --metadata <json>", "Metadata patch (JSON)")
+    .action((id, status, opts) => {
+      const db = _dbFromCtx(quant);
+      const rec = setJobTicketStatusV2(db, id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("start-job-ticket <ticket-id>")
+    .description("Transition a V2 job ticket to RUNNING")
+    .option("-r, --reason <text>", "Reason")
+    .action((id, opts) => {
+      const rec = startJobTicket(_dbFromCtx(quant), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("complete-job-ticket <ticket-id>")
+    .description("Transition a V2 job ticket to COMPLETED")
+    .option("-r, --reason <text>", "Reason")
+    .action((id, opts) => {
+      const rec = completeJobTicket(_dbFromCtx(quant), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("fail-job-ticket <ticket-id>")
+    .description("Transition a V2 job ticket to FAILED")
+    .option("-r, --reason <text>", "Reason")
+    .action((id, opts) => {
+      const rec = failJobTicket(_dbFromCtx(quant), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("cancel-job-ticket <ticket-id>")
+    .description("Transition a V2 job ticket to CANCELED")
+    .option("-r, --reason <text>", "Reason")
+    .action((id, opts) => {
+      const rec = cancelJobTicket(_dbFromCtx(quant), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  quant
+    .command("auto-retire-idle-models")
+    .description("Flip idle V2 models (active+deprecated) → RETIRED")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const r = autoRetireIdleModels(_dbFromCtx(quant));
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Retired ${r.count} idle model(s)`);
+    });
+
+  quant
+    .command("auto-fail-stuck-job-tickets")
+    .description("Flip stuck RUNNING V2 tickets → FAILED")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const r = autoFailStuckJobTickets(_dbFromCtx(quant));
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Failed ${r.count} stuck ticket(s)`);
+    });
+
+  quant
+    .command("stats-v2")
+    .description("Phase 20 V2 statistics")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const s = getQuantizationStatsV2();
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(
+        `Models(V2)=${s.totalModelsV2} Tickets(V2)=${s.totalTicketsV2} ` +
+          `caps: active-models/owner=${s.maxActiveModelsPerOwner} running-jobs/owner=${s.maxRunningJobsPerOwner}`,
+      );
+      console.log("models-by-status:");
+      for (const [k, v] of Object.entries(s.modelsByStatus))
+        console.log(`  ${k.padEnd(12)} ${v}`);
+      console.log("tickets-by-status:");
+      for (const [k, v] of Object.entries(s.ticketsByStatus))
+        console.log(`  ${k.padEnd(12)} ${v}`);
+    });
+
   program.addCommand(quant);
 }