@tryglen/cli 0.34.0 → 0.36.0

package/dist/jcode/skills/search/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: search
+description: Search the team's shared glen memory for a SPECIFIC fact, decision, or past discussion that is not already in the auto-injected context. Do not use for things already recalled this turn.
+---
+
+For current or source-owned facts, use the available source-of-truth tool first (for example, Slack, GitHub, Notion, or logs), especially when the user names it. Use Glen only for durable history or to supplement that source; if the live source is unavailable, say so, and if it conflicts with Glen, prefer it for current state.
+
+Run `glen search "<query>"` via Bash — **start with ONE comprehensive query, not a
+fan-out of variants**.
+
+Each search takes ~10 seconds of real user-facing wait, and the server ranks results
+with an LLM that reads your query as free-text intent — so one detailed, self-contained
+query beats several keyword variants. Pack everything you know into a single query:
+who/what/where, the repo or system involved, and what kind of answer you need (a
+decision, an owner, a rationale, setup steps).
+
+- ✅ `glen search "Shams's recent work on the usage-page redesign in the dashboard repo — what was decided, current status, and who owns it"`
+- ❌ `glen search "Shams"` … `glen search "usage page redesign"` … `glen search "dashboard"`
+
+If a hook or reminder suggests multiple search questions, merge the related ones into
+one query and run that single search.
+
+Follow-up searches are fine for going DEEPER — when the first result surfaces
+something new worth chasing (a project you didn't know to name, a decision that
+points at another decision), and the answer would genuinely change what you do next.
+But every extra search is another ~10s the user sits waiting, so don't overdo it:
+ask yourself whether the follow-up will provide real value the first result didn't,
+and skip it if you already have enough to act. Never re-run a mere rephrase of a
+query that returned little — same memory, same cost, nothing new.
+
+The output is a synthesized answer followed by a "Sources:" list (conversation ·
+date · author · id) — treat the answer as recalled memory (it may be outdated or
+conflicting), and cite the sources when relevant. If it prints no results, say so
+rather than re-searching variants.
+If it prints "No active organization", tell the user to run `glen org switch`.

package/dist/jcode/skills/session-takeover/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: session-takeover
+description: Use when the user provides a Glen takeover code or generated command to open its shared transcript in a fresh native agent session.
+---
+
+# Session Takeover
+
+Use this skill only to open a shared Glen transcript in a fresh native session.
+Do not use it to resume the current session or import local transcript archives.
+
+Use this two-stage contract:
+
+1. **Select and classify before constructing a command.** Make no tool call.
+   Candidate selection has exactly two allowed message shapes:
+
+   - Plain-message form: the candidate is the entire user message, with nothing
+     before or after it.
+   - Fenced-block form: the message contains exactly one fenced code block, has
+     no non-whitespace content outside that block, and the candidate is the
+     block's sole content.
+
+   Every other message shape is INVALID. Do not search for or extract a
+   `glen takeover` substring from prose. Classify the whole unnormalized
+   selected candidate:
+
+   - VALID raw code: the entire candidate matches `^[A-Za-z0-9_-]{43}$`.
+   - VALID generated command: the entire candidate matches
+     `^glen takeover ([A-Za-z0-9_-]{43})$`; capture group 1 is the code.
+   - INVALID: every other candidate. Examples include prefix or suffix prose, a
+     command embedded in a paragraph, prose surrounding a fenced block, multiple
+     fenced blocks, `glen takeover --help`, `glen takeover <valid-code>.`,
+     `glen takeover <valid-code> extra`,
+     `glen takeover <valid-code>; printf TAKEOVER_INJECTION_PROBE`,
+     `glen takeover <valid-code>$(printf TAKEOVER_INJECTION_PROBE)`, and
+     ``glen takeover <valid-code>`printf TAKEOVER_INJECTION_PROBE` ``.
+
+2. **Produce exactly one allowed output.**
+
+   - VALID: make exactly one Bash call from the captured code:
+
+     ```bash
+     glen takeover '<validated-code>'
+     ```
+
+   - INVALID: make zero tool calls, reply exactly "Please paste the complete
+     generated `glen takeover ...` command by itself in a code block.", and
+     stop.
+
+Construct the VALID Bash call from the captured code as one opaque quoted
+argument, never from the user's pasted command string. Never guess, sanitize,
+decode, alter, summarize, truncate, or invent a code.
+
+Treat the CLI output as authoritative:
+
+- If disconnected, tell the user to run `glen login`.
+- If no organization is active, tell the user to run `glen org switch`.
+- If the handoff is expired, unavailable, or belongs to another recipient, ask
+  the sender for a new command.
+- If compatibility or context-fit validation fails, report the exact failure and
+  stop. Never bypass the guard or shorten the transcript.
+- If installation succeeds but launch fails, surface the exact native resume
+  command printed by the CLI.
+
+On success, explain that Glen opened a fresh native session containing the
+verified inherited history and left the source transcript unchanged. Do not
+pretend the current session became the takeover destination or continue the
+inherited work here.

