chainlesschain 0.47.4 → 0.47.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.47.4",
+  "version": "0.47.6",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {
@@ -59,6 +59,7 @@
     "@chainlesschain/core-db": "0.1.0",
     "@chainlesschain/core-config": "0.1.0",
     "@chainlesschain/core-infra": "0.1.0",
+    "@chainlesschain/session-core": "0.1.0",
     "ws": "^8.14.2"
   },
   "devDependencies": {

package/src/commands/config.js

@@ -129,6 +129,73 @@ export function registerConfigCommand(program) {
         logger.info("Reset cancelled");
       }
     });
+
+  // config beta — Managed Agents parity Phase E2 beta flags
+  const beta = cmd
+    .command("beta")
+    .description("Manage beta / experimental feature flags");
+
+  beta
+    .command("list", { isDefault: true })
+    .description("List enabled and known beta flags")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { getBetaFlags } =
+          await import("../lib/session-core-singletons.js");
+        const flags = await getBetaFlags();
+        const out = flags.list();
+        if (options.json) {
+          console.log(JSON.stringify(out, null, 2));
+          return;
+        }
+        logger.log(chalk.bold("Enabled beta flags:"));
+        if (out.enabled.length === 0) logger.log(chalk.gray("  (none)"));
+        for (const f of out.enabled) logger.log(`  ${chalk.green("✓")} ${f}`);
+        if (out.known.length > out.enabled.length) {
+          const disabled = out.known.filter((f) => !out.enabled.includes(f));
+          logger.log(chalk.bold("\nKnown (disabled):"));
+          for (const f of disabled) logger.log(`  ${chalk.gray("·")} ${f}`);
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  beta
+    .command("enable")
+    .description("Enable a beta flag (format: <feature>-<YYYY-MM-DD>)")
+    .argument("<flag>")
+    .action(async (flag) => {
+      try {
+        const { getBetaFlags } =
+          await import("../lib/session-core-singletons.js");
+        const flags = await getBetaFlags();
+        flags.enable(flag);
+        logger.success(`Enabled: ${chalk.cyan(flag)}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  beta
+    .command("disable")
+    .description("Disable a beta flag")
+    .argument("<flag>")
+    .action(async (flag) => {
+      try {
+        const { getBetaFlags } =
+          await import("../lib/session-core-singletons.js");
+        const flags = await getBetaFlags();
+        flags.disable(flag);
+        logger.success(`Disabled: ${chalk.cyan(flag)}`);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }
 
 function printConfig(obj, indent = "") {

package/src/commands/memory.js

@@ -239,6 +239,100 @@ export function registerMemoryCommand(program) {
       }
     });
 
+  // memory recall — Managed Agents parity Phase D2 (session-core MemoryStore)
+  memory
+    .command("recall")
+    .description("Recall scoped memory (session-core MemoryStore)")
+    .argument("[query]", "Query string")
+    .option("--scope <scope>", "session | agent | global")
+    .option(
+      "--scope-id <id>",
+      "Session or agent id (required for session/agent)",
+    )
+    .option("--category <cat>", "Filter by category")
+    .option("--tags <tags>", "Comma-separated tags")
+    .option("-n, --limit <n>", "Max results", "10")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+      try {
+        const { getMemoryStore } =
+          await import("../lib/session-core-singletons.js");
+        const store = getMemoryStore();
+        const tags = options.tags
+          ? options.tags
+              .split(",")
+              .map((t) => t.trim())
+              .filter(Boolean)
+          : null;
+        const results = store.recall({
+          query: query || "",
+          scope: options.scope,
+          scopeId: options.scopeId,
+          category: options.category,
+          tags,
+          limit: Math.max(1, parseInt(options.limit) || 10),
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else if (results.length === 0) {
+          logger.info("No scoped memory entries matched.");
+        } else {
+          logger.log(
+            chalk.bold(`Scoped memory (${results.length} results):\n`),
+          );
+          for (const m of results) {
+            logger.log(
+              `  ${chalk.gray(m.id.slice(0, 12))}  ${chalk.cyan(m.scope)}${m.scopeId ? ":" + m.scopeId.slice(0, 12) : ""}  ${chalk.yellow(m.category)}  rel=${m.relevance?.toFixed(2) ?? "?"}`,
+            );
+            logger.log(`    ${chalk.white(m.content.substring(0, 160))}`);
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // memory store — add to session-core MemoryStore (separate from DB-backed memory add)
+  memory
+    .command("store")
+    .description("Write a scoped memory (session-core MemoryStore)")
+    .argument("<content>")
+    .requiredOption("--scope <scope>", "session | agent | global")
+    .option("--scope-id <id>", "Required for session/agent scope")
+    .option("--category <cat>", "Category", "general")
+    .option("--tags <tags>", "Comma-separated tags")
+    .option("--json", "Output as JSON")
+    .action(async (content, options) => {
+      try {
+        const { getMemoryStore } =
+          await import("../lib/session-core-singletons.js");
+        const store = getMemoryStore();
+        const tags = options.tags
+          ? options.tags
+              .split(",")
+              .map((t) => t.trim())
+              .filter(Boolean)
+          : [];
+        const m = store.add({
+          scope: options.scope,
+          scopeId: options.scopeId || null,
+          category: options.category,
+          content,
+          tags,
+        });
+        if (options.json) console.log(JSON.stringify(m, null, 2));
+        else
+          logger.success(
+            `Stored ${chalk.gray(m.id.slice(0, 12))} [${chalk.cyan(m.scope)}/${m.category}]`,
+          );
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // memory file
   memory
     .command("file")

package/src/commands/session.js

@@ -416,6 +416,40 @@ export function registerSessionCommand(program) {
       }
     });
 
+  // session policy — Managed Agents parity Phase E1 approval policy
+  session
+    .command("policy")
+    .description("Show or set per-session approval policy")
+    .argument("<id>", "Session ID")
+    .option("--set <policy>", "strict | trusted | autopilot")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const { getApprovalGate } =
+          await import("../lib/session-core-singletons.js");
+        const gate = await getApprovalGate();
+        if (options.set) {
+          gate.setSessionPolicy(id, options.set);
+          // give persistence a tick before the CLI process exits
+          await new Promise((r) => setImmediate(r));
+          logger.success(
+            `Session ${chalk.gray(id.slice(0, 12))} policy → ${chalk.cyan(options.set)}`,
+          );
+        }
+        const current = gate.getSessionPolicy(id);
+        if (options.json) {
+          console.log(JSON.stringify({ sessionId: id, policy: current }));
+        } else if (!options.set) {
+          logger.log(
+            `Session ${chalk.gray(id.slice(0, 12))} policy: ${chalk.cyan(current)}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
   // session workflow — inspect canonical coding workflow state
   // Reads .chainlesschain/sessions/<id>/{intent.md,plan.md,progress.log,mode.json}
   // written by the 4 workflow skills ($deep-interview/$ralplan/$ralph/$team).

package/src/lib/session-core-singletons.js

@@ -0,0 +1,70 @@
+/**
+ * Session-core singletons for the CLI
+ *
+ * Wires MemoryStore / BetaFlags / ApprovalGate with file-based persistence under
+ * the CLI home dir (`~/.chainlesschain/`).
+ *
+ * Lazy: instances are created on first access so bootstrap stays fast.
+ */
+
+import { join } from "node:path";
+import { getHomeDir } from "./paths.js";
+import {
+  MemoryStore,
+  BetaFlags,
+  ApprovalGate,
+  APPROVAL_POLICY,
+  createMemoryFileAdapter,
+  createBetaFlagsFileAdapter,
+  createApprovalGateFileAdapter,
+  hydrateMemoryStore,
+} from "@chainlesschain/session-core";
+
+let _memoryStore = null;
+let _betaFlags = null;
+let _approvalGate = null;
+
+export function getMemoryStorePath() {
+  return join(getHomeDir(), "memory-store.json");
+}
+
+export function getBetaFlagsPath() {
+  return join(getHomeDir(), "beta-flags.json");
+}
+
+export function getApprovalPoliciesPath() {
+  return join(getHomeDir(), "approval-policies.json");
+}
+
+export function getMemoryStore() {
+  if (_memoryStore) return _memoryStore;
+  const adapter = createMemoryFileAdapter(getMemoryStorePath());
+  _memoryStore = new MemoryStore({ adapter });
+  hydrateMemoryStore(_memoryStore, adapter);
+  return _memoryStore;
+}
+
+export async function getBetaFlags() {
+  if (_betaFlags) return _betaFlags;
+  const store = createBetaFlagsFileAdapter(getBetaFlagsPath());
+  _betaFlags = new BetaFlags({ store });
+  await _betaFlags.load();
+  return _betaFlags;
+}
+
+export async function getApprovalGate() {
+  if (_approvalGate) return _approvalGate;
+  const store = createApprovalGateFileAdapter(getApprovalPoliciesPath());
+  _approvalGate = new ApprovalGate({
+    defaultPolicy: APPROVAL_POLICY.STRICT,
+    store,
+  });
+  await _approvalGate.load();
+  return _approvalGate;
+}
+
+export function resetSessionCoreSingletonsForTests() {
+  _memoryStore = null;
+  _betaFlags = null;
+  _approvalGate = null;
+}

package/src/session/index.js

@@ -0,0 +1,7 @@
+/**
+ * CLI session module — thin re-export of @chainlesschain/session-core
+ *
+ * Managed Agents parity Phase A+B.
+ * Consume via: require("../session") inside packages/cli/src/.
+ */
+module.exports = require("@chainlesschain/session-core");