@codyswann/lisa 4.81.2 → 4.81.4

package/plugins/lisa/skills/lisa-session-manager/scripts/session-manager.mjs

@@ -18,11 +18,14 @@
  * background sessions (`claude --bg`, `claude agents`), cross-session
  * messaging and channels, which no other supported agent has. Codex, Cursor,
  * OpenCode, Antigravity, Copilot and Devin can run the setup-time subcommands
- * (init-config, store-token, validate, start), and `start` hosts a Claude Code
- * manager in tmux whatever agent ran it; they cannot run a manager cycle
+ * (init-config, store-token, trust-status, coexistence, validate, start), and
+ * `start` hosts a Claude Code manager in tmux whatever agent ran it. Note that
+ * trust-status reads Claude Code's own trust record, which is the one that
+ * matters: workers are always Claude Code. They cannot run a manager cycle
  * themselves. OpenCode copies skill folders without the plugin-level
- * `scripts/` directory, so `queue` and `record-cycle` (which import from it)
- * are unavailable there unless the npm package provides that directory.
+ * `scripts/` directory, and this entry point statically imports modules that
+ * reach into it (cli-cycle.mjs, cli-runtime.mjs), so on OpenCode every
+ * subcommand runs only from the npm package, never from the skill-folder copy.
  * @module session-manager
  */
 import { readFileSync, realpathSync } from "node:fs";
@@ -38,17 +41,15 @@ import {
   recordCycle,
   route,
 } from "./cli-cycle.mjs";
+import { repoDir, start, status, stop, validate } from "./cli-manager.mjs";
+import { queue } from "./cli-queue.mjs";
+import { CliError, EXIT } from "./cli-runtime.mjs";
 import {
+  coexistence,
   initConfig,
-  repoDir,
-  start,
-  status,
-  stop,
   storeToken,
-  validate,
-} from "./cli-manager.mjs";
-import { queue } from "./cli-queue.mjs";
-import { CliError, EXIT } from "./cli-runtime.mjs";
+  trustStatus,
+} from "./cli-setup.mjs";
 import { USAGE } from "./cli-usage.mjs";
 import { capacity, classify, resume, spawn } from "./cli-workers.mjs";
 