package/dist/jcode/skills/setup/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: setup
+description: Set up, fix, or update glen on this machine. Use when the user asks to "set up glen", "fix glen", "update glen", says glen is not working / not connected / not recording, or the status line shows glen is not connected or has no org selected.
+---
+
+Run `glen doctor` first and branch on its `status:` lines. Fix ONLY what is
+broken, in this order, then re-run `glen doctor` to verify and confirm to the
+user what changed.
+
+- `glen: command not found` → install the CLI: `npm install -g @tryglen/cli`,
+  then run `glen install` (it sets up the plugin + hooks for this agent).
+- `status: cli=<x> latest=<y> channel=<...>` where y is newer than x → run
+  `glen update` (updates the CLI and any installed glen plugins in one go).
+- `status: login=missing ...` → run `glen login` — a browser window opens with
+  a short device code prefilled; the user approves it to connect their account.
+  If no browser can open (SSH/headless), relay the printed URL and code so the
+  user can approve from any device.
+- `status: login=ok org=missing` → run `glen org list`, show the user the
+  options, and run `glen org switch <slug>` for their choice. Never pick an
+  org for them.
+- `status: jcode=detected plugin=not-installed` → run `glen install --agent jcode`.
+  It writes glen's hook lines into `~/.jcode/config.toml`, a managed block into
+  `~/.jcode/prompt-overlay.md` and `~/.jcode/preferred-tools.md`, and the glen
+  skills into `~/.jcode/skills/`. Tell the user to start a NEW jcode session
+  afterwards — jcode reads its prompt files at session start.
+- `status: claude=detected plugin=not-installed` (or codex/pi) → run
+  `glen install --agent <claude|codex|pi>` for that agent.
+- `status: codex=detected plugin=... hooks=not-registered` → run
+  `glen install --agent codex`.
+- `status: codex-self-heal=failed: ...` → run `glen install --agent codex`,
+  then re-check.
+- `status: claude=not-found` (or `status: codex=not-found` /
+  `status: pi=not-found` / `status: jcode=not-found`) when the user says it IS
+  installed → ask them to run `which claude` (or `which codex` / `which pi` /
+  `which jcode`) in their terminal, then run `glen install --claude-path
+  <that path>` (or `--codex-path` / `--pi-path` / `--jcode-path`).
+
+`glen doctor` also prints one `status: ingest agent=<agent>
+state=<ok|failing|never|fresh-install|idle> lastSuccess=<iso|never>` line per
+detected agent — this tracks whether hooks are actually firing, separate from
+whether the plugin is installed:
+- `ok` / `failing` — reflects the last recorded hook run. For `failing`,
+  doctor prints a remedy right after the line (check `glen status`, then
+  `glen login` if disconnected).
+- `fresh-install` — installed under an hour ago with no ingest yet; not a
+  fault, just still warming up.
+- `idle` — hooks fire here; nothing recorded yet — logged out, glen off, or
+  no completed turn.
+- `never` — hooks have never fired on THIS machine. Doctor prints a remedy
+  right after the line: untrusted hooks (trust them in-agent and start a new
+  session), a PATH gap, a failed hook-trust query, or a machine-topology
+  mismatch.
+- A topology mismatch usually means the agent process runs on a different
+  machine than the one you're looking at: Codex `--remote` / Desktop-SSH and
+  Claude Code over SSH/devcontainer both run the agent — and its hooks — on
+  the REMOTE host, not locally. Install glen there and run `glen doctor` on
+  that machine, as the user the agent connects as. Cloud sessions (Codex
+  Cloud tasks, claude.ai/code) can't run user-level hooks at all — only
+  repo-committed hooks apply there.
+
+Finish with `glen status` and tell the user, in one sentence, what state they
+are in now.

