chainlesschain 0.66.0 → 0.132.0

package/src/commands/reputation.js

@@ -18,6 +18,22 @@ import {
   listOptimizationRuns,
   applyOptimizedParams,
   OPTIMIZATION_OBJECTIVES,
+  // V2 (Phase 60)
+  RUN_STATUS_V2,
+  OBJECTIVE_V2,
+  DECAY_MODEL_V2,
+  ANOMALY_METHOD_V2,
+  REPUTATION_DEFAULT_MAX_CONCURRENT,
+  setMaxConcurrentOptimizations,
+  getMaxConcurrentOptimizations,
+  getActiveOptimizationCount,
+  startOptimizationV2,
+  completeOptimization,
+  cancelOptimization,
+  failOptimization,
+  applyOptimization,
+  setRunStatus,
+  getReputationStatsV2,
 } from "../lib/reputation-optimizer.js";
 
 function _dbFromCtx(ctx) {
@@ -346,4 +362,249 @@ export function registerReputationCommand(program) {
         for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
       }
     });
+
+  /* ── V2 (Phase 60) ───────────────────────────────────────── */
+
+  rep
+    .command("run-statuses")
+    .description(
+      "List V2 run statuses (running/complete/applied/failed/cancelled)",
+    )
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(RUN_STATUS_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("v2-objectives")
+    .description("List V2 objectives (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(OBJECTIVE_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("decay-models")
+    .description("List V2 decay models (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(DECAY_MODEL_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("anomaly-methods")
+    .description("List V2 anomaly methods (frozen enum)")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(ANOMALY_METHOD_V2);
+      if (options.json) console.log(JSON.stringify(values, null, 2));
+      else for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+    });
+
+  rep
+    .command("default-max-concurrent")
+    .description("Show default max concurrent optimizations")
+    .action(() => {
+      logger.log(`  ${REPUTATION_DEFAULT_MAX_CONCURRENT}`);
+    });
+
+  rep
+    .command("max-concurrent")
+    .description("Show current max concurrent optimizations")
+    .action(() => {
+      logger.log(`  ${getMaxConcurrentOptimizations()}`);
+    });
+
+  rep
+    .command("active-optimization-count")
+    .description("Show count of currently-RUNNING optimizations")
+    .action(() => {
+      logger.log(`  ${getActiveOptimizationCount()}`);
+    });
+
+  rep
+    .command("set-max-concurrent <n>")
+    .description("Set the concurrency cap for RUNNING optimizations")
+    .action((n) => {
+      try {
+        const v = setMaxConcurrentOptimizations(Number(n));
+        logger.success(`Max concurrent = ${v}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("start-v2")
+    .description(
+      "Start a V2 optimization (RUNNING only, driven by complete/cancel/fail)",
+    )
+    .option(
+      "-o, --objective <name>",
+      "Objective (accuracy|fairness|resilience|convergence_speed)",
+      "accuracy",
+    )
+    .option("-i, --iterations <n>", "Iteration count", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const run = startOptimizationV2(db, {
+          objective: options.objective,
+          iterations: options.iterations,
+        });
+        if (options.json) console.log(JSON.stringify(run, null, 2));
+        else {
+          logger.success(`Optimization started [${run.status}]`);
+          logger.log(`  ${chalk.bold("Run ID:")}     ${chalk.cyan(run.runId)}`);
+          logger.log(`  ${chalk.bold("Objective:")}  ${run.objective}`);
+          logger.log(`  ${chalk.bold("Iterations:")} ${run.iterations}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("complete <run-id>")
+    .description(
+      "Complete a V2 optimization (RUNNING → COMPLETE, runs iterations)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (runId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = completeOptimization(db, runId);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else {
+          logger.success(`Completed [${result.status}]`);
+          logger.log(`  ${chalk.bold("Best score:")}  ${result.bestScore}`);
+          logger.log(
+            `  ${chalk.bold("Best params:")} ${JSON.stringify(result.bestParams)}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("cancel <run-id>")
+    .description("Cancel a V2 RUNNING optimization")
+    .action(async (runId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = cancelOptimization(db, runId);
+        logger.success(`Cancelled [${result.status}]`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("fail <run-id>")
+    .description("Fail a V2 RUNNING optimization")
+    .option("--message <msg>", "Error message")
+    .action(async (runId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = failOptimization(db, runId, options.message);
+        logger.success(`Failed [${result.status}]`);
+        if (result.errorMessage)
+          logger.log(`  ${chalk.bold("Error:")} ${result.errorMessage}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("apply-v2 <run-id>")
+    .description("Apply a V2 COMPLETE optimization (COMPLETE → APPLIED)")
+    .action(async (runId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const result = applyOptimization(db, runId);
+        logger.success(`Applied [${result.status}]`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("set-status <run-id> <status>")
+    .description("Set V2 run status via the state machine")
+    .option("--message <msg>", "Error message (FAILED only)")
+    .option("--json", "Output as JSON")
+    .action(async (runId, status, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const patch = options.message ? { errorMessage: options.message } : {};
+        const result = setRunStatus(db, runId, status, patch);
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else logger.success(`Status = ${result.status}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("stats-v2")
+    .description("V2 aggregated stats")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const stats = getReputationStatsV2();
+        if (options.json) console.log(JSON.stringify(stats, null, 2));
+        else {
+          logger.log(`  ${chalk.bold("Total runs:")}   ${stats.totalRuns}`);
+          logger.log(`  ${chalk.bold("Active:")}       ${stats.activeRuns}`);
+          logger.log(
+            `  ${chalk.bold("Max concurrent:")} ${stats.maxConcurrentOptimizations}`,
+          );
+          logger.log(`  ${chalk.bold("By status:")}`);
+          for (const [k, v] of Object.entries(stats.byStatus))
+            logger.log(`    ${k.padEnd(12)} ${v}`);
+          logger.log(`  ${chalk.bold("By objective:")}`);
+          for (const [k, v] of Object.entries(stats.byObjective))
+            logger.log(`    ${k.padEnd(20)} ${v}`);
+          logger.log(
+            `  ${chalk.bold("Observations:")} ${stats.observations.totalObservations} (${stats.observations.totalDids} DIDs)`,
+          );
+          logger.log(
+            `  ${chalk.bold("Best score ever:")} ${stats.bestScoreEver}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/runtime.js

@@ -34,8 +34,51 @@ import {
   healthCheck,
   getMetrics,
   getRuntimeStats,
+  /* V2 (Phase 63) */
+  PLUGIN_MATURITY_V2,
+  RUNTIME_TASK_V2,
+  getDefaultMaxActivePluginsPerOwnerV2,
+  getMaxActivePluginsPerOwnerV2,
+  setMaxActivePluginsPerOwnerV2,
+  getDefaultMaxRunningTasksPerOwnerV2,
+  getMaxRunningTasksPerOwnerV2,
+  setMaxRunningTasksPerOwnerV2,
+  getDefaultPluginIdleMsV2,
+  getPluginIdleMsV2,
+  setPluginIdleMsV2,
+  getDefaultTaskStuckMsV2,
+  getTaskStuckMsV2,
+  setTaskStuckMsV2,
+  registerPluginV2,
+  getPluginV2,
+  setPluginMaturityV2,
+  activatePluginV2,
+  deprecatePluginV2,
+  retirePluginV2,
+  touchPluginInvocation,
+  enqueueRuntimeTaskV2,
+  getRuntimeTaskV2,
+  setRuntimeTaskStatusV2,
+  startRuntimeTask,
+  completeRuntimeTask,
+  failRuntimeTask,
+  cancelRuntimeTask,
+  getActivePluginCount,
+  getRunningTaskCount,
+  autoRetireIdlePlugins,
+  autoFailStuckRuntimeTasks,
+  getRuntimeStatsV2,
 } from "../lib/universal-runtime.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;
@@ -496,5 +539,269 @@ export function registerRuntimeCommand(program) {
       console.log(`Uptime:   ${s.metrics.uptimeMs}ms`);
     });
 
+  /* ═════════════════════════════════════════════════════ *
+   *  Phase 63 V2 — Plugin Maturity + Runtime Task Lifecycle
+   * ═════════════════════════════════════════════════════ */
+
+  runtime
+    .command("plugin-maturities-v2")
+    .description("List Phase 63 V2 plugin maturity states")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(PLUGIN_MATURITY_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      for (const s of v) console.log(s);
+    });
+
+  runtime
+    .command("runtime-task-lifecycles-v2")
+    .description("List Phase 63 V2 runtime-task lifecycle states")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const v = Object.values(RUNTIME_TASK_V2);
+      if (opts.json) return console.log(JSON.stringify(v, null, 2));
+      for (const s of v) console.log(s);
+    });
+
+  runtime
+    .command("default-max-active-plugins-per-owner")
+    .action(() => console.log(getDefaultMaxActivePluginsPerOwnerV2()));
+  runtime
+    .command("max-active-plugins-per-owner")
+    .action(() => console.log(getMaxActivePluginsPerOwnerV2()));
+  runtime
+    .command("set-max-active-plugins-per-owner <n>")
+    .action((n) => console.log(setMaxActivePluginsPerOwnerV2(n)));
+
+  runtime
+    .command("default-max-running-tasks-per-owner")
+    .action(() => console.log(getDefaultMaxRunningTasksPerOwnerV2()));
+  runtime
+    .command("max-running-tasks-per-owner")
+    .action(() => console.log(getMaxRunningTasksPerOwnerV2()));
+  runtime
+    .command("set-max-running-tasks-per-owner <n>")
+    .action((n) => console.log(setMaxRunningTasksPerOwnerV2(n)));
+
+  runtime
+    .command("default-plugin-idle-ms")
+    .action(() => console.log(getDefaultPluginIdleMsV2()));
+  runtime
+    .command("plugin-idle-ms")
+    .action(() => console.log(getPluginIdleMsV2()));
+  runtime
+    .command("set-plugin-idle-ms <ms>")
+    .action((ms) => console.log(setPluginIdleMsV2(ms)));
+
+  runtime
+    .command("default-task-stuck-ms")
+    .action(() => console.log(getDefaultTaskStuckMsV2()));
+  runtime
+    .command("task-stuck-ms")
+    .action(() => console.log(getTaskStuckMsV2()));
+  runtime
+    .command("set-task-stuck-ms <ms>")
+    .action((ms) => console.log(setTaskStuckMsV2(ms)));
+
+  runtime
+    .command("active-plugin-count")
+    .option("-o, --owner <id>")
+    .action((opts) => console.log(getActivePluginCount(opts.owner)));
+
+  runtime
+    .command("running-task-count")
+    .option("-o, --owner <id>")
+    .action((opts) => console.log(getRunningTaskCount(opts.owner)));
+
+  runtime
+    .command("register-plugin-v2 <plugin-id>")
+    .requiredOption("-o, --owner <id>")
+    .option("-n, --name <text>")
+    .option("-v, --version <text>")
+    .option("-i, --initial-status <status>")
+    .option("-m, --metadata <json>")
+    .option("--json")
+    .action((pluginId, opts) => {
+      const rec = registerPluginV2(_dbFromCtx(runtime), {
+        pluginId,
+        ownerId: opts.owner,
+        name: opts.name,
+        version: opts.version,
+        initialStatus: opts.initialStatus,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`Registered plugin ${pluginId} (${rec.status})`);
+    });
+
+  runtime
+    .command("plugin-v2 <plugin-id>")
+    .option("--json")
+    .action((id, opts) => {
+      const rec = getPluginV2(id);
+      if (!rec) {
+        console.error(`Unknown plugin: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`${rec.pluginId} [${rec.status}] owner=${rec.ownerId}`);
+    });
+
+  runtime
+    .command("set-plugin-maturity-v2 <plugin-id> <status>")
+    .option("-r, --reason <text>")
+    .option("-m, --metadata <json>")
+    .action((id, status, opts) => {
+      const rec = setPluginMaturityV2(_dbFromCtx(runtime), id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("activate-plugin-v2 <plugin-id>")
+    .option("-r, --reason <text>")
+    .action((id, opts) => {
+      const rec = activatePluginV2(_dbFromCtx(runtime), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("deprecate-plugin-v2 <plugin-id>")
+    .option("-r, --reason <text>")
+    .action((id, opts) => {
+      const rec = deprecatePluginV2(_dbFromCtx(runtime), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("retire-plugin-v2 <plugin-id>")
+    .option("-r, --reason <text>")
+    .action((id, opts) => {
+      const rec = retirePluginV2(_dbFromCtx(runtime), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime.command("touch-plugin-invocation <plugin-id>").action((id) => {
+    const r = touchPluginInvocation(id);
+    console.log(`${id} lastInvokedAt=${r.lastInvokedAt}`);
+  });
+
+  runtime
+    .command("enqueue-runtime-task-v2 <task-id>")
+    .requiredOption("-o, --owner <id>")
+    .requiredOption("-p, --plugin <id>")
+    .requiredOption("-k, --kind <name>")
+    .option("-m, --metadata <json>")
+    .option("--json")
+    .action((taskId, opts) => {
+      const rec = enqueueRuntimeTaskV2(_dbFromCtx(runtime), {
+        taskId,
+        ownerId: opts.owner,
+        pluginId: opts.plugin,
+        kind: opts.kind,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`Enqueued task ${taskId} (${rec.status})`);
+    });
+
+  runtime
+    .command("runtime-task-v2 <task-id>")
+    .option("--json")
+    .action((id, opts) => {
+      const rec = getRuntimeTaskV2(id);
+      if (!rec) {
+        console.error(`Unknown task: ${id}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.json) return console.log(JSON.stringify(rec, null, 2));
+      console.log(`${rec.taskId} [${rec.status}] owner=${rec.ownerId}`);
+    });
+
+  runtime
+    .command("set-runtime-task-status-v2 <task-id> <status>")
+    .option("-r, --reason <text>")
+    .option("-m, --metadata <json>")
+    .action((id, status, opts) => {
+      const rec = setRuntimeTaskStatusV2(_dbFromCtx(runtime), id, status, {
+        reason: opts.reason,
+        metadata: _parseMetaV2(opts.metadata),
+      });
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("start-runtime-task <task-id>")
+    .option("-r, --reason <text>")
+    .action((id, opts) => {
+      const rec = startRuntimeTask(_dbFromCtx(runtime), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("complete-runtime-task <task-id>")
+    .option("-r, --reason <text>")
+    .action((id, opts) => {
+      const rec = completeRuntimeTask(_dbFromCtx(runtime), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("fail-runtime-task <task-id>")
+    .option("-r, --reason <text>")
+    .action((id, opts) => {
+      const rec = failRuntimeTask(_dbFromCtx(runtime), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("cancel-runtime-task <task-id>")
+    .option("-r, --reason <text>")
+    .action((id, opts) => {
+      const rec = cancelRuntimeTask(_dbFromCtx(runtime), id, opts.reason);
+      console.log(`${id} → ${rec.status}`);
+    });
+
+  runtime
+    .command("auto-retire-idle-plugins")
+    .option("--json")
+    .action((opts) => {
+      const r = autoRetireIdlePlugins(_dbFromCtx(runtime));
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Retired ${r.count} idle plugin(s)`);
+    });
+
+  runtime
+    .command("auto-fail-stuck-runtime-tasks")
+    .option("--json")
+    .action((opts) => {
+      const r = autoFailStuckRuntimeTasks(_dbFromCtx(runtime));
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`Failed ${r.count} stuck task(s)`);
+    });
+
+  runtime
+    .command("stats-v2")
+    .description("Phase 63 V2 statistics")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const s = getRuntimeStatsV2();
+      if (opts.json) return console.log(JSON.stringify(s, null, 2));
+      console.log(
+        `Plugins(V2)=${s.totalPluginsV2} Tasks(V2)=${s.totalTasksV2} ` +
+          `caps: active-plugins/owner=${s.maxActivePluginsPerOwner} running-tasks/owner=${s.maxRunningTasksPerOwner}`,
+      );
+      console.log("plugins-by-status:");
+      for (const [k, v] of Object.entries(s.pluginsByStatus))
+        console.log(`  ${k.padEnd(12)} ${v}`);
+      console.log("tasks-by-status:");
+      for (const [k, v] of Object.entries(s.tasksByStatus))
+        console.log(`  ${k.padEnd(12)} ${v}`);
+    });
+
   program.addCommand(runtime);
 }