@@ -67,9 +68,11 @@ const COMMANDS = {
   stop: { run: stop, options: {}, positionals: 0 },
   "store-token": {
     run: storeToken,
-    options: { replace: flag },
+    options: { replace: flag, "from-clipboard": flag },
     positionals: 0,
   },
+  "trust-status": { run: trustStatus, options: {}, positionals: 0 },
+  coexistence: { run: coexistence, options: {}, positionals: 0 },
   "repo-dir": {
     run: repoDir,
     options: { repo: text, raw: flag },

package/plugins/lisa/skills/lisa-session-manager/scripts/setup-checks.mjs

@@ -0,0 +1,168 @@
+/**
+ * Read-only facts setup needs before it asks the operator for anything:
+ * which worker directories Claude Code already trusts, and whether a
+ * scheduled intake loop is still running alongside the manager.
+ *
+ * Both used to be manual (CodySwannGT/lisa#4465). Setup asked the operator to
+ * open `claude` in every worker directory to accept workspace trust, even
+ * where Claude Code had already recorded it; and it only warned that
+ * `intake-tickets` / `intake-repair` compete with the manager, leaving the
+ * agent to dig through run logs to find out whether either was alive.
+ *
+ * Neither check writes anything, and neither answers a trust prompt.
+ * @module session-manager/setup-checks
+ */
+import * as nodeFs from "node:fs";
+import path from "node:path";
+
+/** The scheduled loops that compete with the manager for the same items. */
+export const COMPETING_LOOPS = Object.freeze([
+  "intake-tickets",
+  "intake-repair",
+]);
+
+/** A loop counts as recent when it ran within at least this long. */
+const MIN_RECENT_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Where Claude Code keeps its global state, including per-directory trust:
+ * `$CLAUDE_CONFIG_DIR/.claude.json` when that is set, else `~/.claude.json`.
+ * @param {{ env?: Record<string, string | undefined>, homedir: string }} input
+ *   - Environment and home directory
+ * @returns {string} Absolute path
+ */
+export function claudeStateFile({ env = {}, homedir }) {
+  const configDir = env.CLAUDE_CONFIG_DIR;
+  return configDir
+    ? path.join(configDir, ".claude.json")
+    : path.join(homedir, ".claude.json");
+}
+
+/**
+ * Whether Claude Code has recorded workspace trust for each directory.
+ *
+ * `true` and `false` come from Claude Code's own record
+ * (`projects[<dir>].hasTrustDialogAccepted`). A directory and the key Claude
+ * Code recorded can name the same place through different symlinks (macOS
+ * `/var` is `/private/var`), so a key matches when the two realpaths agree;
+ * only keys with the same final segment are resolved, so a large state file
+ * costs a handful of realpath calls. `unknown` means the record could not be
+ * read, so the operator still has to check that directory by hand.
+ * @param {{ dirs: string[], env?: Record<string, string | undefined>,
+ *   homedir: string, fs?: Pick<typeof nodeFs, "readFileSync" | "realpathSync"> }}
+ *   input - Worker directories, environment, home directory and fs seam
+ * @returns {{ file: string, dirs: Array<{ dir: string,
+ *   trusted: true | false | "unknown" }> }} One row per directory
+ */
+export function trustStatus({ dirs, env, homedir, fs = nodeFs }) {
+  const file = claudeStateFile({ env, homedir });
+  let projects = null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    projects =
+      parsed && typeof parsed.projects === "object" ? parsed.projects : {};
+  } catch {
+    projects = null;
+  }
+  const realpath = dir => {
+    try {
+      return fs.realpathSync(dir);
+    } catch {
+      return dir;
+    }
+  };
+  const entryFor = dir => {
+    if (Object.hasOwn(projects, dir)) return projects[dir];
+    const target = realpath(dir);
+    const key = Object.keys(projects).find(
+      candidate =>
+        path.basename(candidate) === path.basename(dir) &&
+        realpath(candidate) === target
+    );
+    return key === undefined ? undefined : projects[key];
+  };
+  return {
+    file,
+    dirs: dirs.map(dir => {
+      if (projects === null) return { dir, trusted: "unknown" };
+      return { dir, trusted: entryFor(dir)?.hasTrustDialogAccepted === true };
+    }),
+  };
+}
+
+/**
+ * The last parseable record of a loop's run log, or null.
+ * @param {string} file - `.lisa/automations/runs/<loop>.jsonl`
+ * @param {Pick<typeof nodeFs, "readFileSync">} fs - Filesystem seam
+ * @returns {{ ts: string, outcome: string | null } | null} Last record
+ */
+function lastRunRecord(file, fs) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = text.split("\n").filter(line => line.trim());
+  for (const line of lines.reverse()) {
+    try {
+      const record = JSON.parse(line);
+      if (
+        typeof record?.ts === "string" &&
+        !Number.isNaN(Date.parse(record.ts))
+      ) {
+        return { ts: record.ts, outcome: record.outcome ?? null };
+      }
+    } catch {
+      // A torn or foreign line: keep looking further back.
+    }
+  }
+  return null;
+}
+
+/**
+ * How long a loop may go without a recorded run and still count as live:
+ * twice the time the manager gives a silent worker before giving up on it
+ * (`stall.noOutputMinutes × stall.maxAttempts`), and never under a day.
+ * @param {{ noOutputMinutes?: number, maxAttempts?: number } | undefined} stall
+ *   - The manager's stall settings
+ * @returns {number} Milliseconds
+ */
+export function recentWindowMs(stall) {
+  const minutes = (stall?.noOutputMinutes ?? 60) * (stall?.maxAttempts ?? 3);
+  return Math.max(MIN_RECENT_MS, 2 * minutes * 60 * 1000);
+}
+
+/**
+ * What this project's own run logs say about each competing intake loop.
+ *
+ * A loop with a recent recorded run is probably still scheduled and will
+ * compete with the manager. A stale or missing log is evidence, not proof,
+ * that it stopped: the runtime's scheduler (claude.ai routines, Codex
+ * automations, GitHub Actions) is the authority, and setup lists it too.
+ * @param {{ root: string, now: Date, stall?: object,
+ *   fs?: Pick<typeof nodeFs, "readFileSync"> }} input - Project root, the
+ *   current time, the manager's stall settings and fs seam
+ * @returns {{ windowHours: number, loops: Array<{ loop: string,
+ *   log: string, lastRun: { ts: string, outcome: string | null } | null,
+ *   recent: boolean }> }} One row per competing loop
+ */
+export function coexistence({ root, now, stall, fs = nodeFs }) {
+  const windowMs = recentWindowMs(stall);
+  return {
+    windowHours: windowMs / 3_600_000,
+    loops: COMPETING_LOOPS.map(loop => {
+      const log = path.join(
+        root,
+        ".lisa",
+        "automations",
+        "runs",
+        `${loop}.jsonl`
+      );
+      const lastRun = lastRunRecord(log, fs);
+      const recent =
+        lastRun !== null && now.getTime() - Date.parse(lastRun.ts) <= windowMs;
+      return { loop, log, lastRun, recent };
+    }),
+  };
+}

