chainlesschain 0.81.0 → 0.132.0

package/src/commands/skill.js

@@ -11,7 +11,41 @@ import ora from "ora";
 import fs from "fs";
 import path from "path";
 import { logger } from "../lib/logger.js";
-import { CLISkillLoader, LAYER_NAMES } from "../lib/skill-loader.js";
+import {
+  CLISkillLoader,
+  LAYER_NAMES,
+  SKILL_MATURITY_V2,
+  EXECUTION_LIFECYCLE_V2,
+  getMaxActiveSkillsPerOwnerV2,
+  setMaxActiveSkillsPerOwnerV2,
+  getMaxPendingExecutionsPerSkillV2,
+  setMaxPendingExecutionsPerSkillV2,
+  getSkillIdleMsV2,
+  setSkillIdleMsV2,
+  getExecStuckMsV2,
+  setExecStuckMsV2,
+  registerSkillV2,
+  getSkillV2,
+  listSkillsV2,
+  setSkillStatusV2,
+  activateSkillV2,
+  deprecateSkillV2,
+  archiveSkillV2,
+  touchSkillV2,
+  getActiveSkillCountV2,
+  createExecutionV2,
+  getExecutionV2,
+  listExecutionsV2,
+  setExecutionStatusV2,
+  startExecutionV2,
+  succeedExecutionV2,
+  failExecutionV2,
+  cancelExecutionV2,
+  getPendingExecutionCountV2,
+  autoDeprecateIdleSkillsV2,
+  autoFailStuckExecutionsV2,
+  getSkillLoaderStatsV2,
+} from "../lib/skill-loader.js";
 import { getElectronUserDataDir } from "../lib/paths.js";
 import { findProjectRoot } from "../lib/project-detector.js";
 import {
@@ -695,4 +729,236 @@ export function registerSkillCommand(program) {
         `  ${chalk.bold("Total:")} ${allSkills.length} skills resolved\n`,
       );
     });
