@winding-labs/glow 0.1.1 → 0.1.5

package/README.md

@@ -15,11 +15,19 @@ branch, commits and pull request. From that post in Glow you can send the sessio
 - **Only to Glow** (`https://app.meetglow.ai`). The address is fixed when you set up and can't be changed by a repo or
   an environment variable (the hook runs with an empty environment but `HOME` and `PATH`).
 - **Only from linked repos.** A session in any other repo sends nothing. You link repos to products in Glow.
-- **Only the agent's last reply**, with keys and tokens masked, plus the branch, the titles of the branch's commits and
-  a pull request link on the same repo. Never your code, files, prompts or the transcript.
-- Glow turns the reply into a short summary right away and **doesn't keep the reply itself**.
+- **Never from a repo you ignore.** `/glow:ignore` in a repo (or `npx @winding-labs/glow ignore`) and its sessions send
+  nothing from this computer, even if it's linked: the hook stops before it makes any request.
+- **Only the agent's last reply and the request it answers**, with keys and tokens masked, plus the branch, the titles
+  of the branch's commits and a pull request link on the same repo, and which of GitHub (`gh` signed in), Chrome, Docker
+  and Xcode this computer has (yes or no each, for its tags in Glow). Never your code, files or the transcript: the hook
+  reads only your latest request from the agent's own session file.
+- Glow turns the reply into a short summary right away and **doesn't keep the reply or the request**. From the request
+  it keeps only the recipe it names when it's a job you'd run again ("Pen test the API", "Optimize SEO"), so it can
+  count how often you run it and offer to run it for you. Don't want that? `npx @winding-labs/glow recipes off`.
 - This computer's key can do three things: send a report, read which repos are linked, and fetch messages you sent to
-  its sessions. It can't read anything else in your workspace. It stops working after 90 days unused.
+  its sessions. While `glow run` is on, it also picks up the sessions you start here and says how they're going (the
+  repo, the last command or file, masked; never output or code). It can't read anything else in your workspace. It
+  stops working after 90 days unused.
 
 ## Messages back
 
@@ -27,19 +35,67 @@ Only the person who paired the computer can message its sessions, and Glow asks
 first. Claude Code picks a message up while it's idle (for 25 minutes after its last reply); Codex picks it up when its
 current turn ends. Don't want that? `npx @winding-labs/glow messages off` on the computer.
 