package/plugins/lisa/skills/lisa-session-manager/scripts/token.mjs

@@ -1,7 +1,8 @@
 /**
  * The Telegram bot token the manager needs: validated, stored in
  * `<stateDir>/.env` (dir 0700, file 0600), read from the operator's terminal
- * with echo off, and never put in argv, a return value, an error message or a
+ * with echo off or from the clipboard (`--from-clipboard`, for when no TTY is
+ * reachable), and never put in argv, a return value, an error message or a
  * log line. An existing token is replaced only on request. Split out of
  * launch.mjs, which re-exports everything here.
  * @module token
@@ -10,6 +11,7 @@ import { randomUUID } from "node:crypto";
 import * as nodeFs from "node:fs";
 import path from "node:path";
 
+import { readClipboard } from "./clipboard.mjs";
 import { LaunchError, resolveStateDir } from "./state-dir.mjs";
 
 /** The shape of a BotFather token: `<bot id>:<secret>`. */
@@ -94,41 +96,110 @@ function shellQuote(word) {
  *   input - Script and project locations, and whether to carry `--replace`
  * @returns {string} One shell line
  */
-export function buildStoreTokenCommand({ scriptsDir, projectRoot, replace }) {
+export function buildStoreTokenCommand({
+  scriptsDir,
+  projectRoot,
+  replace,
+  fromClipboard = false,
+}) {
   const script = shellQuote(path.join(scriptsDir, "session-manager.mjs"));
-  const flag = replace ? " --replace" : "";
-  return `node ${script} store-token${flag} --project-root ${shellQuote(projectRoot)}`;
+  const flags =
+    (replace ? " --replace" : "") + (fromClipboard ? " --from-clipboard" : "");
+  return `node ${script} store-token${flags} --project-root ${shellQuote(projectRoot)}`;
+}
+
+/** Why `store-token` cannot prompt here, and the two ways forward. */
+const NO_TTY_HINT =
+  "No terminal to prompt on, and Claude Code's ! prefix has no TTY either. " +
+  "Run `command` in a separate terminal app, or copy the token from " +
+  "BotFather and run `clipboardCommand`.";
+
+/** The `invalid` outcome; names the expected shape, never the input. */
+const INVALID = Object.freeze({
+  stored: false,
+  reason: "invalid",
+  message:
+    "That does not look like a Telegram bot token " +
+    "(expected <digits>:<30 or more letters, digits, _ or ->).",
+});
+
+/**
+ * Refuse to overwrite an existing token unless `replace` was asked for: a
+ * second project that shares this state dir by mistake would otherwise
+ * silently take over the first project's bot.
+ * @param {string} stateDir - Resolved state dir
+ * @param {boolean} replace - `--replace`
+ * @param {{ fs?: { existsSync?: (p: string) => boolean } }} io - Seams
+ */
+function assertReplaceable(stateDir, replace, io) {
+  const existing = path.join(stateDir, TOKEN_FILE_NAME);
+  const exists = io.fs?.existsSync ?? nodeFs.existsSync;
+  if (!replace && exists(existing)) {
+    throw new LaunchError(
+      `A bot token already exists at ${existing}. Nothing was changed. ` +
+        `Re-run store-token with --replace to overwrite it.`
+    );
+  }
+}
+
+/**
+ * Store the bot token from the system clipboard, with no TTY needed.
+ *
+ * Same validation and the same existing-token rule as the prompt. The
+ * clipboard is cleared only after a successful store, so a failed attempt
+ * leaves the operator's copy in place to retry with. The token is never
+ * returned, and an invalid value is reported by shape, never echoed.
+ * @param {{ stateDir: string, replace?: boolean,
+ *   env?: Record<string, string | undefined>, homedir?: string,
+ *   io?: { readClipboard?: typeof readClipboard, fs?: object } }} input -
+ *   Configured state dir, the `--replace` flag and seams
+ * @returns {{ stored: true, path: string, clipboardCleared: boolean } |
+ *   { stored: false, reason: "empty" | "invalid" | "unsupported" |
+ *     "unavailable" | "failed", message: string }} Outcome
+ */
+export function storeTokenFromClipboard(input) {
+  const { replace = false, io = {} } = input;
+  const stateDir = resolveStateDir(input.stateDir, input);
+  assertReplaceable(stateDir, replace, io);
+  const clip = (io.readClipboard ?? readClipboard)();
+  if (!clip.ok) {
+    return { stored: false, reason: clip.reason, message: clip.message };
+  }
+  const token = clip.text.trim();
+  if (!token) {
+    return {
+      stored: false,
+      reason: "empty",
+      message: "The clipboard is empty.",
+    };
+  }
+  if (!validateBotToken(token)) return { ...INVALID };
+  const written = writeTokenFile(stateDir, token, io);
+  return { stored: true, ...written, clipboardCleared: clip.clear() };
 }
 
 /**
  * Prompt for the bot token on the operator's terminal and store it.
  *
- * An existing token is never overwritten without `replace`: a second project
- * that shares this state dir by mistake would otherwise silently take over the
- * first project's bot. With no TTY this does not prompt and does not fail: it
- * returns the exact command for the operator to run themselves, because an
- * agent's Bash can never answer a prompt and a hung setup looks like a slow
- * one.
+ * An existing token is never overwritten without `replace`. With no TTY this
+ * does not prompt and does not fail: it returns the exact command for the
+ * operator to run in a separate terminal app, and the `--from-clipboard` form
+ * of it, because an agent's Bash (and Claude Code's `!` prefix) can never
+ * answer a prompt and a hung setup looks like a slow one.
  * @param {{ stateDir: string, scriptsDir: string, projectRoot: string,
  *   replace?: boolean, env?: Record<string, string | undefined>,
  *   homedir?: string, io?: { canPrompt?: () => boolean,
  *   promptSecret?: (message: string) => string, fs?: object } }} input -
  *   Configured state dir, locations, the `--replace` flag and seams
  * @returns {Promise<{ stored: true, path: string } |
- *   { stored: false, reason: "no-tty", command: string } |
+ *   { stored: false, reason: "no-tty", message: string, command: string,
+ *     clipboardCommand: string } |
  *   { stored: false, reason: "empty" | "invalid", message: string }>} Outcome
  */
 export async function storeToken(input) {
   const { scriptsDir, projectRoot, replace = false, io = {} } = input;
   const stateDir = resolveStateDir(input.stateDir, input);
-  const existing = path.join(stateDir, TOKEN_FILE_NAME);
-  const exists = io.fs?.existsSync ?? nodeFs.existsSync;
-  if (!replace && exists(existing)) {
-    throw new LaunchError(
-      `A bot token already exists at ${existing}. Nothing was changed. ` +
-        `Re-run store-token with --replace to overwrite it.`
-    );
-  }
+  assertReplaceable(stateDir, replace, io);
   const loaded =
     io.canPrompt && io.promptSecret ? null : await loadPromptSecret();
   const canPrompt = io.canPrompt ?? (() => loaded.canPrompt());
@@ -138,7 +209,14 @@ export async function storeToken(input) {
     return {
       stored: false,
       reason: "no-tty",
+      message: NO_TTY_HINT,
       command: buildStoreTokenCommand({ scriptsDir, projectRoot, replace }),
+      clipboardCommand: buildStoreTokenCommand({
+        scriptsDir,
+        projectRoot,
+        replace,
+        fromClipboard: true,
+      }),
     };
   }
   const typed = promptSecret(
@@ -147,15 +225,7 @@ export async function storeToken(input) {
   if (!typed) {
     return { stored: false, reason: "empty", message: "Nothing entered." };
   }
-  if (!validateBotToken(typed)) {
-    return {
-      stored: false,
-      reason: "invalid",
-      message:
-        "That does not look like a Telegram bot token " +
-        "(expected <digits>:<30 or more letters, digits, _ or ->).",
-    };
-  }
+  if (!validateBotToken(typed)) return { ...INVALID };
   return { stored: true, ...writeTokenFile(stateDir, typed, io) };
 }
 

package/plugins/lisa/skills/lisa-setup-session-manager/SKILL.md

@@ -42,11 +42,14 @@ writes `$SM`, and pass `--project-root "$ROOT"` (the absolute project root) on e
 
 1. Preview: `node "$SM/session-manager.mjs" init-config --project-root "$ROOT"`. It detects
    `projects/*/.lisa.config.json` and proposes `name`, `interval`, `repos`, `capacity`, `stall` and a
-   per-project `notify.stateDir`. Show the block to the operator.
+   per-project `notify.stateDir`. Repo detection leaves out linked worktrees and keeps one checkout
+   per remote, so ticket worktrees and second clones under `projects/` are not proposed. Show the
+   block to the operator and ask whether any repo is missing or should not be routed.
 2. Write it: the same command with `--write`. It adds only non-secret fields and never overwrites an
    existing block (`reason: "exists"` means keep it).
-3. Ask the operator to replace each repo's starter `hints` with the technologies and areas that
-   identify it (e.g. `api`: `["NestJS","migrations"]`, `web`: `["Expo","screens"]`), and whether to
+3. Each repo's `hints` are a draft: its name plus one per well-known dependency (`NestJS`, `Expo`,
+   `AWS CDK`, ...). Ask the operator to correct them and add the areas that identify the repo
+   (e.g. `api`: `["NestJS","migrations"]`, `web`: `["Expo","screens"]`), and whether to
    set `sessionManager.trustedAuthorIds`. Without it, any author's Ready item reaches a
    bypass-permissions worker; say so plainly. The list holds stable tracker user ids as strings,
    never logins: the GitHub numeric user id (`gh api users/<login> --jq .id`), the Jira
@@ -61,8 +64,14 @@ The operator creates a bot with @BotFather, one per project. Then run
 - `stored: true`: done.
 - Exit 2 because a token already exists: keep it (re-running setup is safe). Only when the operator
   says the stored token is wrong or belongs to another project, re-run with `store-token --replace`.
-- `reason: "no-tty"` (an agent's Bash has no terminal): print `command` from the output and ask the
-  operator to run it in their own terminal, where it prompts with echo off. Wait for them to confirm.
+- `reason: "no-tty"` (an agent's Bash has no terminal): offer the operator both routes, and say
+  plainly that Claude Code's `!` prefix has no terminal either, so it fails the same way:
+  - **Clipboard (simplest):** they copy the token from the BotFather chat and tell you; then run
+    `clipboardCommand` from the output (`store-token --from-clipboard`). It validates the token,
+    stores it, never prints it, and clears the clipboard. On `stored: false`, say what `message`
+    reports and ask them to copy it again.
+  - **Separate terminal app:** print `command` and ask them to run it in Terminal, iTerm or similar,
+    outside the agent, where it prompts with echo off. Wait for them to confirm.
 - `empty` / `invalid`: say what was wrong and ask again.
 
 Never ask for the token in chat, never echo, log or commit it, and never put it in
@@ -97,14 +106,24 @@ If `.lisa/automations/session-manager.runbook.md` does not exist, copy
 `$SM/../references/runbook-template.md` there. Never overwrite an existing runbook: it is the
 project's. It is checked in, like every automation runbook (`automation-runbook-contract`).
 
-## Step 7: Coexistence warning
-
-Tell the operator, before starting: if this project also runs the scheduled `intake-repair` loop, it
-can re-dispatch an item a local worker is still building (it treats a claimed item with no tracker
-activity for `intake.repair.staleAfterHours` as stalled). `intake-tickets` competes for the same
-Ready items. Recommend tearing down `intake-tickets` (`/lisa:tear-down-automations intake-tickets`)
-and either raising `intake.repair.staleAfterHours` above `stall.noOutputMinutes × stall.maxAttempts`
-or tearing down `intake-repair`.
+## Step 7: Check for competing intake loops
+
+The scheduled `intake-repair` loop can re-dispatch an item a local worker is still building (it treats
+a claimed item with no tracker activity for `intake.repair.staleAfterHours` as stalled), and
+`intake-tickets` competes for the same Ready items. Find out whether either is running before you
+start the manager; do not leave the operator to check.
+
+1. Run `node "$SM/session-manager.mjs" coexistence --project-root "$ROOT"`. For each loop it reports
+   the last run recorded in this project's run log and whether that is `recent`. `live` lists the
+   loops that ran recently.
+2. A run log is evidence, not proof: also list your runtime's scheduler for those loop names (Claude
+   Code: the `/schedule` listing of claude.ai routines; Codex: automations; a `lisa-<loop>.yml`
+   workflow with a `schedule:` trigger on GitHub Actions).
+3. Report what you found, per loop, in one line each. Only for a loop that is live (a recent run, or a
+   scheduler entry): recommend tearing down `intake-tickets` (`/lisa:tear-down-automations
+   intake-tickets`) and either raising `intake.repair.staleAfterHours` above
+   `stall.noOutputMinutes × stall.maxAttempts` or tearing down `intake-repair`. When neither is live,
+   say so and move on.
 
 ## Step 8: Accept workspace trust in each worker repo
 
@@ -113,12 +132,15 @@ folder?" prompt: until someone has accepted it in a directory, `claude --bg` ref
 and `spawn` exits 2 saying so. Do this once per routed repo (or once for the root on a single-repo
 project), on every machine that runs the manager:
 
-1. List the directories workers start in. Single-repo: the project root. Multi-repo: for each key in
-   `sessionManager.repos.entries`,
-   `node "$SM/session-manager.mjs" repo-dir --repo <key> --raw --project-root "$ROOT"`.
-2. Ask the operator, in their own terminal, to run `claude` once in that directory,
-   accept the trust prompt, then exit. An agent's Bash cannot answer that prompt, so never try to
-   accept it for them.
+1. Run `node "$SM/session-manager.mjs" trust-status --project-root "$ROOT"`. It lists every
+   directory workers start in (each routed repo, or the root on a single-repo project) with whether
+   Claude Code has already recorded trust for it. `needsTrust` lists the ones that are not
+   `trusted: true`. When it is empty, this step is done: say so.
+2. For each directory in `needsTrust`, ask the operator, in a separate terminal app (not the agent's
+   Bash or Claude Code's `!` prefix), to run `claude` once in that directory, accept the trust prompt,
+   then exit. An agent's Bash cannot answer that prompt, so never try to accept it for them. Then
+   re-run `trust-status` to confirm. (`trusted: "unknown"` means Claude Code's state file could not be
+   read; treat it as needing trust.)
 3. Re-run this step whenever a repo is added to `sessionManager.repos`.
 
 ## Step 9: Start and pair
@@ -152,5 +174,6 @@ confirm the "Session manager Telegram isolation?" check is green. Fix every warn
 `node "$SM/session-manager.mjs" status --project-root "$ROOT"` should show the manager running.
 
 Report: the config block written (or kept), where the token lives (the path, never the value), the
-plugin scope result, the runbook path, which repo dirs had workspace trust accepted, the manager's
-tmux session name, and the doctor result.
+plugin scope result, the runbook path, which repo dirs were already trusted and which the operator
+accepted trust in, what the competing-loop check found, the manager's tmux session name, and the
+doctor result.

package/plugins/lisa-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.81.2",
+  "version": "4.81.4",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-agy/skills/lisa-session-manager/SKILL.md

@@ -23,9 +23,9 @@ channels (Telegram) and cross-session messaging (`SendMessage`, `crossSessionInb
 | Runtime | lisa-setup-session-manager | lisa-session-manager (manager) | `managedBy=` |
 |---|---|---|---|
 | Claude Code | supported | supported (reference). Needs `claude` ≥ 2.1.224, `tmux`, `bun` | supported |
-| Codex | config, token and runbook are supported. `start` launches a Claude Code manager, so it works when the `claude` CLI is installed | the skill ships, but `cycle` refuses to run here (no `/loop`, channels or `SendMessage`); tell the operator to run `start` | rejected with the gap message |
+| Codex | config, token (prompt or `--from-clipboard`), runbook, `trust-status` and `coexistence` are supported. `trust-status` reads Claude Code's trust record, which is the one that matters (workers are Claude Code); accepting trust needs the `claude` CLI. `coexistence` sees only run logs, so also list Codex automations. `start` launches a Claude Code manager, so it works when the `claude` CLI is installed | the skill ships, but `cycle` refuses to run here (no `/loop`, channels or `SendMessage`); tell the operator to run `start` | rejected with the gap message |
 | Cursor / Antigravity (agy) / Copilot / Devin | same as Codex | same as Codex | rejected |
-| OpenCode | config and token are supported; script resolution relies on the npm rung, so `queue` and `record-cycle` need the npm package | gap | rejected |
+| OpenCode | same setup subcommands as Codex, but script resolution relies on the npm rung: the CLI imports plugin-level scripts the skill-folder copy lacks, so every subcommand needs the npm package | gap | rejected |
 
 On any runtime other than Claude Code, `cycle` stops with: "The session manager runs on Claude Code
 only (background sessions, channels, cross-session messaging). Run `/lisa:session-manager start`

package/plugins/lisa-agy/skills/lisa-session-manager/scripts/cli-manager.mjs

@@ -1,6 +1,7 @@
 /**
- * Manager and setup subcommands of the session-manager CLI: start, stop,
- * status, repo-dir, validate, init-config and store-token.
+ * Manager subcommands of the session-manager CLI: start, stop, status,
+ * repo-dir and validate. The setup ones (init-config, store-token,
+ * trust-status, coexistence) live in cli-setup.mjs.
  *
  * `start` hosts the manager in tmux. It refuses (exit 2) unless the bot
  * token file exists with owner-only permissions in the project's own state
@@ -11,15 +12,11 @@
  * manager's tmux session: workers hold claimed work and keep running.
  * @module session-manager/cli-manager
  */
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-
 import {
   CliError,
   EXIT,
   GLOBAL_CONFIG_FILE,
   asSetupError,
-  asSetupErrorAsync,
   intFlag,
   listAgents,
   loadProject,
@@ -28,12 +25,8 @@ import {
   requireLisaRepo,
   run,
 } from "./cli-runtime.mjs";
-import { buildDefaultBlock, detectRepos, resolveRepoDir } from "./config.mjs";
-import {
-  defaultProjectSlug,
-  probeOwnSession,
-  sessionSurvives,
-} from "./isolation.mjs";
+import { resolveRepoDir } from "./config.mjs";
+import { probeOwnSession, sessionSurvives } from "./isolation.mjs";
 import {
   assertTokenPresent,
   buildForegroundCommand,
@@ -41,7 +34,6 @@ import {
   buildManagerLaunch,
   buildStopManager,
   resolveStateDir,
-  storeToken as storeTokenFile,
 } from "./launch.mjs";
 import { readLedger } from "./ledger.mjs";
 import { parseWorkerName, scrubWorkerEnv } from "./workers.mjs";
@@ -208,69 +200,6 @@ export function validate(ctx) {
   };
 }
 
-/**
- * `init-config [--slug <slug>] [--write]`: the default block for this
- * project, written to `.lisa.config.json` only with `--write` and only when
- * no block exists. Non-secret fields only; the token never goes here.
- * @param {object} ctx - CLI context
- * @returns {{ json: object }} `{written,block,...}`
- */
-export function initConfig(ctx) {
-  const { global } = loadProject(ctx.root);
-  if (global?.sessionManager) {
-    return {
-      json: { written: false, reason: "exists", block: global.sessionManager },
-    };
-  }
-  const slug =
-    ctx.values.slug ?? defaultProjectSlug(ctx.root, global?.github?.repo);
-  const block = asSetupError(() =>
-    buildDefaultBlock({
-      projectSlug: slug,
-      detectedRepos: detectRepos(ctx.root),
-    })
-  );
-  if (!ctx.values.write) return { json: { written: false, block } };
-
-  const file = path.join(ctx.root, GLOBAL_CONFIG_FILE);
-  if (!existsSync(file)) {
-    throw new CliError(
-      `${file} does not exist; set up Lisa in this project first.`,
-      EXIT.SETUP
-    );
-  }
-  const current = JSON.parse(readFileSync(file, "utf8"));
-  writeFileSync(
-    file,
-    `${JSON.stringify({ ...current, sessionManager: block }, null, 2)}\n`
-  );
-  return { json: { written: true, path: file, block } };
-}
-
-/**
- * `store-token [--replace]`: prompt for the bot token on the operator's
- * terminal and write `<stateDir>/.env`. An existing token is kept (exit 2)
- * unless `--replace` is given. With no TTY it prints the command the operator
- * must run themselves and exits 0 with `stored:false`.
- * @param {object} ctx - CLI context
- * @returns {Promise<{ json: object, exitCode: number }>} Outcome
- */
-export async function storeToken(ctx) {
-  const config = requireConfig(ctx);
-  const result = await asSetupErrorAsync(() =>
-    storeTokenFile({
-      stateDir: config.notify?.stateDir,
-      scriptsDir: ctx.scriptsDir,
-      projectRoot: ctx.root,
-      replace: ctx.values.replace === true,
-      env: ctx.env,
-      homedir: ctx.homedir,
-    })
-  );
-  const refused = result.stored === false && result.reason !== "no-tty";
-  return { json: result, exitCode: refused ? EXIT.SETUP : EXIT.OK };
-}
-
 /**
  * `status`: is the manager's tmux session up, and what does the ledger say
  * about each worker it dispatched.