+
+  // ─── 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);
+    }
+  };
+
+  skill
+    .command("skill-maturities-v2")
+    .description("List V2 skill maturity states")
+    .action(() => out(Object.values(SKILL_MATURITY_V2)));
+
+  skill
+    .command("execution-lifecycles-v2")
+    .description("List V2 execution lifecycle states")
+    .action(() => out(Object.values(EXECUTION_LIFECYCLE_V2)));
+
+  skill
+    .command("stats-v2")
+    .description("V2 skill-loader stats")
+    .action(() => out(getSkillLoaderStatsV2()));
+
+  skill
+    .command("get-max-active-skills-v2")
+    .description("Get max active skills per owner (V2)")
+    .action(() =>
+      out({ maxActiveSkillsPerOwner: getMaxActiveSkillsPerOwnerV2() }),
+    );
+
+  skill
+    .command("set-max-active-skills-v2 <n>")
+    .description("Set max active skills per owner (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxActiveSkillsPerOwnerV2(Number(n));
+        out({ maxActiveSkillsPerOwner: getMaxActiveSkillsPerOwnerV2() });
+      }),
+    );
+
+  skill
+    .command("get-max-pending-executions-v2")
+    .description("Get max pending executions per skill (V2)")
+    .action(() =>
+      out({
+        maxPendingExecutionsPerSkill: getMaxPendingExecutionsPerSkillV2(),
+      }),
+    );
+
+  skill
+    .command("set-max-pending-executions-v2 <n>")
+    .description("Set max pending executions per skill (V2)")
+    .action((n) =>
+      tryRun(() => {
+        setMaxPendingExecutionsPerSkillV2(Number(n));
+        out({
+          maxPendingExecutionsPerSkill: getMaxPendingExecutionsPerSkillV2(),
+        });
+      }),
+    );
+
+  skill
+    .command("get-skill-idle-ms-v2")
+    .description("Get skill idle threshold (V2)")
+    .action(() => out({ skillIdleMs: getSkillIdleMsV2() }));
+
+  skill
+    .command("set-skill-idle-ms-v2 <ms>")
+    .description("Set skill idle threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setSkillIdleMsV2(Number(ms));
+        out({ skillIdleMs: getSkillIdleMsV2() });
+      }),
+    );
+
+  skill
+    .command("get-exec-stuck-ms-v2")
+    .description("Get execution stuck threshold (V2)")
+    .action(() => out({ execStuckMs: getExecStuckMsV2() }));
+
+  skill
+    .command("set-exec-stuck-ms-v2 <ms>")
+    .description("Set execution stuck threshold (V2)")
+    .action((ms) =>
+      tryRun(() => {
+        setExecStuckMsV2(Number(ms));
+        out({ execStuckMs: getExecStuckMsV2() });
+      }),
+    );
+
+  skill
+    .command("active-skill-count-v2 <ownerId>")
+    .description("Active skill count for owner (V2)")
+    .action((ownerId) =>
+      out({ ownerId, count: getActiveSkillCountV2(ownerId) }),
+    );
+
+  skill
+    .command("pending-execution-count-v2 <skillId>")
+    .description("Pending execution count for skill (V2)")
+    .action((skillId) =>
+      out({ skillId, count: getPendingExecutionCountV2(skillId) }),
+    );
+
+  skill
+    .command("register-skill-v2 <id>")
+    .description("Register a V2 skill")
+    .requiredOption("-o, --owner <id>", "owner id")
+    .requiredOption("-n, --name <name>", "skill name")
+    .option("-l, --layer <layer>", "skill layer", "workspace")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(
+          registerSkillV2(id, {
+            ownerId: opts.owner,
+            name: opts.name,
+            layer: opts.layer,
+          }),
+        ),
+      ),
+    );
+
+  skill
+    .command("get-skill-v2 <id>")
+    .description("Get a V2 skill")
+    .action((id) => out(getSkillV2(id)));
+
+  skill
+    .command("list-skills-v2")
+    .description("List V2 skills")
+    .option("-o, --owner <id>", "filter by owner")
+    .option("-s, --status <status>", "filter by status")
+    .option("-l, --layer <layer>", "filter by layer")
+    .action((opts) =>
+      out(
+        listSkillsV2({
+          ownerId: opts.owner,
+          status: opts.status,
+          layer: opts.layer,
+        }),
+      ),
+    );
+
+  skill
+    .command("set-skill-status-v2 <id> <next>")
+    .description("Set V2 skill status")
+    .action((id, next) => tryRun(() => out(setSkillStatusV2(id, next))));
+
+  skill
+    .command("activate-skill-v2 <id>")
+    .description("Activate a V2 skill")
+    .action((id) => tryRun(() => out(activateSkillV2(id))));
+
+  skill
+    .command("deprecate-skill-v2 <id>")
+    .description("Deprecate a V2 skill")
+    .action((id) => tryRun(() => out(deprecateSkillV2(id))));
+
+  skill
+    .command("archive-skill-v2 <id>")
+    .description("Archive a V2 skill")
+    .action((id) => tryRun(() => out(archiveSkillV2(id))));
+
+  skill
+    .command("touch-skill-v2 <id>")
+    .description("Touch a V2 skill")
+    .action((id) => tryRun(() => out(touchSkillV2(id))));
+
+  skill
+    .command("create-execution-v2 <id>")
+    .description("Create a V2 execution")
+    .requiredOption("-s, --skill <id>", "skill id")
+    .option("-k, --kind <kind>", "execution kind", "invoke")
+    .action((id, opts) =>
+      tryRun(() =>
+        out(createExecutionV2(id, { skillId: opts.skill, kind: opts.kind })),
+      ),
+    );
+
+  skill
+    .command("get-execution-v2 <id>")
+    .description("Get a V2 execution")
+    .action((id) => out(getExecutionV2(id)));
+
+  skill
+    .command("list-executions-v2")
+    .description("List V2 executions")
+    .option("-s, --skill <id>", "filter by skill")
+    .option("-t, --status <status>", "filter by status")
+    .action((opts) =>
+      out(listExecutionsV2({ skillId: opts.skill, status: opts.status })),
+    );
+
+  skill
+    .command("set-execution-status-v2 <id> <next>")
+    .description("Set V2 execution status")
+    .action((id, next) => tryRun(() => out(setExecutionStatusV2(id, next))));
+
+  skill
+    .command("start-execution-v2 <id>")
+    .description("Start a V2 execution")
+    .action((id) => tryRun(() => out(startExecutionV2(id))));
+
+  skill
+    .command("succeed-execution-v2 <id>")
+    .description("Succeed a V2 execution")
+    .action((id) => tryRun(() => out(succeedExecutionV2(id))));
+
+  skill
+    .command("fail-execution-v2 <id>")
+    .description("Fail a V2 execution")
+    .action((id) => tryRun(() => out(failExecutionV2(id))));
+
+  skill
+    .command("cancel-execution-v2 <id>")
+    .description("Cancel a V2 execution")
+    .action((id) => tryRun(() => out(cancelExecutionV2(id))));
+
+  skill
+    .command("auto-deprecate-idle-skills-v2")
+    .description("Auto-deprecate idle V2 skills")
+    .action(() => out(autoDeprecateIdleSkillsV2()));
+
+  skill
+    .command("auto-fail-stuck-executions-v2")
+    .description("Auto-fail stuck V2 executions")
+    .action(() => out(autoFailStuckExecutionsV2()));
 }

