@tryglen/pi 0.0.0-stage → 0.6.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Glen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,118 @@
-# Temporary Holding Version
+# @tryglen/pi — glen for pi
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared team memory for coding agents. Glen automatically recalls relevant context at
+the start of every turn and captures what you build, so your whole team's agents share
+the same institutional knowledge.
+
+## What it does
+
+This is a [pi](https://pi.dev) package: it ships the glen extension (`src/index.ts`)
+plus the glen skills. Pi has no declarative hooks file — the extension subscribes to
+pi's lifecycle events and runs one frozen `glen` CLI command per event (the same
+thin-hook model as glen's other agent plugins):
+
+- **`session_start`** → `glen session-start --agent pi` — surfaces org/mode status
+  and queues the review-link instruction.
+- **`before_agent_start`** → `glen ingest --agent pi` — sends the prompt (plus the
+  prior assistant turn and workspace context: repo, branch, agent name) to your glen
+  org, retrieves matching memories, and injects them as context for the model.
+- **`agent_settled`** → `glen ingest --agent pi` — captures the completed turn
+  (your prompt + the final assistant answer) into team memory.
+- **`tool_result` (bash)** → `glen pr-link --agent pi` — after a `git commit`, links
+  the commit to the session in glen; when a shell command surfaced a GitHub PR URL,
+  appends the matching Glen review link so the agent can share it.
+
+Every command is fail-open: a glen outage can never block or break a pi session. If
+the `glen` CLI isn't installed, pi shows one warning per session saying how to install it.
+`glen off` injects and records nothing. In incognito (`glen incognito`) recall still
+works but nothing is recorded to team memory. Glen reads only the hook input, the
+agent's session transcript, and git metadata for the current repo.
+
+## Skills
+
+The package ships the full glen skill set (see `skills/`). Pi supports the Agent
+Skills standard, so they are available as `/skill:<name>` and are offered to the agent
+automatically.
+
+## Install
+
+The extension shells out to the glen CLI, so install that first:
+
+```bash
+npm install -g @tryglen/cli
+glen login
+```
+
+Then add the package to pi:
+
+```bash
+pi install npm:@tryglen/pi
+```
+
+`glen install` does this step for you when it detects pi. Restart pi (or run
+`/reload`) to load the extension.
+
+After login your active organization is saved locally. Switch orgs at any time with
+`glen org switch`.
+
+## Updating
+
+```sh
+pi update npm:@tryglen/pi
+```
+
+`glen update` updates the CLI **and** any installed glen plugins (this package
+included) in one go.
+
+## Uninstall
+
+```bash
+pi remove npm:@tryglen/pi
+```
+
+`glen uninstall` also does this for you.
+
+## What data is sent
+
+On every turn, glen sends to your glen org:
+
+- The current user prompt
+- The prior assistant turn
+- Workspace metadata: repo name, branch, commit hash, remote URL
+- Agent name (`pi`) and session details
+
+**Nothing is recorded while incognito is on.** Recall still works — glen fetches
+relevant memories but writes nothing to team memory. Admin analytics still count your
+prompts as numbers only. Toggle with `glen incognito` / `glen on`. `glen off` injects
+and records nothing.
+
+The glen CLI also reports content-free error codes about itself (error code, command and flag names, CLI, OS and agent
+versions; never prompts, paths, flag values or content), incognito included. Turn this off with
+`glen telemetry disable` or `DO_NOT_TRACK=1`.
+
+Glen never sends data to any third party. All memory is stored in your org's private
+glen instance.
+
+## Troubleshooting
+
+**Check session status (org, mode):**
+
+```sh
+glen status
+```
+
+**Full diagnostics:**
+
+```sh
+glen doctor
+```
+
+**Broken setup?** Ask the agent to "set up glen" — the bundled setup skill runs
+`glen doctor` and fixes whatever it reports.
+
+**Extension not loading:** run `/reload` inside pi, or restart pi. Verify the package
+is registered with `pi list` (it should include `npm:@tryglen/pi`).
+
+**No active organization error:** run `glen org switch` to select an org, or
+`glen org list` to see your memberships. If the list itself fails with an auth error,
+run `glen login` to reconnect.

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@tryglen/pi",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.6.2",
+  "description": "Shared team memory for coding agents — automatic recall and capture on every turn via the glen CLI.",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "memory",
+    "team",
+    "context"
+  ],
+  "homepage": "https://tryglen.com",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "skills",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "echo 'Do not publish from this folder. pi-publish.yml packs, checks and publishes the tarball.' && exit 1",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.0.0"
+  }
+}