+## Start sessions from Glow
+
+```
+npx @winding-labs/glow run ~/code
+```
+
+Only if you want it, and only while it runs: Glow's Agents tab can then start a Claude Code session on this computer,
+from a queued task ("Run on …") or a prompt you type ("New session"). It runs in your checkout of a repo that's linked
+to a product and found under the folders you give it (the current folder by default), and the Agents tab shows it live:
+the repo, what it's on, its status, how long it's been running, its last command or tool, and a Stop button. Its reply
+posts to the product's channel like any session's, except for a task someone else wrote or one filed from a capture:
+then only you see it, under the session.
+
+- **Only you** (the person who paired the computer) can start one, and Glow asks for Face ID or your passkey first.
+- **A mode you pick each time:** *Look only* (Claude Code's plan mode: it reads, changes nothing), *Edit files* (also
+  edits files in the repo) or *Auto* (Claude Code's auto mode; never for a queued task). Never a mode that skips
+  permission checks. Opus at medium effort unless you pick another model or effort.
+- **This computer decides too**, whatever Glow sends: `--max-mode read|edit|auto` is the most a session may do here
+  (*Look only* by default: `--max-mode edit` lets sessions edit files, `--max-mode auto` allows *Auto*; the app offers
+  only what the computer allows); `--repo owner/name` (repeat it) runs only those repos,
+  and `--repo owner/name=~/code/zest` picks the checkout when a repo is checked out more than once (otherwise it doesn't
+  run; worktrees don't count: it runs in the main checkout). Only in a folder you've trusted in Claude Code (opened `claude` there and said yes), since its own `.claude`
+  settings and hooks apply. A session id is run once, never again.
+- **Up to 3 at once** on a computer, one per repo, 30 a day, 3 hours each at most. Stop from Glow ends the session and
+  the commands it started. Pausing the computer in Glow stops them all; Ctrl-C (or closing the terminal) stops the
+  runner and its sessions, and everything they started.
+- `run --background` keeps it going after you close the terminal (log: `~/.glow/runner.log`); `run stop` stops it. A
+  session the runner started can't stop it or turn Glow off.
+
+## In Claude Code and Codex
+
+```
+/glow:status      what this folder sends (and why not), what's set up, which repos report or are ignored
+/glow:ignore      this repo never sends to Glow from this computer (add a folder or owner/name for another)
+/glow:unignore    let it send again (only when you type it: an agent can't run it on its own in Claude Code)
+/glow:run         start (or stop) the runner in the background, for the linked repos under the session's folder
+                  (only when you type it; Look only: --max-mode and --repo are for the terminal)
+```
+
+In Codex they're `$glow:status`, `$glow:ignore`, `$glow:unignore` and `$glow:run`. Setup adds them as a `glow` plugin, through each
+agent's own `plugin` command; each may run only its own `~/.glow/glow` command, and a session Glow started can't run
+any of them.
+
 ## Commands
 
 ```
 npx @winding-labs/glow                 set up (or add an agent you installed later)
-npx @winding-labs/glow status          what's set up and which repos report
+npx @winding-labs/glow status          what this folder sends, what's set up, which repos report
+npx @winding-labs/glow ignore [repo]   this repo (or a folder, or owner/name) never sends from this computer
+npx @winding-labs/glow unignore [repo] let it send again
 npx @winding-labs/glow off | on        stop or start sending from this computer
 npx @winding-labs/glow messages off    messages from Glow no longer reach your agents here (messages on: again)
-npx @winding-labs/glow uninstall       remove the hooks, revoke the key, delete ~/.glow
+npx @winding-labs/glow run [folders]   let Glow start Claude Code sessions in the linked repos under these folders
+    [--max-mode read|edit|auto] [--repo owner/name[=path]…] [--background]
+npx @winding-labs/glow run stop        stop the runner (and its sessions)
+npx @winding-labs/glow uninstall       remove the hooks and the plugin, revoke the key, delete ~/.glow
 ```
 
 Codex asks before it runs any new hook: open Codex and run `/hooks` once to trust Glow's.
 
-Files: `~/.glow/` (the key, owner-only), a `Stop` hook in `~/.claude/settings.json` and `~/.codex/hooks.json` (a
+Files: `~/.glow/` (owner-only: the key, the ignored repos, a copy of this package and the plugin), a `Stop` hook in `~/.claude/settings.json` and `~/.codex/hooks.json` (a
 symlinked settings file stays a link). The first time, the originals are copied to `*.before-glow`.
 
 Security: [SECURITY.md](SECURITY.md).

package/SECURITY.md

@@ -7,12 +7,48 @@ Report a vulnerability to **security@meetglow.ai**. Please don't open a public i
 - **Talk to one host:** `https://app.meetglow.ai`, fixed at setup in `~/.glow/config.json` (owner-only) and checked on
   every call. Redirects are refused. The hook runs with an empty environment except `HOME` and `PATH`, so no proxy, TLS
   or `NODE_*` setting can send it anywhere else.
-- **Send only from repos you linked** to a product in Glow: the agent's last reply (keys and tokens masked), the branch,
-  up to five commit titles on it, and a pull request link on the same repo. Never code, files, prompts or transcripts.
+- **Send only from repos you linked** to a product in Glow: the agent's last reply and the request it answers (keys and
+  tokens masked; the request only from a .jsonl under ~/.claude/projects or ~/.codex/sessions, never with `recipes
+  off`), the branch, up to five commit titles on it, and a pull request link on the same repo. Never code, files or
+  transcripts.
+  A repo you ignore here (`/glow:ignore`) sends nothing, linked or not: the hook stops before any request.
 - **Run git read-only** (the origin URL, the branch, commit titles), with no shell, hooks, fsmonitor, pager, signature
   checks or `GIT_*` variables, so a repo's `.git/config` can't make it run a program.
 - **Edit two settings files:** add one `Stop` hook to `~/.claude/settings.json` and `~/.codex/hooks.json`, keep
   everything else, back up the originals once (`*.before-glow`), and never overwrite a file that isn't valid JSON.
+- **Add one plugin** (`glow`, from `~/.glow/marketplace`) with each agent's own `claude plugin` / `codex plugin`
+  command. Each may run only its own `~/.glow/glow` command (`status`, `ignore …`, `unignore …`; `/glow:run`: exactly
+  `run --background`, `run stop` or `status`), and `/glow:unignore` and `/glow:run` run only when you type them.
+
+- **Start Claude Code, only while `glow run` runs** (you start it; nothing installs it to start on its own). It runs
+  `claude` as an argument list (no shell), in your checkout of a linked repo found under the folders you gave it, with
+  the prompt on stdin (so a prompt can't become a flag), in the mode picked in Glow: `plan` for *Look only* (it changes
+  nothing), `acceptEdits` for *Edit files*, `auto` for *Auto*, with permission prompts turned down. Never
+  `bypassPermissions` or `--dangerously-skip-permissions`; and always `--disallowedTools` for Glow's own CLI
+  (`~/.glow/glow`, `npx @winding-labs/glow`, `node …/glow.mjs`) and files (`~/.glow`, the computer's key), which no
+  allow rule (the plugin's included) can grant back. That list matches the command's text, so a session already
+  allowed arbitrary shell commands (*Auto*, or a broad allow rule in your own or the repo's settings) could spell its
+  way around it (`~/.gl?w/glow`); *Look only* and *Edit files* don't allow that, and the CLI also refuses any command
+  run from inside a session. One command per call: `glow ignore x run …` is refused, so a skill allowed to run one
+  command can't reach another. Stop, a pause in Glow, the 3-hour limit, Ctrl-C or closing the
+  terminal ends a session and everything it started: Claude Code's Bash tool and hooks start each command in a process
+  group of its own, so the runner signals every group under that Claude Code (SIGTERM, then SIGKILL after 5 s; SIGTERM
+  at once if the runner itself exits).
+- **Not take Glow's word for it.** The runner refuses, on your computer: a mode above `--max-mode` (*Look only*
+  unless you widen it: `--max-mode edit` or `auto`, also for `/glow:run`); a repo outside `--repo` when you gave it; a folder Claude Code hasn't been trusted in (`claude -p` skips
+  that question, and a repo's own `.claude` settings and hooks would apply); a repo with more than one main checkout
+  unless you pinned one (`--repo owner/name=path`; its worktrees aren't copies: it runs in the main one); a model or
+  effort not on its list (only `--model opus|sonnet|haiku|fable` and `--effort low…max` ever reach `claude`); and a
+  session id it has already been given. A command run inside one of
+  its sessions can't stop the runner, turn Glow off or change what it sends: besides the denied tools, `glow` refuses
+  when its environment has the session's marker (`GLOW_RUN_SESSION`, kept by `~/.glow/glow`), when a session's Claude
+  Code is among its parent processes, or when it runs in a session's process group.
+  Signed launch tokens (Glow signs each session, the computer checks it with a key it keeps) are a later step: today a
+  compromised Glow account or server could start a session within those limits.
+- **Report how a session goes:** running, done, failed or stopped; turns, cost, how many tool calls were turned down;
+  and its last step as one line: a command by its program and subcommand only (`$ psql …`, never its arguments), a
+  file path relative to the repo, a search pattern or a web host. Keys and tokens are masked before anything is cut,
+  the home folder is `~`, and Glow cuts and scrubs it again. Never output, file contents or the transcript.
 
 ## What the key can do in Glow
 
@@ -25,3 +61,13 @@ stops working when you remove the computer, leave the workspace, or don't use it
 
 Messages back: only the person who paired the computer can message its sessions, with a fresh second factor each time.
 `npx @winding-labs/glow messages off` turns them off on the computer.
+
+Sessions started from Glow: only the person who paired the computer can start one, with a fresh second factor, in a
+repo linked to a product and checked out on the computer, while `glow run` is on there. With the runner on, the key can
+also say which linked repos are checked out, pick up a waiting session (Glow hands the prompt over once and then
+deletes it) and report its status. Glow allows 3 at once per computer, one per repo, and 30 a day, and never more
+than the runner's `--max-mode`; a session not picked up in 10 minutes fails (closed nightly at the latest, prompt
+deleted), and pausing or removing the computer stops its sessions, as does Glow's own kill switch. A queued task never
+runs in *Auto*, and the start sheet says who wrote the task's text. When someone else wrote the task, or it came from a
+capture, the session's reply goes to you only (under the session in the Agents tab), never to a channel. Only you see
+which repos the runner found on your computer.

package/bin/glow.mjs

@@ -3,20 +3,30 @@
 // session in a repo linked to a product posts what it did to that product's channel, and Glow can message it back.
 //
 //   npx @winding-labs/glow                 set up: find the agents, pair (approve in Glow, type the code it shows), add the hooks
-//   npx @winding-labs/glow status          what's set up, and the repos that report
+//   npx @winding-labs/glow status          what's set up, what this folder sends, and the repos that report
+//   npx @winding-labs/glow ignore [repo]   never send from this repo (or a folder / owner/name) on this computer
+//   npx @winding-labs/glow unignore [repo] undo that
 //   npx @winding-labs/glow off | on        stop / start sending from this computer
 //   npx @winding-labs/glow messages off    stop messages from Glow reaching this computer's agents (on: again)
-//   npx @winding-labs/glow uninstall       remove the hooks, revoke this computer's key, delete ~/.glow
-import { execFile } from 'node:child_process';
+//   npx @winding-labs/glow recipes off     stop sending the request each reply answers (Glow learns recipes from it)
+//   npx @winding-labs/glow run [folder…]   let Glow start Claude Code sessions here, in the linked repos under these
+//                                          folders (default: this one), while it runs (--background; run stop)
+//   npx @winding-labs/glow uninstall       remove the hooks and plugins, revoke this computer's key, delete ~/.glow
+//
+// Setup copies this package to ~/.glow (bin, lib, marketplace) with two shims: ~/.glow/hook, which the agents' Stop
+// hooks run, and ~/.glow/glow, this CLI, which the /glow:status, /glow:ignore, /glow:unignore and /glow:run plugin
+// commands run.
+import { execFile, spawn } from 'node:child_process';
 import readline from 'node:readline';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { AGENTS, detect, install, installed, shimPath, shq, uninstall } from '../lib/agents.mjs';
-import { api, apiBase, apiOk, computerName, DEFAULT_API, dir, printable, readConfig, repoOf, VERSION, writeConfig } from '../lib/core.mjs';
+import { addPlugin, AGENTS, detect, install, installed, removePlugin, shimPath, shq, uninstall } from '../lib/agents.mjs';
+import { api, apiBase, apiOk, computerName, DEFAULT_API, dir, ignoredOf, printable, readConfig, REPO_RE, repoOf, VERSION, writeConfig } from '../lib/core.mjs';
+import { inRunnerSession, logPath, MODES, runnerState, SESSION_ENV, startRunner } from '../lib/runner.mjs';
 
-const LIB = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'lib');
+const PKG = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 const tty = process.stdout.isTTY;
 const c = (code, s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : s);
 const bold = (s) => c(1, s);
@@ -31,11 +41,23 @@ const fail = (s) => {
 const HELP = `Glow ${VERSION}: send what your coding agents do to your Glow channels.
 
   npx @winding-labs/glow                 set up this computer (finds Claude Code and Codex, pairs with Glow, adds hooks)
-  npx @winding-labs/glow status          what's set up and which repos report
+  npx @winding-labs/glow status          what's set up, what this folder sends, which repos report
+  npx @winding-labs/glow ignore [repo]   never send from this repo on this computer (or a folder, or owner/name)
+  npx @winding-labs/glow unignore [repo] let it send again
   npx @winding-labs/glow off | on        stop or start sending from this computer
   npx @winding-labs/glow messages off    stop messages from Glow reaching your agents here (messages on: again)
+  npx @winding-labs/glow recipes off     don't send your requests, so Glow learns no recipes from them (recipes on: again)
+  npx @winding-labs/glow run [folder…]   let Glow start Claude Code sessions here (Agents tab), in the linked repos
+                                         checked out under these folders (default: this one), while it runs
+      --background                       keep it running after this terminal closes (log: ~/.glow/runner.log)
+      --max-mode read|edit|auto          the most a session may do on its own here, whatever Glow asks (default: read,
+                                         Look only; edit lets it edit files, auto runs Claude Code's auto mode)
+      --repo owner/name[=path]           only this repo (repeat for more); =path picks its checkout
+  npx @winding-labs/glow run stop        stop it, and the sessions it runs
   npx @winding-labs/glow uninstall       remove the hooks and revoke this computer's key
 
+In Claude Code: /glow:status, /glow:ignore, /glow:unignore, /glow:run (in Codex: $glow:status, $glow:ignore, …)
+
 Options for setup:
   --claude, --codex   only these agents (default: every one found)
   --new               pair again, as a new computer
@@ -44,11 +66,19 @@ Options for setup:
 `;
 
 function parse(argv) {
-  const o = { cmd: 'install', agents: [], api: DEFAULT_API, dev: false, open: true, fresh: false, name: '', messages: null };
+  const o = { cmd: 'install', agents: [], api: DEFAULT_API, dev: false, open: true, fresh: false, name: '', messages: null, recipes: null, target: '', roots: [], background: false, runStop: false, maxMode: 'read', allow: new Map() };
+  // One command per call: `glow ignore x run …` must not become `run` (a skill allowed to run `glow ignore` can't
+  // reach any other command).
+  let named = '', asked = '';
+  const command = (c) => {
+    if (named) fail(`One command at a time (${named}, then ${c}).`);
+    named = c;
+    o.cmd = c;
+  };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
-    if (a === '--help' || a === '-h' || a === 'help') o.cmd = 'help';
-    else if (a === '--version' || a === '-v') o.cmd = 'version';
+    if (a === '--help' || a === '-h' || a === 'help') asked = 'help';
+    else if (a === '--version' || a === '-v') asked = 'version';
     else if (a === '--claude') o.agents.push('claude_code');
     else if (a === '--codex') o.agents.push('codex');
     else if (a === '--new') o.fresh = true;
@@ -57,11 +87,35 @@ function parse(argv) {
     else if (a === '--api') o.api = argv[++i] ?? '';
     else if (a === '--name') o.name = argv[++i] ?? '';
     else if (a === 'messages' && ['on', 'off'].includes(argv[i + 1])) {
-      o.cmd = 'messages';
+      command('messages');
       o.messages = argv[++i] === 'on';
-    } else if (['install', 'setup', 'status', 'off', 'on', 'uninstall'].includes(a)) o.cmd = a === 'setup' ? 'install' : a;
+    } else if (a === 'recipes' && ['on', 'off'].includes(argv[i + 1])) {
+      command('recipes');
+      o.recipes = argv[++i] === 'on';
+    } else if (a === 'ignore' || a === 'unignore') {
+      command(a);
+      if (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) o.target = argv[++i];
+    } else if (a === 'run') {
+      command('run');
+      while (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) {
+        const x = argv[++i];
+        if (x === 'stop' && !o.roots.length) o.runStop = true;
+        else o.roots.push(x);
+      }
+    } else if (a === '--background' && o.cmd === 'run') o.background = true;
+    else if (a === '--max-mode' && o.cmd === 'run') {
+      o.maxMode = argv[++i] ?? '';
+      if (!MODES.includes(o.maxMode)) fail('--max-mode is read, edit or auto.');
+    } else if (a === '--repo' && o.cmd === 'run') {
+      const [name, at] = String(argv[++i] ?? '').split(/=(.*)/s);
+      const repo = name.toLowerCase();
+      if (!REPO_RE.test(repo)) fail('--repo is owner/name, or owner/name=path to pick its checkout.');
+      o.allow.set(repo, at ? path.resolve(at.replace(/^~(?=$|\/)/, os.homedir())) : null);
+    }
+    else if (['install', 'setup', 'status', 'off', 'on', 'uninstall'].includes(a)) command(a === 'setup' ? 'install' : a);
     else fail(`Unknown option ${a}. Run npx @winding-labs/glow --help`);
   }
+  if (asked) o.cmd = asked; // help and version win, whatever else is there
   if (!apiOk(o.api, o.dev)) fail(`${printable(o.api)} isn’t Glow. The API must be https://app.meetglow.ai (or localhost with --dev).`);
   return o;
 }
@@ -74,8 +128,13 @@ async function main() {
   if (o.cmd === 'help') return console.log(HELP);
   if (o.cmd === 'version') return console.log(VERSION);
   if (o.cmd === 'status') return status();
+  // A session Glow started here can't change how Glow reaches this computer (stop the runner, turn sending off, …).
+  if (inRunnerSession()) fail('Not from a session Glow started: run it yourself, in a terminal.');
   if (o.cmd === 'off' || o.cmd === 'on') return toggle(o.cmd === 'off');
   if (o.cmd === 'messages') return messages(o.messages);
+  if (o.cmd === 'recipes') return recipes(o.recipes);
+  if (o.cmd === 'ignore' || o.cmd === 'unignore') return ignore(o.target, o.cmd === 'ignore');
+  if (o.cmd === 'run') return run(o);
   if (o.cmd === 'uninstall') return remove();
   return setup(o);
 }
@@ -118,7 +177,7 @@ async function setup(o) {
     writeConfig({ ...cfg, agents: [...new Set([...(cfg.agents ?? []), ...agents])], ...(info?.repos ? { repos: info.repos, repos_at: Date.now() } : {}), version: VERSION });
   }
 
-  copyHook();
+  copyFiles();
   for (const a of agents) {
     try {
       const file = install(a);
@@ -126,18 +185,29 @@ async function setup(o) {
     } catch (e) {
       warn(`${AGENTS[a].label}: couldn’t update ${tilde(path.join(os.homedir(), ...AGENTS[a].file))} (${e.message}). Fix it, then run this again.`);
     }
+    try {
+      addPlugin(a);
+      const x = a === 'codex' ? '$' : '/';
+      ok(`${AGENTS[a].label}: ${x}glow:status, ${x}glow:ignore, ${x}glow:unignore and ${x}glow:run added`);
+    } catch (e) {
+      warn(`${AGENTS[a].label}: couldn’t add the /glow commands (${printable(e.message, 160)}). The hook works without them.`);
+    }
   }
 
-  const repos = (info?.repos ?? []).map((r) => printable(r, 160));
+  const ignored = ignoredOf(readConfig());
+  const repos = (info?.repos ?? []).filter((r) => !ignored.includes(r)).map((r) => printable(r, 160));
   console.log('');
   console.log(repos.length ? `Repos that report to Glow: ${repos.join(', ')}` : 'No repos are linked to a product yet.');
+  if (ignored.length) console.log(`Ignored on this computer: ${ignored.join(', ')}`);
   const here = repoOf(process.cwd());
-  if (here && !repos.includes(here)) console.log(`This repo (${here}) isn’t linked. Link it to a product: ${apiBase(cfg.api)}/app/pair?repo=${encodeURIComponent(here)}`);
+  if (here && !repos.includes(here) && !ignored.includes(here)) console.log(`This repo (${here}) isn’t linked. Link it to a product: ${linkUrl(cfg, here)}`);
   console.log('');
-  if (agents.includes('claude_code')) console.log(`${bold('Claude Code')}: new sessions in those repos post to Glow when they finish a reply. Restart open sessions to pick it up.`);
+  if (agents.includes('claude_code')) console.log(`${bold('Claude Code')}: new sessions in those repos post to Glow when they finish a reply. Restart open sessions to pick it up (and the /glow commands).`);
   if (agents.includes('codex')) console.log(`${bold('Codex')}: open Codex and run ${bold('/hooks')} once to trust the Glow hook (Codex asks before running any new hook).`);
   console.log(`Messages you send a session from its post in Glow reach that agent${readConfig()?.messages === false ? ' (off here: npx @winding-labs/glow messages on)' : ' (npx @winding-labs/glow messages off to stop that)'}.`);
-  console.log(dim('\nOnly sessions in linked repos send anything, and only to Glow. Off: npx @winding-labs/glow off · Remove: npx @winding-labs/glow uninstall'));
+  if (agents.includes('claude_code')) console.log(`To start Claude Code sessions here from Glow (Agents tab): ${bold('npx @winding-labs/glow run')} in your code folder.`);
+  console.log(dim('\nOnly sessions in linked repos send anything, and only to Glow. A repo you never want sent: /glow:ignore in it.'));
+  console.log(dim('Off: npx @winding-labs/glow off · Remove: npx @winding-labs/glow uninstall'));
 }
 
 /** The device flow: show a code, open Glow to approve it, then type the confirmation Glow shows to get the key. */
@@ -213,22 +283,38 @@ async function pair(o, agents) {
 }
 
 
-/** ~/.glow/{core,hook}.mjs and the shim the agents run, which uses the Node that ran this (or the one on PATH). */
-function copyHook() {
-  fs.mkdirSync(dir(), { recursive: true, mode: 0o700 });
-  fs.chmodSync(dir(), 0o700);
-  for (const f of ['core.mjs', 'hook.mjs']) fs.copyFileSync(path.join(LIB, f), path.join(dir(), f));
-  for (const f of ['core.mjs', 'hook.mjs']) fs.chmodSync(path.join(dir(), f), 0o600);
-  // An empty environment but HOME and PATH: no NODE_OPTIONS, proxy, TLS or GIT_* variable from the agent's settings
-  // can change where the hook sends or what it runs. (GLOW_POLL_MS only speeds up the tests.)
-  const shim = `#!/bin/sh
-# Glow agent hook (npx @winding-labs/glow ${VERSION}). Sends coding agent replies in linked repos to Glow.
+/**
+ * This package's code to ~/.glow (bin, lib, marketplace) and the two shims: ~/.glow/hook (the agents' Stop hooks) and
+ * ~/.glow/glow (this CLI, for the /glow commands). Both run the Node that ran this (or the one on PATH) with an empty
+ * environment but HOME and PATH: no NODE_OPTIONS, proxy, TLS or GIT_* variable from the agent's settings can change
+ * where they send or what they run. (GLOW_POLL_MS only speeds up the tests.)
+ */
+function copyFiles() {
+  const home = dir();
+  fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+  fs.chmodSync(home, 0o700);
+  // Copied over in place (never removed first), so a hook that starts meanwhile still finds its files.
+  if (fs.realpathSync(PKG) !== fs.realpathSync(home)) {
+    for (const d of ['bin', 'lib', 'marketplace']) fs.cpSync(path.join(PKG, d), path.join(home, d), { recursive: true, force: true });
+  }
+  // 0.1.0–0.1.1 kept the hook at ~/.glow/hook.mjs and ~/.glow/core.mjs.
+  for (const f of ['core.mjs', 'hook.mjs']) fs.rmSync(path.join(home, f), { force: true });
+  const shim = (what, script, extra = '') => `#!/bin/sh
+# ${what} (npx @winding-labs/glow ${VERSION})
 NODE=${shq(process.execPath)}
-[ -x "$NODE" ] || NODE=$(command -v node) || exit 0
-exec env -i HOME="$HOME" PATH="$PATH" \${GLOW_POLL_MS:+GLOW_POLL_MS="$GLOW_POLL_MS"} "$NODE" ${shq(path.join(dir(), 'hook.mjs'))} "$@"
+[ -x "$NODE" ] || NODE=$(command -v node) || { echo "Glow needs Node 18 or newer: https://nodejs.org" >&2; exit 0; }
+exec env -i HOME="$HOME" PATH="$PATH" ${extra}"$NODE" ${shq(path.join(home, script))} "$@"
 `;
-  fs.writeFileSync(shimPath(), shim, { mode: 0o700 });
-  fs.chmodSync(shimPath(), 0o700);
+  writeShim(shimPath(), shim('Glow agent hook: sends coding agent replies in linked repos to Glow', path.join('lib', 'hook.mjs'), '${GLOW_POLL_MS:+GLOW_POLL_MS="$GLOW_POLL_MS"} '));
+  // The session marker goes through (env -i drops the rest): glow refuses to change anything from a runner's session.
+  writeShim(cliPath(), shim('Glow: status, ignore, unignore, run and the rest of npx @winding-labs/glow, for the /glow commands', path.join('bin', 'glow.mjs'), `\${${SESSION_ENV}:+${SESSION_ENV}="$${SESSION_ENV}"} `));
+}
+
+const cliPath = () => path.join(dir(), 'glow');
+
+function writeShim(file, text) {
+  fs.writeFileSync(file, text, { mode: 0o700 });
+  fs.chmodSync(file, 0o700);
 }
 
 function openUrl(url) {
@@ -241,20 +327,80 @@ function openUrl(url) {
 }
 
 const tilde = (p) => (p.startsWith(os.homedir()) ? `~${p.slice(os.homedir().length)}` : p);
+const linkUrl = (cfg, repo) => `${apiBase(cfg.api)}/app/pair?repo=${encodeURIComponent(repo)}`;
 
 // ---------- status, off/on, uninstall ----------
 
+/** What's set up here, what this folder sends (and why not), and the repos that report or are ignored. */
 async function status() {
   const cfg = readConfig();
-  if (!cfg) return console.log('Not set up. Run npx @winding-labs/glow');
+  if (!cfg) return console.log('Glow isn’t set up on this computer, so nothing is sent from it. Set it up: npx @winding-labs/glow');
   const res = await api(cfg, 'GET', '/api/v1/agent/config', undefined, 10_000);
-  console.log(`${bold('Glow')} ${dim(VERSION)} · ${apiBase(cfg.api)}`);
-  console.log(`Computer: ${printable(cfg.computer?.name) || '?'} · workspace: ${printable(res.json?.workspace?.name ?? cfg.workspace?.name) || '?'}`);
-  console.log(`Key: ${res.status === 200 ? 'works' : res.status === 401 ? 'revoked (run setup again)' : res.status === 403 ? 'paused in Glow' : `unreachable (${res.status})`}${cfg.off ? ' · sending is OFF here' : ''}`);
-  console.log(`Messages from Glow: ${cfg.messages === false ? 'off' : 'on'}`);
-  for (const a of Object.keys(AGENTS)) console.log(`${AGENTS[a].label}: ${installed(a) ? 'hooked' : 'not hooked'}`);
-  const repos = (res.json?.repos ?? cfg.repos ?? []).map((r) => printable(r, 160));
-  console.log(`Repos that report: ${repos.length ? repos.join(', ') : 'none yet'}`);
+  const ok200 = res.status === 200 && Array.isArray(res.json?.repos);
+  try {
+    if (ok200) writeConfig({ ...(readConfig() ?? cfg), repos: res.json.repos.filter((r) => typeof r === 'string').slice(0, 200), repos_at: Date.now() });
+  } catch {
+    // a sandbox that can't write ~/.glow: the hook refreshes the list itself
+  }
+  const linkedRepos = (ok200 ? res.json.repos : Array.isArray(cfg.repos) ? cfg.repos : []).filter((r) => typeof r === 'string').map((r) => printable(r, 160));
+  const ignored = ignoredOf(cfg);
+  const key = res.status === 200 ? 'key works' : res.status === 401 ? 'key revoked: run npx @winding-labs/glow to pair again' : res.status === 403 ? 'paused in Glow (Connections › Coding agents)' : `Glow unreachable (${res.status || 'offline'})`;
+
+  const here = repoOf(process.cwd());
+  let folder;
+  if (!here) folder = 'not a GitHub repo: sends nothing';
+  else if (ignored.includes(here)) folder = `${here}: ignored here, sends nothing (undo: /glow:unignore)`;
+  else if (!linkedRepos.includes(here)) folder = `${here}: not linked to a product, sends nothing. Link it: ${linkUrl(cfg, here)}`;
+  else if (cfg.off) folder = `${here}: linked, but sending is off on this computer`;
+  else if (res.status === 401 || res.status === 403) folder = `${here}: linked, but this computer can’t send (see Computer)`;
+  else folder = `${here}: reports to Glow`;
+
+  const agents = Object.keys(AGENTS).map((a) => `${AGENTS[a].label} ${installed(a) ? 'hooked' : 'not hooked'}`).join(' · ');
+  const reporting = linkedRepos.filter((r) => !ignored.includes(r));
+  const rs = runnerState();
+  const rows = [
+    ['This folder', folder],
+    ['Computer', `${printable(cfg.computer?.name) || '?'} · workspace ${printable(res.json?.workspace?.name ?? cfg.workspace?.name) || '?'} · ${key}`],
+    ['Sending', `${cfg.off ? 'off (npx @winding-labs/glow on)' : 'on'} · messages from Glow ${cfg.messages === false ? 'off' : 'on'} · requests for recipes ${cfg.recipes === false ? 'off' : 'on'}`],
+    ['Agents', agents],
+    ['Reporting', reporting.length ? reporting.join(', ') : 'no repo yet'],
+    ['Ignored here', ignored.length ? ignored.join(', ') : 'none'],
+    ['Runner', rs
+      ? `on since ${new Date(rs.started_at).toLocaleString()} (pid ${rs.pid}) in ${(rs.roots ?? []).map((r) => printable(r, 160)).join(', ')}: Glow can start Claude Code sessions here · stop: npx @winding-labs/glow run stop`
+      : 'off: Glow can’t start sessions here (to let it: npx @winding-labs/glow run, in your code folder)'],
+  ];
+  console.log(`${bold('Glow')} ${dim(VERSION)} · ${apiBase(cfg.api)}\n`);
+  for (const [k, v] of rows) console.log(`${dim(k.padEnd(14))}${v}`);
+}
+
+/** The repo a folder is in (default: this one), or an owner/name typed out (or its GitHub URL). */
+function repoArg(target) {
+  if (!target) return { repo: repoOf(process.cwd()), where: 'This folder' };
+  const p = path.resolve(target.replace(/^~(?=$|\/)/, os.homedir()));
+  if (fs.existsSync(p)) return { repo: repoOf(p), where: tilde(p) };
+  const r = target.trim().toLowerCase().replace(/^(?:https:\/\/)?github\.com\//, '').replace(/(?:\.git)?\/?$/, '');
+  return { repo: REPO_RE.test(r) ? r : null, where: printable(target, 160) };
+}
+
+/** Ignore (or stop ignoring) a repo on this computer. Local only: the hook checks it before sending anything. */
+function ignore(target, on) {
+  const { repo, where } = repoArg(target);
+  if (!repo) return console.log(`${where} isn’t a GitHub repo, so Glow sends nothing from it.`);
+  const cfg = readConfig();
+  if (!cfg) return console.log(`Glow isn’t set up on this computer, so nothing is sent from ${repo} (or any repo).`);
+  const list = ignoredOf(cfg);
+  const linked = Array.isArray(cfg.repos) && cfg.repos.includes(repo);
+  if (on) {
+    if (list.includes(repo)) return ok(`${repo} is already ignored here: nothing is sent from it.`);
+    writeConfig({ ...cfg, ignored: [...list, repo].sort() });
+    ok(`Ignored ${repo}: Claude Code and Codex sessions in it send nothing to Glow from this computer.`);
+    console.log(dim(`${linked ? 'It’s linked to a product in Glow; other computers still report from it. ' : ''}Undo: /glow:unignore ($glow:unignore in Codex, or npx @winding-labs/glow unignore${target ? ` ${repo}` : ''})`));
+    return;
+  }
+  if (!list.includes(repo)) return console.log(`${repo} isn’t ignored here. ${linked ? 'Sessions in it report to Glow.' : 'It isn’t linked to a product, so it sends nothing.'}`);
+  writeConfig({ ...cfg, ignored: list.filter((r) => r !== repo) });
+  ok(`${repo} isn’t ignored anymore.`);
+  console.log(linked ? 'Sessions in it report to Glow again.' : `It isn’t linked to a product, so it still sends nothing. Link it: ${linkUrl(cfg, repo)}`);
 }
 
 function toggle(off) {
@@ -271,8 +417,25 @@ function messages(on) {
   ok(on ? 'Messages on: what you send a session from Glow reaches its agent' : 'Messages off: Glow holds nothing for this computer’s agents (npx @winding-labs/glow messages on to undo)');
 }
 
+function recipes(on) {
+  const cfg = readConfig();
+  if (!cfg) fail('Not set up. Run npx @winding-labs/glow');
+  writeConfig({ ...cfg, recipes: on });
+  ok(on ? 'Recipes on: each report carries the request it answers, and Glow learns the recipes you run' : 'Recipes off: reports carry the agent’s reply only (npx @winding-labs/glow recipes on to undo)');
+}
+
 async function remove() {
   const cfg = readConfig();
+  const rs = runnerState();
+  if (rs) {
+    try {
+      process.kill(rs.pid, 'SIGTERM');
+      for (let n = 0; n < 100 && runnerState(); n++) await sleep(100);
+      ok('Runner stopped');
+    } catch {
+      warn(`Couldn’t stop the runner (pid ${rs.pid}). Stop it yourself: kill ${rs.pid}`);
+    }
+  }
   for (const a of Object.keys(AGENTS)) {
     try {
       const file = uninstall(a);
@@ -280,6 +443,7 @@ async function remove() {
     } catch (e) {
       warn(`${AGENTS[a].label}: couldn’t update its settings (${e.message}); remove the Glow hook by hand.`);
     }
+    if (detect().includes(a) && removePlugin(a)) ok(`${AGENTS[a].label}: /glow commands removed`);
   }
   if (cfg) {
     const res = await api(cfg, 'DELETE', '/api/v1/agent/computer', undefined, 10_000);
@@ -290,4 +454,81 @@ async function remove() {
   ok(`Deleted ${tilde(dir())}`);
 }
 
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ---------- run: sessions Glow starts here ----------
+
+/**
+ * `glow run [folder…]`: Glow can start Claude Code sessions here while this runs (lib/runner.mjs). In the foreground
+ * (Ctrl-C stops it and its sessions), or with --background as its own process logging to ~/.glow/runner.log. One per
+ * computer. `glow run stop` ends it.
+ */
+async function run(o) {
+  const cfg = readConfig();
+  if (!cfg) fail('Glow isn’t set up on this computer. Set it up first: npx @winding-labs/glow');
+  const on = runnerState();
+  if (o.runStop) {
+    if (!on) return console.log('The runner isn’t on here, so Glow can’t start sessions on this computer.');
+    process.kill(on.pid, 'SIGTERM');
+    for (let n = 0; n < 120 && runnerState(); n++) await sleep(100);
+    return runnerState() ? warn(`Asked the runner (pid ${on.pid}) to stop; it’s still finishing.`) : ok('Runner stopped: Glow can’t start sessions here until you run it again.');
+  }
+  if (cfg.off) fail('Sending is off on this computer. Turn it on first: npx @winding-labs/glow on');
+  if (on) fail(`The runner is already on here (pid ${on.pid}, in ${(on.roots ?? []).map((r) => printable(r, 160)).join(', ')}). Stop it first: npx @winding-labs/glow run stop`);
+  const roots = (o.roots.length ? o.roots : [process.cwd()]).map((r) => path.resolve(r.replace(/^~(?=$|\/)/, os.homedir())));
+  for (const r of roots) if (!fs.existsSync(r) || !fs.statSync(r).isDirectory()) fail(`${printable(r, 160)} isn’t a folder.`);
+  // From 0.1.4 the hook leaves the sessions the runner starts to the runner (one report each): bring an older copy up.
+  let hookVersion;
+  try {
+    hookVersion = /VERSION = '([\d.]+)'/.exec(fs.readFileSync(path.join(dir(), 'lib', 'core.mjs'), 'utf8'))?.[1];
+  } catch {
+    hookVersion = undefined;
+  }
+  const older = (a, b) => {
+    const [x, y] = [a, b].map((v) => v.split('.').map(Number));
+    for (let i = 0; i < 3; i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) < (y[i] ?? 0);
+    return false;
+  };
+  let shimNow = '';
+  try {
+    shimNow = fs.readFileSync(cliPath(), 'utf8');
+  } catch {
+    shimNow = '';
+  }
+  // Older, or a ~/.glow/glow that drops the session marker (an early 0.1.4): bring it up.
+  if (hookVersion && /^\d+\.\d+\.\d+$/.test(VERSION) && (older(hookVersion, VERSION) || (shimNow && !shimNow.includes(SESSION_ENV)))) {
+    copyFiles();
+    console.log(dim(older(hookVersion, VERSION) ? `Updated Glow’s hook on this computer from ${hookVersion} to ${VERSION}.` : 'Updated Glow’s files on this computer.'));
+  }
+  if (o.background) {
+    const log = logPath();
+    fs.mkdirSync(dir(), { recursive: true, mode: 0o700 });
+    try {
+      if (fs.statSync(log).size > 1_000_000) fs.rmSync(log, { force: true });
+    } catch {
+      // no log yet
+    }
+    const fd = fs.openSync(log, 'a', 0o600);
+    fs.chmodSync(log, 0o600);
+    const flags = ['--max-mode', o.maxMode, ...[...o.allow].flatMap(([r, at]) => ['--repo', at ? `${r}=${at}` : r])];
+    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), 'run', ...roots, ...flags], { detached: true, stdio: ['ignore', fd, fd], env: process.env, cwd: roots[0] });
+    child.unref();
+    for (let n = 0; n < 80 && runnerState()?.pid !== child.pid; n++) await sleep(100);
+    if (runnerState()?.pid !== child.pid) fail(`The runner didn’t start. See ${tilde(log)}`);
+    ok(`Runner on in the background (pid ${child.pid}): Glow can start Claude Code sessions in the linked repos under ${roots.map(tilde).join(', ')}.`);
+    console.log(dim(`Log: ${tilde(log)} · Stop: npx @winding-labs/glow run stop`));
+    return;
+  }
+  for (const [r, at] of o.allow) if (at && (!fs.existsSync(at) || !fs.statSync(at).isDirectory())) fail(`${printable(at, 160)} (for ${r}) isn’t a folder.`);
+  const r = startRunner({ roots, say: (line) => console.log(line), maxMode: o.maxMode, allow: o.allow });
+  const quit = () => {
+    console.log(dim('\nStopping the runner and its sessions…'));
+    void r.stop();
+  };
+  process.once('SIGINT', quit);
+  process.once('SIGTERM', quit);
+  process.once('SIGHUP', quit); // the terminal closed
+  process.exit(await r.done);
+}
+
 main().catch((e) => fail(e?.message ?? String(e)));