package/src/commands/social.js

@@ -23,6 +23,35 @@ import {
   getChatMessages,
   getChatThreads,
   getSocialStats,
+  RELATIONSHIP_MATURITY_V2,
+  THREAD_LIFECYCLE_V2,
+  getMaxConnectedPerUserV2,
+  setMaxConnectedPerUserV2,
+  getMaxOpenThreadsPerUserV2,
+  setMaxOpenThreadsPerUserV2,
+  getRelationshipIdleMsV2,
+  setRelationshipIdleMsV2,
+  getThreadStuckMsV2,
+  setThreadStuckMsV2,
+  getConnectedCountV2,
+  getOpenThreadCountV2,
+  registerRelationshipV2,
+  getRelationshipV2,
+  listRelationshipsV2,
+  connectRelationshipV2,
+  muteRelationshipV2,
+  blockRelationshipV2,
+  touchRelationshipV2,
+  createThreadV2,
+  getThreadV2,
+  listThreadsV2,
+  engageThreadV2,
+  resolveThreadV2,
+  abandonThreadV2,
+  reportThreadV2,
+  autoMuteIdleRelationshipsV2,
+  autoAbandonStuckThreadsV2,
+  getSocialManagerStatsV2,
 } from "../lib/social-manager.js";
 import { classifyTopic, detectLanguage } from "../lib/topic-classifier.js";
 import {
@@ -1053,4 +1082,231 @@ export function registerSocialCommand(program) {
         process.exit(1);
       }
     });