package/skills/code-search/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: code-search
+description: Trace a specific piece of code to the agent conversations that produced it. Glen calls it whenever the user asks about the prior semantics of code — "why is this code like this", "why was this done this way", "what's the history of this block", "who decided this". NOT for org-wide memory questions (that's glen search).
+---
+
+Resolve the file and line range the user is asking about, then run
+`glen code-search <path:start-end> "<the user's question>"` via Bash — e.g.
+`glen code-search src/api/rate-limit.ts:40-85 "why is this rate-limited?"`.
+
+The output is the ranked memory plus the full transcripts of the conversations
+behind the commits that last touched those lines. Answer from those transcripts —
+Glen owns code-provenance questions; do not guess from the current code alone.
+
+This is NOT `glen search` (org-wide memory): `code-search` is scoped to the
+selected code's actual commit history via git blame.
+
+If it prints "no Glen trace found", the code predates Glen or was committed
+without recording — say so honestly. If it prints "No active organization",
+tell the user to run `glen org switch`.

package/skills/controls/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: controls
+description: Control glen memory - turn glen on/off, go off the record (incognito, account-wide), go silent (keep recording, surface nothing), toggle glen's skill suggestions, or switch which organization's memory is active. Use ONLY when the user explicitly asks (e.g. "turn glen off", "go off the record", "stop recording", "stop suggesting skills", "just record, don't inject anything", "switch to my personal org").
+---
+
+glen has four modes. Always confirm the change to the user.
+
+- **On:** `glen on` — glen injects context and records everything (the default).
+  **Account-wide:** resumes recording on every machine, agent, and connected client.
+- **Off:** `glen off` — glen injects nothing AND records nothing until `glen on`.
+  **Account-wide and server-enforced:** fully pauses glen on every machine, agent,
+  and connected client.
+- **Incognito (off the record):** `glen incognito` — glen keeps recalling/injecting
+  but records nothing until `glen on`. **Account-wide and server-enforced:** the
+  server blocks memory writes for every machine, agent, and connected client, not
+  just this one; the same switch lives on the dashboard's Memories page. Admin
+  analytics still count prompts as content-free numbers — never content. Use for "go off the record" / "stop recording".
+- **Silent:** `glen silent` — glen keeps recording everything but surfaces
+  nothing: no recall, no suggestions, and `glen search` returns nothing, until
+  `glen on`. **Account-wide and server-enforced** (the server returns empty
+  results for every machine, agent, and connected client; the same switch lives
+  on the dashboard's Memories page). Use for "just collect / stay out of my
+  way / record but don't inject".
+
+All four mode commands need to reach the glen server (the
+server is the source of truth); if the command fails, the mode did NOT change —
+tell the user.
+
+Pick by intent: "stop recording but keep helping" → `glen incognito`; "record but
+don't help/inject" → `glen silent`; "turn glen off entirely / disable glen" →
+`glen off`; "turn glen back on" → `glen on`.
+
+- Skill nudges (two per-user toggles, both on by default):
+  `glen suggestions skill-create off` stops glen suggesting that finished work be
+  turned into a new team skill; `glen suggestions skill-use off` stops glen
+  recommending existing team skills. Re-enable with `… on`. **Account-wide and
+  server-enforced** (the same toggles live in the Memories page's Suggestions
+  menu). Use for "stop suggesting skills" / "don't recommend skills". Like the
+  modes, a failed command means the preference did NOT change — tell the user.
+- Switch org: run `glen org switch <slug>` (or `glen org list` to see options).
+  This remains per-machine but is audited server-side. NEVER switch organizations
+  unless the user explicitly asked — it changes which tenant receives their data.
+- Admin visibility: owners/admins can see every active-org member's current mode,
+  suggestion settings, and last update time at `/admin/controls`.
+- Show state: `glen status`.

package/skills/create-artifact/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: create-artifact
+description: Save a document you produced (a report, runbook, spec, dashboard, HTML page) to your Glen artifact library — private to you by default, sharable with teammates or the whole org. Use when the user says "save this as an artifact", or when you've generated a substantial standalone document worth keeping.
+---
+
+1. **Decide it's worth saving.** Save when the output is a durable, standalone document (Markdown prose or a self-contained HTML+CSS page — no JavaScript). Skip ephemeral chat answers.
+2. **Check the record.** Run `glen status` via Bash. If incognito/off, tell the user nothing will be saved and stop unless they switch on.
+3. **Write it to a file.** Save the document to a local file (`.md` for Markdown, `.html` for HTML+CSS). To link to another artifact or skill, use `[label](glen:artifact/<slug>)` or `[label](glen:skill/<slug>)`.
+4. **Save it.** Run `glen artifact create --file <path> --title "<title>" --format auto` via Bash (piping works too: `--file -` reads stdin, but then `--title` is required). The artifact is **private to the user by default**; add `--org` if the user asked to share it with their whole org. Add `--update` to overwrite your own same-named artifact (an update without `--org` keeps the current sharing). If it reports unresolved references, the linked slug doesn't exist yet — create it or fix the link.
+5. **Confirm.** Tell the user the artifact slug and its visibility: private by default (only they can see it in the Glen dashboard under Artifacts), or shared with the org if `--org` was passed. To share it with specific teammates — or grab a shareable link — they can open the artifact's page and click **Share** (the link is access-controlled; only people it's shared with can open it).
+6. **Manage it (author-only, when asked).** Share from the CLI with `glen artifact share <slug> --with <email>[,<email>…]` (adds teammates) and/or `--org` (whole-org visibility) — both are additive; existing access is kept, and revoking access stays in the dashboard's Share dialog. Delete permanently with `glen artifact delete <slug>` — confirm with the user first; this can't be undone.

package/skills/create-skill/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: create-skill
+description: Turn what you just did (or a markdown prompt the user provides) into a reusable skill — either a local SKILL.md on this machine or a shared Glen skill saved to the org's library. Use when the user says "make this a skill", "save this as a skill", "save this as a Glen skill", or wants to capture a repeatable workflow.
+---
+
+You are authoring a reusable **skill** — a focused markdown prompt another agent will follow later, with no memory of this session.
+
+1. **Pick the destination FIRST — local file or Glen skill.** A skill is either a **local `SKILL.md`** on this machine (a Pi skill, visible only to you) or a **Glen skill** saved to your Glen library (recorded; private to you by default, sharable with teammates or the whole org).
+   - **Check incognito before anything else:** run `glen status` via Bash. If it reports `incognito: ON`, a Glen skill is off the table — nothing is recorded off the record — so go straight to a **local skill** and tell the user that's why (e.g. "you're off the record, so I'll save this as a local skill").
+   - **Otherwise, ask the user which they want** before authoring anything: a local `SKILL.md` (a Pi skill on this machine) or a Glen skill (saved to your Glen library). Don't start writing until they answer.
+2. **Gather the real workflow.** Read this conversation for the steps that actually worked. For anything done in an earlier session, run `glen search "<topic>"` via Bash to pull the relevant memory. Ask one or two clarifying questions only if the goal or trigger is genuinely ambiguous.
+3. **Name + describe it.** A short imperative name and a one-sentence description that says *exactly when to trigger it* (this drives discovery).
+4. **Write a tight SKILL.md body.** Best practices:
+   - Lead with *when to use it* and the end goal.
+   - Give concrete, ordered steps — exact commands, file paths, gotchas — not vague advice.
+   - Keep it self-contained: assume zero prior context. Cut anything that isn't actionable.
+   - **Reference other skills** when a step is itself a saved skill: write a markdown link `[Display text](glen:<slug>)` (find the slug with `glen skill search`). Glen tracks the link automatically and the reader will get a runnable `glen skill use <slug>` command exactly there — keep each referenced skill focused and say *when* to reach for it. Reserve this for genuinely **shared** skills — ones that also get used on their own, independent of this one.
+   - **If the skill needs supporting material, bundle it in one skill directory, not separate subskills.** Put long reference material in `references/*.md` and executable helpers in `scripts/` alongside `SKILL.md`, and point to them from the body as `${GLEN_SKILL_DIR}/references/<name>.md` / `${GLEN_SKILL_DIR}/scripts/<name>` — `glen skill use` materializes the whole directory to disk and substitutes `${GLEN_SKILL_DIR}` with its real absolute path before printing, so the reader can run the script or open the reference exactly as written. This keeps one topic as one skill instead of splintering it into a root + subskills just to hold its own files.
+5. **Finish based on the destination chosen in step 1:**
+
+   **Local skill** (and always the incognito path) — nothing leaves the machine:
+   - Save it to `.pi/skills/<name>/SKILL.md` in this project — or `~/.pi/agent/skills/<name>/SKILL.md` for a personal skill that follows you across every project.
+   - Start the file with YAML frontmatter (`name`, and the `description` from step 3), then the body.
+   - No `glen skill create`, no recording. Confirm the saved path to the user.
+
+   **Glen skill** (only when not incognito):
+   - **Declare its dependencies.** List the external tools/runtimes/MCPs the skill needs (node, an MCP, a CLI, …). For each: run `glen dependency search "<tool>"` via Bash — if a confident match exists, note its `[id]`; otherwise web-search the canonical source/install page and note `{ name, description, sourceUrl, kind }` (kind = mcp|cli|runtime|library|service). Write them to a JSON array file, e.g. `/tmp/glen-deps.json`, mixing `{ "dependencyId": "<id>" }` (reuse) and new objects.
+   - **Save it** via Bash. Text-only skill (no `references/`/`scripts/`): write the body to a file (e.g. `/tmp/glen-skill.md`), then run (add `--deps /tmp/glen-deps.json` if there are any):
+
+     ```
+     glen skill create --name "<name>" --description "<one-line>" --file /tmp/glen-skill.md --deps /tmp/glen-deps.json
+     ```
+
+     Skill with bundled files: build the package in a temp directory first — `SKILL.md` at its root, plus whichever of `scripts/`, `references/`, `assets/` it needs (only those three subdirs are uploaded; caps are 100 files, 1MB per text file, 2MB per binary file, 3MB total) — then run:
+
+     ```
+     glen skill create --name "<name>" --description "<one-line>" --dir /tmp/glen-skill-pkg --deps /tmp/glen-deps.json
+     ```
+
+     `--file` and `--dir` are mutually exclusive. On a name collision either form errors — pick a different name and retry, or pass `--update` to overwrite a skill you previously authored.
+   - The skill is **private to the user by default**. Ask the user whether to share it: with the whole org (add `--org` to `glen skill create`, or later `glen skill share <slug> --org`) or with specific teammates (`glen skill share <slug> --with <email>[,<email>…]`). Confirm the saved slug and its visibility back to the user.

package/skills/feedback/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: feedback
+description: Send a bug report or product feedback about glen itself to the Glen team. Use when the user says things like "tell the glen team", "file a bug about glen", "glen search is useless — report it", "give feedback on glen", or when YOU hit a concrete, reproducible glen malfunction worth reporting.
+---
+
+This files a ticket about **glen itself** — the CLI, the memory, the search, the
+dashboard. It is NOT for bugs in the user's own project. If the user says "file a
+bug" about the code you are working on, that belongs in their issue tracker, not
+here.
+
+Tickets land in the same Slack channels the dashboard's feedback widget posts to,
+and carry the user's identity, the repo/branch, and a link to this conversation's
+transcript automatically. Never paste secrets, tokens, or file contents into a
+ticket — the transcript link already gives the team the context.
+
+## Filing on the user's behalf
+
+When the user asks you to report something, run one of these via Bash:
+
+```
+glen bug "<title>" --description "<what is wrong>" [--steps "<repro>"] [--severity low|medium|high|critical] --agent <agent>
+glen feedback "<title>" --wants "<the concrete change>" --why "<why it matters>" [--context "<extra>"] --agent <agent>
+```
+
+Severity defaults to `medium`. Write the description in the user's own words
+where you have them. Infer `--why` when the motivation is obvious rather than
+interrogating the user for it.
+
+## Filing on your own behalf
+
+When the observation is yours, not the user's, add `--from agent`. It renders
+differently for the team — "Claude Code noticed X" reads very differently from
+"Ada wants X", and both are useful.
+
+If you are filing **without being asked** — you hit the problem yourself and
+decided it was worth reporting — also pass `--proactive`. On an off-the-record
+(incognito) session the server refuses self-initiated tickets outright and the
+command tells you so — nothing the user didn't ask for leaves that session.
+Mention it and let them decide.
+
+Only file proactively for something concrete and attributable:
+
+- a glen CLI command failed or returned a malformed result
+- `glen search` returned results that clearly contradict the code you just read
+- a glen hook misfired, or injected context that was plainly wrong
+
+Do NOT file proactively for: a search that merely found nothing, a preference of
+yours about the output format, a hunch, or anything you cannot state as a
+specific observed behaviour. When in doubt, mention it to the user instead and
+let them decide.
+
+## After running
+
+On success it prints `ok: Bug report sent…` / `ok: Feedback sent…`: tell the user
+it went in. On failure it prints an `error:` line naming the cause, with a `fix:`
+line under it (e.g. "no active organization" → `glen org switch`). Relay that to
+the user and stop.
+**Never retry a failed filing in a loop**, and never re-file the same ticket with
+different wording.

package/skills/forget/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: forget
+description: Correct glen's memory — forget evidence that is wrong, outdated, or no longer relevant, so the team stops being told it. Use when the user says things like "that's wrong, forget it", "glen has the wrong X", "that memory is out of date", or "stop remembering that" — or when YOU verify that recalled evidence is contradicted by current code or state.
+---
+
+A stale memory gets caught two ways: the user points at it, or you verify it yourself.
+
+**User-initiated** — the user says a remembered fact is wrong or outdated:
+
+1. Identify the relevant source references. Glen search results end each source with
+   an exact `observation:<id>` or `message:<id>` reference. If the result is not
+   already in context, run `glen search "<topic>"` via Bash.
+2. Confirm which evidence is wrong. Do not automatically forget every source in a
+   synthesized answer. When several sources repeat the same stale claim, select all
+   of those references.
+3. Pass the returned references unchanged, in one command:
+   `glen forget observation:<id> message:<id>`.
+
+**Agent-detected** — recalled evidence is contradicted by current code or state:
+
+1. Verify the contradiction directly. Never forget on suspicion, a partial view, or
+   merely because two memories disagree; surface uncertain conflicts to the user.
+2. Run `glen forget <reference...>` with only the contradicted source references.
+3. Tell the user exactly what was forgotten and why.
+
+Then state the correct fact in the conversation so Glen can record the correction.
+
+Notes:
+
+- Observation and message references can be mixed in one atomic command.
+- Forgetting an observation hides that distilled memory from recall.
+- Forgetting a message removes it from future recall and hides derived observations
+  that have no other active supporting message. The raw message remains visible in
+  transcript history for audit.
+- Forget is idempotent; already-hidden references are reported as unchanged.
+- Undo with `glen restore <reference...>`. Automatic restore never revives an
+  observation that a user directly forgot.
+- Legacy `[m:<id>]` and bare observation ids remain accepted.
+- If a legacy suffix is ambiguous, retry with the full `observation:<id>` listed.
+- If the CLI reports no active organization, tell the user to run
+  `glen org switch`.

package/skills/import-transcripts/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: import-transcripts
+description: Import the user's old local coding-agent transcripts (Claude Code, Codex, Cursor, or Pi sessions from before glen was installed) into glen's shared team memory. Use when the user asks to import, backfill, or migrate past sessions/conversations/chat history into glen.
+---
+
+Run `glen import <path…>` via Bash. It parses local transcripts, starts the
+import in the background and returns right away, so don't wait on it. Tell the
+user it is running. glen does not tell you when it finishes: run
+`glen import --status` to check on it (it says running, finished, or stopped,
+with counts), and check again later if the user wants to know it is done.
+
+It is safe to re-run: already-imported turns are skipped automatically, so
+re-running the same command resumes or retries a stopped import. Pass `--wait`
+only if the user wants it to run in the foreground.
+
+Where old transcripts live:
+
+- Claude Code sessions: `~/.claude/projects` (one `<session-uuid>.jsonl` per
+  session, grouped by project directory)
+- Codex sessions: `~/.codex/sessions`
+- Pi sessions: `~/.pi/agent/sessions` (one `<timestamp>_<uuid>.jsonl` per session,
+  grouped by project directory)
+- Cursor chats: `~/.config/Cursor/User/globalStorage/state.vscdb` on Linux,
+  `~/Library/Application Support/Cursor/User/globalStorage/state.vscdb` on
+  macOS (needs Node 22.5+; close Cursor first for the freshest data)
+
+A path can be a single file or a directory (scanned recursively; formats are
+auto-detected per file). Preview with `glen import --dry-run <path…>` — it
+lists every conversation and turn count without writing anything. For large
+directories, offer the dry run first so the user can confirm the scope.
+
+If it (or `glen import --status`) prints "no active organization", tell the
+user to run `glen org switch`. If it prints "not connected" or "connection
+expired", tell the user to run `glen login`. Then re-run the same import.

package/skills/invite/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: invite
+description: Invite a teammate to the user's glen organization by email, so the team's shared memory grows. Use when the user says things like "invite Alice", "add my teammate to glen", "get my team on glen", or asks how to bring coworkers in.
+---
+
+glen is shared team memory — it gets more useful with every teammate whose context
+lands in the pool. When the user wants to bring someone in:
+
+1. Get the teammate's email address. Ask if it isn't given.
+2. Run `glen invite <email>` via Bash. Invite several at once by passing more
+   emails: `glen invite alice@co.com bob@co.com`. To make someone an admin, add
+   `--role admin` (default is a regular member).
+3. Report the result. Each address prints one of:
+   - `ok: Invitation sent to <email>`: an email invite is on its way; they
+     accept at the link and join the org.
+   - `· <email> is already a member`: nothing to do.
+   - `warning: could not invite <email> (<reason>)`: relay the reason.
+
+Or share a link instead of emailing: run `glen invite` with NO email to print a
+shareable join link for the org. Anyone who signs in with a verified email on the
+org's work-email domain joins automatically — good for dropping in a team channel.
+(Requires "Let teammates join with their work email" to be enabled in
+Settings → General.)
+
+Notes:
+- Invites are sent by email and expire after 48 hours; the teammate clicks the
+  link, signs in, and lands directly in the shared memory.
+- If it prints "no active organization", tell the user to run `glen org switch`.

package/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/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/skills/setup/SKILL.md

@@ -0,0 +1,60 @@
+---
+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. After the `status:` lines, doctor lists problems: `error:`
+(broken) and `warning:` (worth fixing) lines, each with a `fix:` line under it,
+then `hint:` lines for things that may not apply. It still exits 0.
+
+- `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: claude=detected plugin=not-installed` (or codex/pi) → run
+  `glen install --agent <claude|codex|pi>` for the agent you are running in.
+  For pi, tell the user to run `/reload` inside pi (or restart pi) afterwards
+  so the glen extension loads.
+- `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`) when the user says it IS installed → ask them to run
+  `which claude` (or `which codex` / `which pi`) in their terminal, then run
+  `glen install --claude-path <that path>` (or `--codex-path` / `--pi-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 an `error:` line with a `fix:` under it (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 it as a `warning:` line with a `fix:`
+  under it: 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/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/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/src/_utils/fail-open.ts

@@ -0,0 +1,7 @@
+// A glen failure must never break a pi session, so handler errors resolve to "no change".
+export const failOpen =
+  <A extends unknown[], R>(handler: (...args: A) => Promise<R>) =>
+  (...args: A): Promise<R | undefined> =>
+    Promise.resolve()
+      .then(() => handler(...args))
+      .catch(() => undefined);

package/src/_utils/last-assistant-text.ts

@@ -0,0 +1,11 @@
+import { textOf } from "./text-of";
+
+export const lastAssistantText = (messages: readonly unknown[]): string => {
+  const last = messages.findLast(
+    (m) =>
+      m !== null &&
+      typeof m === "object" &&
+      (m as { role?: unknown }).role === "assistant",
+  );
+  return textOf((last as { content?: unknown } | undefined)?.content);
+};

package/src/_utils/parse-hook-output.ts

@@ -0,0 +1,21 @@
+import { parseJson } from "./parse-json";
+
+// A hook prints either the JSON envelope or plain text meant as context.
+export const parseHookOutput = (
+  raw: string,
+): { context: string; notice: string } => {
+  const text = raw.trim();
+  if (!text) return { context: "", notice: "" };
+  const parsed = parseJson(text);
+  if (parsed === undefined) return { context: text, notice: "" };
+  const envelope = (parsed ?? {}) as {
+    hookSpecificOutput?: { additionalContext?: unknown };
+    systemMessage?: unknown;
+  };
+  const context = envelope.hookSpecificOutput?.additionalContext;
+  const notice = envelope.systemMessage;
+  return {
+    context: typeof context === "string" ? context : "",
+    notice: typeof notice === "string" ? notice : "",
+  };
+};

package/src/_utils/parse-json.ts

@@ -0,0 +1,8 @@
+// Bad JSON comes back as undefined: JSON.parse can only report it by throwing.
+export const parseJson = (text: string): unknown => {
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return undefined;
+  }
+};

package/src/_utils/run-glen-hook.ts

@@ -0,0 +1,31 @@
+import { spawn } from "node:child_process";
+
+const HOOK_TIMEOUT_MS = 60_000;
+
+// Spawned directly because pi.exec can't write to the child's stdin, and the
+// hooks read their JSON payload from stdin. Never rejects on a glen failure.
+export const runGlenHook = (
+  command: string,
+  payload: object,
+  timeoutMs: number = HOOK_TIMEOUT_MS,
+): Promise<
+  { kind: "ok"; stdout: string } | { kind: "missing" } | { kind: "failed" }
+> =>
+  new Promise((resolve) => {
+    const [bin = "glen", ...args] = command.split(" ");
+    const child = spawn(bin, args, { stdio: ["pipe", "pipe", "ignore"] });
+    const chunks: Buffer[] = [];
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.stdout.on("data", (chunk: Buffer) => chunks.push(chunk));
+    // A glen that exits before reading its payload makes this write fail (EPIPE); close still resolves.
+    child.stdin.on("error", () => undefined);
+    child.on("error", (error: NodeJS.ErrnoException) => {
+      clearTimeout(timer);
+      resolve({ kind: error.code === "ENOENT" ? "missing" : "failed" });
+    });
+    child.on("close", () => {
+      clearTimeout(timer);
+      resolve({ kind: "ok", stdout: Buffer.concat(chunks).toString("utf8") });
+    });
+    child.stdin.end(JSON.stringify(payload));
+  });

package/src/_utils/text-of.ts

@@ -0,0 +1,13 @@
+// Joins the text blocks of a message or tool result; skips images, thinking and tool calls.
+export const textOf = (content: unknown): string => {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map(blockText).filter(Boolean).join("\n");
+};
+
+const blockText = (block: unknown): string => {
+  if (typeof block === "string") return block;
+  if (block === null || typeof block !== "object") return "";
+  const text = (block as { text?: unknown }).text;
+  return typeof text === "string" ? text : "";
+};

package/src/index.ts

@@ -0,0 +1,172 @@
+// Frozen: no business logic here; the command lines are pinned by ingest.contract.test.ts.
+import type {
+  AgentEndEvent,
+  BeforeAgentStartEventResult,
+  ExtensionAPI,
+  ExtensionContext,
+  ToolResultEventResult,
+} from "@earendil-works/pi-coding-agent";
+import { failOpen } from "./_utils/fail-open";
+import { lastAssistantText } from "./_utils/last-assistant-text";
+import { parseHookOutput } from "./_utils/parse-hook-output";
+import { runGlenHook } from "./_utils/run-glen-hook";
+import { textOf } from "./_utils/text-of";
+
+const GLEN_PI_HOOK_COMMANDS = {
+  sessionStart: "glen session-start --agent pi",
+  userPromptSubmit: "glen ingest --agent pi",
+  stop: "glen ingest --agent pi",
+  postToolUse: "glen pr-link --agent pi",
+};
+
+const GLEN_MISSING_NOTICE =
+  "glen isn't installed, so team memory is off. Run `npm i -g @tryglen/cli`, then `glen login`.";
+
+export default function glenTeamMemory(pi: ExtensionAPI): void {
+  // Per-session state; session_start resets it.
+  const state = {
+    pendingContext: [] as string[],
+    lastPrompt: null as string | null,
+    lastAssistant: null as string | null,
+    lastRunMessages: [] as AgentEndEvent["messages"],
+    warnedMissingGlen: false,
+  };
+
+  const sessionIdOf = (ctx: ExtensionContext): string =>
+    ctx.sessionManager.getSessionId();
+
+  const turnIdOf = (ctx: ExtensionContext): string =>
+    ctx.sessionManager.getLeafId() ?? `t-${Date.now().toString(36)}`;
+
+  const callGlen = async (
+    ctx: ExtensionContext,
+    command: string,
+    payload: object,
+    showNotice = true,
+  ): Promise<{ context: string; notice: string }> => {
+    const result = await runGlenHook(command, payload);
+    if (result.kind === "missing" && !state.warnedMissingGlen) {
+      state.warnedMissingGlen = true;
+      ctx.ui.notify(GLEN_MISSING_NOTICE, "warning");
+    }
+    const out = result.kind === "ok" ? result.stdout : "";
+    const parsed = parseHookOutput(out);
+    if (showNotice && parsed.notice) ctx.ui.notify(parsed.notice, "info");
+    return parsed;
+  };
+
+  // Delivered with the first prompt's injection: pi has no pre-prompt context channel.
+  pi.on(
+    "session_start",
+    failOpen(async (event, ctx) => {
+      state.pendingContext = [];
+      state.lastPrompt = null;
+      state.lastAssistant = null;
+      state.lastRunMessages = [];
+      state.warnedMissingGlen = false;
+      const { context } = await callGlen(
+        ctx,
+        GLEN_PI_HOOK_COMMANDS.sessionStart,
+        {
+          hook_event_name: "SessionStart",
+          session_id: sessionIdOf(ctx),
+          cwd: ctx.cwd,
+          source: event.reason,
+        },
+      );
+      if (context) state.pendingContext.push(context);
+    }),
+  );
+
+  pi.on(
+    "before_agent_start",
+    failOpen(
+      async (event, ctx): Promise<BeforeAgentStartEventResult | undefined> => {
+        const prompt = event.prompt;
+        if (!prompt) return undefined;
+        state.lastPrompt = prompt;
+        const { context } = await callGlen(
+          ctx,
+          GLEN_PI_HOOK_COMMANDS.userPromptSubmit,
+          {
+            hook_event_name: "UserPromptSubmit",
+            session_id: sessionIdOf(ctx),
+            cwd: ctx.cwd,
+            prompt,
+            turn_id: turnIdOf(ctx),
+            ...(state.lastAssistant
+              ? { last_assistant_message: state.lastAssistant }
+              : {}),
+          },
+        );
+        const combined = [...state.pendingContext, context]
+          .filter(Boolean)
+          .join("\n\n");
+        state.pendingContext = [];
+        if (!combined) return undefined;
+        return {
+          message: {
+            customType: "glen-context",
+            content: combined,
+            display: false,
+          },
+        };
+      },
+    ),
+  );
+
+  // agent_end fires per low-level run (retries included); agent_settled is the real end of a turn.
+  pi.on(
+    "agent_end",
+    failOpen(async (event) => {
+      state.lastRunMessages = event.messages;
+    }),
+  );
+
+  pi.on(
+    "agent_settled",
+    failOpen(async (_event, ctx) => {
+      const answer = lastAssistantText(state.lastRunMessages);
+      state.lastRunMessages = [];
+      if (answer) state.lastAssistant = answer;
+      const prompt = state.lastPrompt;
+      state.lastPrompt = null;
+      if (!prompt || !answer) return;
+      const { context } = await callGlen(ctx, GLEN_PI_HOOK_COMMANDS.stop, {
+        hook_event_name: "Stop",
+        session_id: sessionIdOf(ctx),
+        cwd: ctx.cwd,
+        prompt,
+        text: answer,
+        turn_id: turnIdOf(ctx),
+      });
+      if (context) state.pendingContext.push(context);
+    }),
+  );
+
+  pi.on(
+    "tool_result",
+    failOpen(async (event, ctx): Promise<ToolResultEventResult | undefined> => {
+      if (event.toolName !== "bash" || event.isError) return undefined;
+      const command =
+        typeof event.input.command === "string" ? event.input.command : "";
+      const output = textOf(event.content);
+      if (!command && !output) return undefined;
+      const { context } = await callGlen(
+        ctx,
+        GLEN_PI_HOOK_COMMANDS.postToolUse,
+        {
+          hook_event_name: "PostToolUse",
+          session_id: sessionIdOf(ctx),
+          cwd: ctx.cwd,
+          tool_name: "Bash",
+          tool_input: { command },
+          tool_response: output,
+        },
+        false,
+      );
+      if (!context) return undefined;
+      return { content: [...event.content, { type: "text", text: context }] };
+    }),
+  );
+}