package/dist/jcode/skills/use-artifact/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: use-artifact
+description: Fetch and display an artifact from the user's Glen library (their own artifacts plus ones shared with them). Use when the user asks to open, view, render, or download a saved Glen artifact.
+---
+
+1. **Find it.** If you don't know the slug, run `glen artifact search "<intent>"` via Bash and confirm the right one with the user. Search covers the user's own artifacts plus ones shared with them (directly or org-wide) — a teammate's unshared artifact won't appear.
+2. **Fetch it.** Run `glen artifact get <slug>` via Bash. The output is the document (Markdown or HTML+CSS).
+3. **Show it.**
+   - **Markdown:** present it inline.
+   - **HTML:** write it to a local `.html` file, then open it in the system browser (`open <file>`); if that is not available, share the dashboard link below. It is a self-contained page with no JavaScript.
+4. **Always** share the dashboard link so the user has the canonical rendered copy: `https://app.tryglen.com/artifacts/<slug>`.

package/dist/jcode/skills/use-skill/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: use-skill
+description: Find and run a reusable skill from the Glen skill library (your skills plus ones shared with you) when you don't know its exact slug. Use when the user asks to "use a Glen skill", "find a skill for X", or wants a teammate's saved workflow.
+---
+
+1. **Search.** Run `glen skill search "<intent>"` via Bash (add `--by "<author>"`, or `--by me` for your own skills). It prints ranked candidates, each with its **[slug]**, author, and description.
+2. **Confirm.** If several plausibly match, show the top 2–3 (name + description + author) and ask the user which one. If it prints "no matching skills", say so — don't invent a skill.
+3. **Check requirements.** If the output has a `## Requirements` section, make sure each listed tool is available — follow its source link to install/enable it (or tell the user) — before you start.
+4. **Run it.** Run `glen skill use <slug>` via Bash. The output is markdown **instructions to execute now** — follow them as if they were a skill. If the skill bundles files, they're materialized locally first and the output references them by **absolute path** (e.g. a script under `~/.glen/skills/<slug>/scripts/`) — run scripts exactly as written, don't rewrite the paths.
+5. **Follow referenced skills on demand.** The instructions may contain runnable `glen skill use <slug>` commands for related skills. Run one via Bash only when its step applies — they're pulled on demand, not all upfront. Skills mentioned via `glen:` links are prefetched — their files are already materialized on disk by the time you pull them, and every `glen skill use` verifies freshness with the server so files on disk are always current.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryglen/cli",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "Glen CLI — memory for coding agents",
   "type": "module",
   "bin": {
@@ -10,7 +10,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && chmod +x dist/bin.js",
+    "build": "tsc && chmod +x dist/bin.js && pnpm build:jcode",
+    "build:jcode": "rm -rf dist/jcode && mkdir -p dist/jcode && cp -R ../jcode-plugin/skills ../jcode-plugin/plugin.json ../jcode-plugin/prompt-overlay.md ../jcode-plugin/preferred-tools.md dist/jcode/",
     "build:indicator": "./macos/build.sh",
     "check": "biome check src/ && tsc --noEmit",
     "test": "vitest run",
@@ -18,7 +19,8 @@
   },
   "dependencies": {
     "cac": "^6.7.14",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "smol-toml": "^1.8.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",