+
+  // ─────────────────────────────────────────────────────────────
+  // V2 Surface — relationship + thread lifecycle (in-memory, throwing)
+  // ─────────────────────────────────────────────────────────────
+
+  social
+    .command("relationship-maturities-v2")
+    .description("List V2 relationship maturity states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const v = Object.values(RELATIONSHIP_MATURITY_V2);
+      if (options.json) console.log(JSON.stringify(v));
+      else logger.log(v.join(", "));
+    });
+
+  social
+    .command("thread-lifecycles-v2")
+    .description("List V2 thread lifecycle states")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const v = Object.values(THREAD_LIFECYCLE_V2);
+      if (options.json) console.log(JSON.stringify(v));
+      else logger.log(v.join(", "));
+    });
+
+  social
+    .command("stats-v2")
+    .description("Show V2 social stats")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const stats = getSocialManagerStatsV2();
+      if (options.json) console.log(JSON.stringify(stats, null, 2));
+      else logger.log(JSON.stringify(stats, null, 2));
+    });
+
+  social
+    .command("get-max-connected-v2")
+    .description("Get max connected per user")
+    .action(() => logger.log(String(getMaxConnectedPerUserV2())));
+  social
+    .command("set-max-connected-v2 <n>")
+    .description("Set max connected per user")
+    .action((n) => {
+      setMaxConnectedPerUserV2(Number(n));
+      logger.log(String(getMaxConnectedPerUserV2()));
+    });
+  social
+    .command("get-max-open-threads-v2")
+    .description("Get max open threads per user")
+    .action(() => logger.log(String(getMaxOpenThreadsPerUserV2())));
+  social
+    .command("set-max-open-threads-v2 <n>")
+    .description("Set max open threads per user")
+    .action((n) => {
+      setMaxOpenThreadsPerUserV2(Number(n));
+      logger.log(String(getMaxOpenThreadsPerUserV2()));
+    });
+  social
+    .command("get-relationship-idle-ms-v2")
+    .description("Get relationship idle ms")
+    .action(() => logger.log(String(getRelationshipIdleMsV2())));
+  social
+    .command("set-relationship-idle-ms-v2 <ms>")
+    .description("Set relationship idle ms")
+    .action((ms) => {
+      setRelationshipIdleMsV2(Number(ms));
+      logger.log(String(getRelationshipIdleMsV2()));
+    });
+  social
+    .command("get-thread-stuck-ms-v2")
+    .description("Get thread stuck ms")
+    .action(() => logger.log(String(getThreadStuckMsV2())));
+  social
+    .command("set-thread-stuck-ms-v2 <ms>")
+    .description("Set thread stuck ms")
+    .action((ms) => {
+      setThreadStuckMsV2(Number(ms));
+      logger.log(String(getThreadStuckMsV2()));
+    });
+
+  social
+    .command("connected-count-v2 <userId>")
+    .description("Count connected relationships for user")
+    .action((userId) => logger.log(String(getConnectedCountV2(userId))));
+  social
+    .command("open-thread-count-v2 <userId>")
+    .description("Count open+engaged threads for user")
+    .action((userId) => logger.log(String(getOpenThreadCountV2(userId))));
+
+  social
+    .command("register-relationship-v2 <id>")
+    .description("Register V2 relationship (initial=pending)")
+    .requiredOption("-u, --user <userId>", "user id")
+    .requiredOption("-p, --peer <peerId>", "peer id")
+    .option("-m, --metadata <json>", "metadata JSON", "{}")
+    .action((id, opts) => {
+      const meta = JSON.parse(opts.metadata);
+      const r = registerRelationshipV2(id, {
+        userId: opts.user,
+        peerId: opts.peer,
+        metadata: meta,
+      });
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  social
+    .command("get-relationship-v2 <id>")
+    .description("Get V2 relationship by id")
+    .action((id) => {
+      const r = getRelationshipV2(id);
+      if (!r) {
+        logger.error(`relationship ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(r, null, 2));
+    });
+
+  social
+    .command("list-relationships-v2")
+    .description("List V2 relationships")
+    .option("-u, --user <userId>", "filter by user")
+    .option("-s, --status <state>", "filter by status")
+    .action((opts) => {
+      const out = listRelationshipsV2({
+        userId: opts.user,
+        status: opts.status,
+      });
+      console.log(JSON.stringify(out, null, 2));
+    });
+
+  social
+    .command("connect-relationship-v2 <id>")
+    .description("Transition relationship → connected")
+    .action((id) =>
+      console.log(JSON.stringify(connectRelationshipV2(id), null, 2)),
+    );
+  social
+    .command("mute-relationship-v2 <id>")
+    .description("Transition relationship → muted")
+    .action((id) =>
+      console.log(JSON.stringify(muteRelationshipV2(id), null, 2)),
+    );
+  social
+    .command("block-relationship-v2 <id>")
+    .description("Transition relationship → blocked (terminal)")
+    .action((id) =>
+      console.log(JSON.stringify(blockRelationshipV2(id), null, 2)),
+    );
+  social
+    .command("touch-relationship-v2 <id>")
+    .description("Update relationship lastSeenAt")
+    .action((id) =>
+      console.log(JSON.stringify(touchRelationshipV2(id), null, 2)),
+    );
+
+  social
+    .command("create-thread-v2 <id>")
+    .description("Create V2 thread (initial=open)")
+    .requiredOption("-u, --user <userId>", "user id")
+    .requiredOption("-t, --topic <topic>", "topic")
+    .option("-m, --metadata <json>", "metadata JSON", "{}")
+    .action((id, opts) => {
+      const meta = JSON.parse(opts.metadata);
+      const t = createThreadV2(id, {
+        userId: opts.user,
+        topic: opts.topic,
+        metadata: meta,
+      });
+      console.log(JSON.stringify(t, null, 2));
+    });
+
+  social
+    .command("get-thread-v2 <id>")
+    .description("Get V2 thread by id")
+    .action((id) => {
+      const t = getThreadV2(id);
+      if (!t) {
+        logger.error(`thread ${id} not found`);
+        process.exit(1);
+      }
+      console.log(JSON.stringify(t, null, 2));
+    });
+
+  social
+    .command("list-threads-v2")
+    .description("List V2 threads")
+    .option("-u, --user <userId>", "filter by user")
+    .option("-s, --status <state>", "filter by status")
+    .action((opts) => {
+      const out = listThreadsV2({
+        userId: opts.user,
+        status: opts.status,
+      });
+      console.log(JSON.stringify(out, null, 2));
+    });
+
+  social
+    .command("engage-thread-v2 <id>")
+    .description("Transition thread → engaged")
+    .action((id) => console.log(JSON.stringify(engageThreadV2(id), null, 2)));
+  social
+    .command("resolve-thread-v2 <id>")
+    .description("Transition thread → resolved (terminal)")
+    .action((id) => console.log(JSON.stringify(resolveThreadV2(id), null, 2)));
+  social
+    .command("abandon-thread-v2 <id>")
+    .description("Transition thread → abandoned (terminal)")
+    .action((id) => console.log(JSON.stringify(abandonThreadV2(id), null, 2)));
+  social
+    .command("report-thread-v2 <id>")
+    .description("Transition thread → reported (terminal)")
+    .action((id) => console.log(JSON.stringify(reportThreadV2(id), null, 2)));
+
+  social
+    .command("auto-mute-idle-rel-v2")
+    .description("Auto-mute idle connected relationships; output flipped")
+    .action(() => {
+      const flipped = autoMuteIdleRelationshipsV2();
+      console.log(JSON.stringify(flipped, null, 2));
+    });
+  social
+    .command("auto-abandon-stuck-threads-v2")
+    .description("Auto-abandon stuck threads; output flipped")
+    .action(() => {
+      const flipped = autoAbandonStuckThreadsV2();
+      console.log(JSON.stringify(flipped, null, 2));
+    });
 }