chainlesschain 0.66.0 → 0.132.0

package/src/commands/kg.js

@@ -21,6 +21,40 @@ import {
   getStats,
   exportGraph,
   importGraph,
+  // V2 surface
+  ENTITY_STATUS_V2,
+  RELATION_STATUS_V2,
+  KG_DEFAULT_MAX_ACTIVE_ENTITIES_PER_OWNER,
+  KG_DEFAULT_MAX_RELATIONS_PER_ENTITY,
+  KG_DEFAULT_ENTITY_STALE_MS,
+  KG_DEFAULT_RELATION_STALE_MS,
+  getMaxActiveEntitiesPerOwnerV2,
+  setMaxActiveEntitiesPerOwnerV2,
+  getMaxRelationsPerEntityV2,
+  setMaxRelationsPerEntityV2,
+  getEntityStaleMsV2,
+  setEntityStaleMsV2,
+  getRelationStaleMsV2,
+  setRelationStaleMsV2,
+  registerEntityV2,
+  getEntityV2,
+  setEntityStatusV2,
+  deprecateEntity,
+  archiveEntityV2,
+  removeEntityV2,
+  reviveEntity,
+  touchEntityActivity,
+  registerRelationV2,
+  getRelationV2,
+  setRelationStatusV2,
+  deprecateRelation,
+  removeRelationV2,
+  reviveRelation,
+  getActiveEntityCount,
+  getActiveRelationCount,
+  autoArchiveStaleEntities,
+  autoRemoveStaleRelations,
+  getKnowledgeGraphStatsV2,
 } from "../lib/knowledge-graph.js";
 
 function _dbFromCtx(ctx) {
@@ -368,4 +402,357 @@ export function registerKgCommand(program) {
         process.exit(1);
       }
     });
+
+  /* ── V2 subcommands (Phase 94) ───────────────────────────────── */
+
+  kg.command("entity-statuses-v2")
+    .description("List V2 entity maturity statuses")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = Object.values(ENTITY_STATUS_V2);
+      if (options.json) {
+        console.log(JSON.stringify(statuses, null, 2));
+      } else {
+        for (const s of statuses) logger.log(`  ${chalk.yellow(s)}`);
+      }
+    });
+
+  kg.command("relation-statuses-v2")
+    .description("List V2 relation statuses")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const statuses = Object.values(RELATION_STATUS_V2);
+      if (options.json) {
+        console.log(JSON.stringify(statuses, null, 2));
+      } else {
+        for (const s of statuses) logger.log(`  ${chalk.yellow(s)}`);
+      }
+    });
+
+  kg.command("default-max-active-entities-per-owner")
+    .description("Show default V2 per-owner active-entity cap")
+    .action(() => logger.log(String(KG_DEFAULT_MAX_ACTIVE_ENTITIES_PER_OWNER)));
+  kg.command("max-active-entities-per-owner")
+    .description("Show current V2 per-owner active-entity cap")
+    .action(() => logger.log(String(getMaxActiveEntitiesPerOwnerV2())));
+  kg.command("set-max-active-entities-per-owner <n>")
+    .description("Set V2 per-owner active-entity cap")
+    .action((n) =>
+      logger.log(String(setMaxActiveEntitiesPerOwnerV2(parseInt(n, 10)))),
+    );
+
+  kg.command("default-max-relations-per-entity")
+    .description("Show default V2 per-entity active-relation cap")
+    .action(() => logger.log(String(KG_DEFAULT_MAX_RELATIONS_PER_ENTITY)));
+  kg.command("max-relations-per-entity")
+    .description("Show current V2 per-entity active-relation cap")
+    .action(() => logger.log(String(getMaxRelationsPerEntityV2())));
+  kg.command("set-max-relations-per-entity <n>")
+    .description("Set V2 per-entity active-relation cap")
+    .action((n) =>
+      logger.log(String(setMaxRelationsPerEntityV2(parseInt(n, 10)))),
+    );
+
+  kg.command("default-entity-stale-ms")
+    .description("Show default V2 entity staleness threshold (ms)")
+    .action(() => logger.log(String(KG_DEFAULT_ENTITY_STALE_MS)));
+  kg.command("entity-stale-ms")
+    .description("Show current V2 entity staleness threshold (ms)")
+    .action(() => logger.log(String(getEntityStaleMsV2())));
+  kg.command("set-entity-stale-ms <ms>")
+    .description("Set V2 entity staleness threshold (ms)")
+    .action((ms) => logger.log(String(setEntityStaleMsV2(parseInt(ms, 10)))));
+
+  kg.command("default-relation-stale-ms")
+    .description("Show default V2 relation staleness threshold (ms)")
+    .action(() => logger.log(String(KG_DEFAULT_RELATION_STALE_MS)));
+  kg.command("relation-stale-ms")
+    .description("Show current V2 relation staleness threshold (ms)")
+    .action(() => logger.log(String(getRelationStaleMsV2())));
+  kg.command("set-relation-stale-ms <ms>")
+    .description("Set V2 relation staleness threshold (ms)")
+    .action((ms) => logger.log(String(setRelationStaleMsV2(parseInt(ms, 10)))));
+
+  kg.command("active-entity-count")
+    .description("Active V2 entity count (scoped by owner)")
+    .option("-o, --owner <id>", "Scope by owner ID")
+    .action((opts) => logger.log(String(getActiveEntityCount(opts.owner))));
+
+  kg.command("active-relation-count")
+    .description("Active V2 relation count (scoped by source entity)")
+    .option("-s, --source <id>", "Scope by source entity ID")
+    .action((opts) => logger.log(String(getActiveRelationCount(opts.source))));
+
+  kg.command("register-entity-v2 <entity-id>")
+    .description("Register a V2 entity")
+    .requiredOption("-o, --owner <id>", "Owner ID")
+    .option("-n, --name <name>", "Entity name")
+    .option("-t, --type <type>", "Entity type")
+    .option("-m, --metadata <json>", "JSON metadata")
+    .option("--json", "Output as JSON")
+    .action((entityId, opts) => {
+      try {
+        const metadata = opts.metadata ? JSON.parse(opts.metadata) : undefined;
+        const rec = registerEntityV2(null, {
+          entityId,
+          ownerId: opts.owner,
+          name: opts.name,
+          type: opts.type,
+          metadata,
+        });
+        if (opts.json) console.log(JSON.stringify(rec, null, 2));
+        else logger.success(`Entity registered: ${entityId} (${rec.status})`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("entity-v2 <entity-id>")
+    .description("Show V2 entity lifecycle state")
+    .option("--json", "Output as JSON")
+    .action((entityId, opts) => {
+      const rec = getEntityV2(entityId);
+      if (!rec) {
+        logger.error(`Entity not registered in V2: ${entityId}`);
+        process.exit(1);
+      }
+      if (opts.json) console.log(JSON.stringify(rec, null, 2));
+      else {
+        logger.log(`  ${chalk.bold("Entity:")} ${rec.entityId}`);
+        logger.log(`  ${chalk.bold("Status:")} ${chalk.yellow(rec.status)}`);
+        logger.log(`  ${chalk.bold("Owner:")}  ${rec.ownerId}`);
+      }
+    });
+
+  kg.command("set-entity-status-v2 <entity-id> <status>")
+    .description("Transition a V2 entity status")
+    .option("-r, --reason <text>", "Reason")
+    .option("-m, --metadata <json>", "JSON metadata to merge")
+    .action((entityId, status, opts) => {
+      try {
+        const patch = {};
+        if (opts.reason) patch.reason = opts.reason;
+        if (opts.metadata) patch.metadata = JSON.parse(opts.metadata);
+        const rec = setEntityStatusV2(null, entityId, status, patch);
+        logger.success(`Entity ${entityId} → ${rec.status}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("deprecate-entity <entity-id>")
+    .description("Deprecate a V2 entity (grace period)")
+    .option("-r, --reason <text>", "Reason")
+    .action((entityId, opts) => {
+      try {
+        deprecateEntity(null, entityId, opts.reason);
+        logger.success(`Entity ${entityId} deprecated`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("archive-entity-v2 <entity-id>")
+    .description("Archive a V2 entity")
+    .option("-r, --reason <text>", "Reason")
+    .action((entityId, opts) => {
+      try {
+        archiveEntityV2(null, entityId, opts.reason);
+        logger.success(`Entity ${entityId} archived`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("remove-entity-v2 <entity-id>")
+    .description("Remove a V2 entity (terminal)")
+    .option("-r, --reason <text>", "Reason")
+    .action((entityId, opts) => {
+      try {
+        removeEntityV2(null, entityId, opts.reason);
+        logger.success(`Entity ${entityId} removed`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("revive-entity <entity-id>")
+    .description("Restore a V2 entity to active")
+    .option("-r, --reason <text>", "Reason")
+    .action((entityId, opts) => {
+      try {
+        reviveEntity(null, entityId, opts.reason);
+        logger.success(`Entity ${entityId} revived`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("touch-entity-activity <entity-id>")
+    .description("Bump lastActivityAt on a V2 entity")
+    .action((entityId) => {
+      try {
+        touchEntityActivity(entityId);
+        logger.success(`Entity ${entityId} activity bumped`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("register-relation-v2 <relation-id>")
+    .description("Register a V2 relation")
+    .requiredOption("-s, --source <id>", "Source entity ID")
+    .requiredOption("-t, --target <id>", "Target entity ID")
+    .requiredOption("-r, --relation-type <type>", "Relation type")
+    .option("-m, --metadata <json>", "JSON metadata")
+    .option("--json", "Output as JSON")
+    .action((relationId, opts) => {
+      try {
+        const metadata = opts.metadata ? JSON.parse(opts.metadata) : undefined;
+        const rec = registerRelationV2(null, {
+          relationId,
+          sourceEntityId: opts.source,
+          targetEntityId: opts.target,
+          relationType: opts.relationType,
+          metadata,
+        });
+        if (opts.json) console.log(JSON.stringify(rec, null, 2));
+        else
+          logger.success(`Relation registered: ${relationId} (${rec.status})`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("relation-v2 <relation-id>")
+    .description("Show V2 relation lifecycle state")
+    .option("--json", "Output as JSON")
+    .action((relationId, opts) => {
+      const rec = getRelationV2(relationId);
+      if (!rec) {
+        logger.error(`Relation not registered in V2: ${relationId}`);
+        process.exit(1);
+      }
+      if (opts.json) console.log(JSON.stringify(rec, null, 2));
+      else {
+        logger.log(`  ${chalk.bold("Relation:")} ${rec.relationId}`);
+        logger.log(`  ${chalk.bold("Status:")}   ${chalk.yellow(rec.status)}`);
+        logger.log(
+          `  ${chalk.bold("Edge:")}     ${rec.sourceEntityId} ─[${rec.relationType}]→ ${rec.targetEntityId}`,
+        );
+      }
+    });
+
+  kg.command("set-relation-status-v2 <relation-id> <status>")
+    .description("Transition a V2 relation status")
+    .option("-r, --reason <text>", "Reason")
+    .option("-m, --metadata <json>", "JSON metadata to merge")
+    .action((relationId, status, opts) => {
+      try {
+        const patch = {};
+        if (opts.reason) patch.reason = opts.reason;
+        if (opts.metadata) patch.metadata = JSON.parse(opts.metadata);
+        const rec = setRelationStatusV2(null, relationId, status, patch);
+        logger.success(`Relation ${relationId} → ${rec.status}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("deprecate-relation <relation-id>")
+    .description("Deprecate a V2 relation")
+    .option("-r, --reason <text>", "Reason")
+    .action((relationId, opts) => {
+      try {
+        deprecateRelation(null, relationId, opts.reason);
+        logger.success(`Relation ${relationId} deprecated`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("remove-relation-v2 <relation-id>")
+    .description("Remove a V2 relation (terminal)")
+    .option("-r, --reason <text>", "Reason")
+    .action((relationId, opts) => {
+      try {
+        removeRelationV2(null, relationId, opts.reason);
+        logger.success(`Relation ${relationId} removed`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("revive-relation <relation-id>")
+    .description("Restore a V2 relation to active")
+    .option("-r, --reason <text>", "Reason")
+    .action((relationId, opts) => {
+      try {
+        reviveRelation(null, relationId, opts.reason);
+        logger.success(`Relation ${relationId} revived`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  kg.command("auto-archive-stale-entities")
+    .description("Bulk-flip stale V2 entities → archived")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const flipped = autoArchiveStaleEntities(null);
+      if (opts.json) console.log(JSON.stringify(flipped, null, 2));
+      else logger.success(`Archived ${flipped.length} stale entities`);
+    });
+
+  kg.command("auto-remove-stale-relations")
+    .description("Bulk-flip stale V2 relations → removed")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const flipped = autoRemoveStaleRelations(null);
+      if (opts.json) console.log(JSON.stringify(flipped, null, 2));
+      else logger.success(`Removed ${flipped.length} stale relations`);
+    });
+
+  kg.command("stats-v2")
+    .description("V2 knowledge graph stats (all-enum-key zero-init)")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+      const stats = getKnowledgeGraphStatsV2();
+      if (opts.json) {
+        console.log(JSON.stringify(stats, null, 2));
+      } else {
+        logger.log(
+          `  ${chalk.bold("Total entities:")}  ${stats.totalEntitiesV2}`,
+        );
+        logger.log(
+          `  ${chalk.bold("Total relations:")} ${stats.totalRelationsV2}`,
+        );
+        logger.log(
+          `  ${chalk.bold("Caps:")}            per-owner=${stats.maxActiveEntitiesPerOwner}, per-entity=${stats.maxRelationsPerEntity}`,
+        );
+        logger.log(
+          `  ${chalk.bold("Stale thresholds:")} entity=${stats.entityStaleMs}ms, relation=${stats.relationStaleMs}ms`,
+        );
+        logger.log(chalk.bold("  Entities by status:"));
+        for (const [k, v] of Object.entries(stats.entitiesByStatus)) {
+          logger.log(`    ${chalk.yellow(k.padEnd(12))} ${v}`);
+        }
+        logger.log(chalk.bold("  Relations by status:"));
+        for (const [k, v] of Object.entries(stats.relationsByStatus)) {
+          logger.log(`    ${chalk.yellow(k.padEnd(12))} ${v}`);
+        }
+      }
+    });
 }

package/src/commands/llm.js

@@ -10,6 +10,37 @@ import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   BUILT_IN_PROVIDERS,
   LLMProviderRegistry,
+  PROVIDER_MATURITY_V2,
+  REQUEST_LIFECYCLE_V2,
+  getMaxActiveProfilesPerOwnerV2,
+  setMaxActiveProfilesPerOwnerV2,
+  getMaxPendingRequestsPerProfileV2,
+  setMaxPendingRequestsPerProfileV2,
+  getProfileIdleMsV2,
+  setProfileIdleMsV2,
+  getRequestStuckMsV2,
+  setRequestStuckMsV2,
+  registerProfileV2,
+  getProfileV2,
+  listProfilesV2,
+  setProfileStatusV2,
+  activateProfileV2,
+  suspendProfileV2,
+  retireProfileV2,
+  touchProfileV2,
+  createRequestV2,
+  getRequestV2,
+  listRequestsV2,
+  setRequestStatusV2,
+  startRequestV2,
+  completeRequestV2,
+  failRequestV2,
+  cancelRequestV2,
+  getActiveProfileCountV2,
+  getPendingRequestCountV2,
+  autoSuspendIdleProfilesV2,
+  autoFailStuckRequestsV2,
+  getLlmProvidersStatsV2,
 } from "../lib/llm-providers.js";
 
 export function registerLlmCommand(program) {
@@ -285,4 +316,236 @@ export function registerLlmCommand(program) {
         process.exit(1);
       }
     });
+
+  // ─── V2 Governance Layer ──────────────────────────────────────────
+  const out = (obj) => console.log(JSON.stringify(obj, null, 2));
+  const tryRun = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  };
+
+  llm
+    .command("provider-maturities-v2")
+    .description("List V2 provider maturity states")
+    .action(() => out(Object.values(PROVIDER_MATURITY_V2)));
+
+  llm
+    .command("request-lifecycles-v2")
+    .description("List V2 request lifecycle states")
+    .action(() => out(Object.values(REQUEST_LIFECYCLE_V2)));
+
+  llm
+    .command("stats-v2")
+    .description("V2 llm-providers stats")
+    .action(() => out(getLlmProvidersStatsV2()));
+
+  llm
+    .command("get-max-active-profiles-v2")
+    .description("Get max active profiles per owner (V2)")
+    .action(() =>
+      out({ maxActiveProfilesPerOwner: getMaxActiveProfilesPerOwnerV2() }),
+    );
+
+  llm
+    .command("set-max-active-profiles-v2 <n>")
+    .description("Set max active profiles per owner (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveProfilesPerOwnerV2(Number(n));
+        out({ maxActiveProfilesPerOwner: getMaxActiveProfilesPerOwnerV2() });
+      }),
+    );
+
+  llm
+    .command("get-max-pending-requests-v2")
+    .description("Get max pending requests per profile (V2)")
+    .action(() =>
+      out({
+        maxPendingRequestsPerProfile: getMaxPendingRequestsPerProfileV2(),
+      }),
+    );
+
+  llm
+    .command("set-max-pending-requests-v2 <n>")
+    .description("Set max pending requests per profile (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingRequestsPerProfileV2(Number(n));
+        out({
+          maxPendingRequestsPerProfile: getMaxPendingRequestsPerProfileV2(),
+        });
+      }),
+    );
+
+  llm
+    .command("get-profile-idle-ms-v2")
+    .description("Get profile idle threshold (V2)")
+    .action(() => out({ profileIdleMs: getProfileIdleMsV2() }));
+
+  llm
+    .command("set-profile-idle-ms-v2 <ms>")
+    .description("Set profile idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setProfileIdleMsV2(Number(ms));
+        out({ profileIdleMs: getProfileIdleMsV2() });
+      }),
+    );
+
+  llm
+    .command("get-request-stuck-ms-v2")
+    .description("Get request stuck threshold (V2)")
+    .action(() => out({ requestStuckMs: getRequestStuckMsV2() }));
+
+  llm
+    .command("set-request-stuck-ms-v2 <ms>")
+    .description("Set request stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setRequestStuckMsV2(Number(ms));
+        out({ requestStuckMs: getRequestStuckMsV2() });
+      }),
+    );
+
+  llm
+    .command("active-profile-count-v2 <ownerId>")
+    .description("Active profile count for owner (V2)")
+    .action((ownerId) =>
+      out({ ownerId, count: getActiveProfileCountV2(ownerId) }),
+    );
+
+  llm
+    .command("pending-request-count-v2 <profileId>")
+    .description("Pending request count for profile (V2)")
+    .action((profileId) =>
+      out({ profileId, count: getPendingRequestCountV2(profileId) }),
+    );
+
+  llm
+    .command("register-profile-v2 <id>")
+    .description("Register a V2 profile")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-p, --provider <name>", "provider name")
+    .option("-m, --model <name>", "model name", "default")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          registerProfileV2(id, {
+            ownerId: opts.owner,
+            provider: opts.provider,
+            model: opts.model,
+          }),
+        ),
+      ),
+    );
+
+  llm
+    .command("get-profile-v2 <id>")
+    .description("Get a V2 profile")
+    .action((id) => out(getProfileV2(id)));
+
+  llm
+    .command("list-profiles-v2")
+    .description("List V2 profiles")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .option("-p, --provider <name>", "filter by provider")
+    .action((opts) =>
+      out(
+        listProfilesV2({
+          ownerId: opts.owner,
+          status: opts.status,
+          provider: opts.provider,
+        }),
+      ),
+    );
+
+  llm
+    .command("set-profile-status-v2 <id> <next>")
+    .description("Set V2 profile status")
+    .action((id, next) => tryRun(() => out(setProfileStatusV2(id, next))));
+
+  llm
+    .command("activate-profile-v2 <id>")
+    .description("Activate a V2 profile")
+    .action((id) => tryRun(() => out(activateProfileV2(id))));
+
+  llm
+    .command("suspend-profile-v2 <id>")
+    .description("Suspend a V2 profile")
+    .action((id) => tryRun(() => out(suspendProfileV2(id))));
+
+  llm
+    .command("retire-profile-v2 <id>")
+    .description("Retire a V2 profile")
+    .action((id) => tryRun(() => out(retireProfileV2(id))));
+
+  llm
+    .command("touch-profile-v2 <id>")
+    .description("Touch a V2 profile")
+    .action((id) => tryRun(() => out(touchProfileV2(id))));
+
+  llm
+    .command("create-request-v2 <id>")
+    .description("Create a V2 request")
+    .requiredOption("-p, --profile <id>", "profile id")
+    .option("-k, --kind <kind>", "request kind", "completion")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(createRequestV2(id, { profileId: opts.profile, kind: opts.kind })),
+      ),
+    );
+
+  llm
+    .command("get-request-v2 <id>")
+    .description("Get a V2 request")
+    .action((id) => out(getRequestV2(id)));
+
+  llm
+    .command("list-requests-v2")
+    .description("List V2 requests")
+    .option("-p, --profile <id>", "filter by profile")
+    .option("-s, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listRequestsV2({ profileId: opts.profile, status: opts.status })),
+    );
+
+  llm
+    .command("set-request-status-v2 <id> <next>")
+    .description("Set V2 request status")
+    .action((id, next) => tryRun(() => out(setRequestStatusV2(id, next))));
+
+  llm
+    .command("start-request-v2 <id>")
+    .description("Start a V2 request")
+    .action((id) => tryRun(() => out(startRequestV2(id))));
+
+  llm
+    .command("complete-request-v2 <id>")
+    .description("Complete a V2 request")
+    .action((id) => tryRun(() => out(completeRequestV2(id))));
+
+  llm
+    .command("fail-request-v2 <id>")
+    .description("Fail a V2 request")
+    .action((id) => tryRun(() => out(failRequestV2(id))));
+
+  llm
+    .command("cancel-request-v2 <id>")
+    .description("Cancel a V2 request")
+    .action((id) => tryRun(() => out(cancelRequestV2(id))));
+
+  llm
+    .command("auto-suspend-idle-profiles-v2")
+    .description("Auto-suspend idle V2 profiles")
+    .action(() => out(autoSuspendIdleProfilesV2()));
+
+  llm
+    .command("auto-fail-stuck-requests-v2")
+    .description("Auto-fail stuck V2 requests")
+    .action(() => out(autoFailStuckRequestsV2()));
 }