@sayansr26/agent-os 0.6.1 → 0.6.3

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Context engineering and agent tooling for Claude Code.",
-    "version": "0.5.0"
+    "version": "0.5.1"
   },
   "plugins": [
     {
@@ -33,6 +33,18 @@
         "effort",
         "mod"
       ]
+    },
+    {
+      "name": "auto-handoff",
+      "source": "./plugins/auto-handoff",
+      "description": "Hands a long session off to a fresh one instead of auto-compacting: Haiku writes a structured brief, the mod runs /clear and seeds the new session with it. Vendored from alexknowshtml/claude-auto-handoff (MIT).",
+      "category": "productivity",
+      "keywords": [
+        "context",
+        "handoff",
+        "compaction",
+        "mod"
+      ]
     }
   ]
 }

package/CHANGELOG.md

@@ -5,6 +5,50 @@ All notable changes to this project are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.3] — 2026-10-31
+
+agent-os plugin 0.5.1 (hooks gain a Cursor mode; Claude Code behaviour
+unchanged), auto-route unchanged (0.1.0), auto-handoff unchanged (0.8.6).
+
+### Added
+- **The agent-os layer for Cursor.** With `cursor` as a target, `init` and
+  `sync` compile the seven agents to `.cursor/agents/agent-os-<name>.md`, the
+  three skills to `/agent-os-init`, `/agent-os-map` and `/agent-os-memory`, the
+  session-start and pre-edit hooks plus git write protection to
+  `.cursor/hooks/agent-os/` (registered in `.cursor/hooks.json`, merged), and
+  the agent contract to an always-on `.cursor/rules/agent-os-agents.mdc`.
+  Subagent memory uses `.claude/agent-memory/agent-os-<name>/`, the directories
+  Claude Code's plugin agents use. `{ "cursor": { "agentOs": false } }` or
+  `{ "cursor": { "gitProtection": false } }` in `.agent-os/config.json` opt out.
+- `session-resume.mjs --cursor` and `pre-edit.mjs --cursor` answer in Cursor's
+  hook protocol (`additional_context`; `permission` with an explicit `allow`).
+
+### Fixed
+- **`init` in a project that does not target Claude Code** no longer prints
+  Claude Code's SETUP block or ends `fresh → repair` with a to-do list of
+  CLAUDE.md, `.claude/settings.json` and plugin items — including one telling
+  the user to run `init` again. It now ends with what it compiled for.
+
+## [0.6.2] — 2026-10-22
+
+agent-os plugin unchanged (0.5.0), auto-route unchanged (0.1.0). New plugin
+auto-handoff 0.8.6 in the same marketplace.
+
+### Added
+- **auto-handoff, a third plugin in the `sayan-plugins` marketplace**, vendored
+  from [alexknowshtml/claude-auto-handoff](https://github.com/alexknowshtml/claude-auto-handoff)
+  by Alex Hillman (MIT, commit `8d762ce`). In place of auto-compact, Haiku
+  writes a structured brief, the mod runs `/clear`, and the fresh session is
+  seeded with a pointer to the brief. `/plugin install auto-handoff@sayan-plugins`.
+  The brief viewer server is **off** by default here (upstream serves on the
+  Tailscale IP); `plugins/auto-handoff/UPSTREAM.md` lists every local change.
+- **`agent-os init` installs and updates auto-handoff** with the other two;
+  `--no-auto-handoff` leaves it out.
+
+### Changed
+- `scripts/validate-plugin.mjs` lets a mod carry a listing `icon.png`, as the
+  agent-os plugin now does.
+
 ## [0.6.1] — 2026-10-21
 
 agent-os plugin unchanged (0.5.0). New plugin auto-route 0.1.0 in the same

package/README.md

@@ -110,14 +110,38 @@ Generated files carry a banner. Edit `.agent-os/`, run `sync`, never edit the ou
 
 Being straight about this matters more than the feature list.
 
-**Hooks don't port.** Every tool differs in events *and* control protocol — Cursor returns JSON `permission`, Windsurf uses exit codes, Claude Code uses JSON. There is no honest common denominator, so `agent-os` doesn't invent one.
+**Hooks don't port generically.** Every tool differs in events *and* control protocol — Cursor returns JSON `permission`, Windsurf uses exit codes, Claude Code uses JSON. There is no honest common denominator, so `agent-os` doesn't invent one for your hooks. Its own hooks are written once per tool: Claude Code (the plugin) and Cursor (see below).
 
-**Memory doesn't port.** Only Claude Code (auto memory) and Windsurf have native per-session memory. Kilo deprecated its Memory Bank in favour of `AGENTS.md`; Cline's is a community methodology, not a feature. So the architecture map — the thing that makes *"change the login flow from email to OTP"* run off known structure — works in Claude Code and nowhere else yet.
+**Memory doesn't port generically.** Only Claude Code (auto memory) and Windsurf have native per-session memory. Kilo deprecated its Memory Bank in favour of `AGENTS.md`; Cline's is a community methodology, not a feature. So the architecture map — the thing that makes *"change the login flow from email to OTP"* run off known structure — works in Claude Code and Cursor, whose subagents are told where their memory lives, and nowhere else yet.
 
 **Antigravity's rules target is best effort.** Its docs state a rule is "simply a Markdown file" and never show frontmatter; glob activation is configured in the Customizations panel. So `agent-os` writes valid Markdown and states the intended scope in a comment, rather than inventing a `globs:` key that may silently do nothing.
 
 ---
 
+## Cursor
+
+When Cursor is a target, `init` and `sync` also compile the agent-os layer into the places Cursor reads it — the same agents, skills and hooks the Claude Code plugin ships:
+
+| Claude Code (plugin) | Cursor (generated) |
+|---|---|
+| agents `agent-os:<name>` | subagents `.cursor/agents/agent-os-<name>.md` |
+| `/agent-os:init`, `/agent-os:map`, `/agent-os:memory` | `/agent-os-init`, `/agent-os-map`, `/agent-os-memory` in `.cursor/skills/` |
+| SessionStart hook | `sessionStart` hook → `additional_context` |
+| PreToolUse guard on generated files + cartographer reminder | `preToolUse` hook on `Write` |
+| git write protection in `permissions.deny` | `beforeShellExecution` hook refusing the same git commands |
+| "Agents in this project" section of `CLAUDE.md` | `.cursor/rules/agent-os-agents.mdc`, always applied |
+| per-agent memory, `.claude/agent-memory/agent-os-<name>/` | the same directories — one map for both tools |
+
+Hook scripts live in `.cursor/hooks/agent-os/` and are registered in `.cursor/hooks.json`, merged so your own hooks stay. Everything carries the generated banner, so `check` catches drift and the pre-edit hook blocks hand edits; `sync` after upgrading the package is the Cursor equivalent of `claude plugin update`. Reload the Cursor window after `init`, then run `/agent-os-init` in Agent chat.
+
+```json
+{ "targets": ["cursor"], "cursor": { "agentOs": true, "gitProtection": true } }
+```
+
+`agentOs: false` stops generating the layer and removes its hooks from `hooks.json` (delete the `agent-os-*` files yourself); `gitProtection: false` drops only the git hook. What does not carry over: Claude Code's auto memory, task tools (Cursor has its own to-do list), and the auto-route and auto-handoff mods.
+
+---
+
 ## The Claude Code plugin
 
 The deeper context-engineering work — the architecture map, seven coordinated agents, per-agent memory, and the hooks that make Claude use them — ships as a Claude Code plugin in this repo:
@@ -162,6 +186,16 @@ claude plugin test plugins/auto-route      # tests/route.test.ts
 
 Once the engine loads it, it writes `.claude-plugin/types/` (git-ignored) for the editor; `tsc -p plugins/auto-route` type-checks it after that. Bump `version` in its `plugin.json` when shipping a change so installs update.
 
+### auto-handoff
+
+A third plugin, vendored from [alexknowshtml/claude-auto-handoff](https://github.com/alexknowshtml/claude-auto-handoff) by Alex Hillman (MIT). Instead of auto-compacting at the context limit, it has Haiku write a structured brief, runs `/clear`, and seeds the fresh session with a pointer to the brief, so work carries on with a clean context. Settings (threshold, templates, ignored files) are rows in `/config`.
+
+```
+/plugin install auto-handoff@sayan-plugins
+```
+
+`agent-os init` installs it too; `--no-auto-handoff` leaves it out. One change from upstream: the brief viewer server is **off** by default here (upstream serves pages on your Tailscale IP); set `viewer` in `/config` to turn it on. `plugins/auto-handoff/UPSTREAM.md` records the upstream commit, the local changes and how to sync. Develop it the same way as auto-route: `claude --plugin-dir plugins/auto-handoff`, `claude plugin validate|test plugins/auto-handoff`.
+
 ---
 
 ## Design rules

package/cursor/hooks/git-guard.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * Cursor beforeShellExecution hook — git write protection.
+ *
+ * Claude Code gets this as `permissions.deny` rules in .claude/settings.json.
+ * Cursor has no deny list, so the same rules (GIT_DENY, generated next to this
+ * file from settings.mjs) are enforced here: any git command that changes the
+ * repository is denied, read-only inspection is allowed.
+ *
+ * The hook is registered with a `git` matcher, so it only sees commands that
+ * mention git. Cursor reads a missing or invalid response as a block, so every
+ * exit answers explicitly.
+ */
+import { readFileSync } from "node:fs";
+import { GIT_DENY } from "../lib/git-deny.mjs";
+
+const answer = (o) => { process.stdout.write(JSON.stringify(o)); process.exit(0); };
+
+// "Bash(git push *)" -> "git push" plus anything after a space;
+// "Bash(git -C*)" -> anything starting "git -C".
+const RULES = GIT_DENY.map((r) => r.replace(/^Bash\(/, "").replace(/\)$/, "")).map((r) =>
+  r.endsWith(" *") ? { prefix: r.slice(0, -2), spaced: true } : { prefix: r.replace(/\*$/, ""), spaced: false });
+
+const denied = (segment) => {
+  const cmd = segment.trim().replace(/\s+/g, " ").replace(/^(?:\w+=\S*\s+)+/, "");
+  return RULES.find((r) => r.spaced ? cmd === r.prefix || cmd.startsWith(`${r.prefix} `) : cmd.startsWith(r.prefix));
+};
+
+let command = "";
+try { command = String(JSON.parse(readFileSync(0, "utf8") || "{}").command ?? ""); } catch { answer({ permission: "allow" }); }
+
+// Check every command in a chain: `cd x && git push` is still a push.
+for (const segment of command.split(/&&|\|\||[;|\n]|\$\(|`/)) {
+  const hit = denied(segment);
+  if (!hit) continue;
+  const text = `agent-os blocks git commands that change the repository (${hit.prefix}${hit.spaced ? " …" : "…"}). ` +
+    "Read-only git (status, log, diff, show, blame) is allowed. Ask the user to run this one themselves.";
+  answer({ permission: "deny", user_message: text, agent_message: text });
+}
+answer({ permission: "allow" });

package/cursor/skills/agent-os-init/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: agent-os-init
+description: Set up or repair this project's agent-os context layer in Cursor. Checks the generated rules, subagents and hooks against .agent-os/, inspects agent memory, then establishes, maps, migrates or maintains the layer. Use for "set up agent-os", "agent-os init", "initialise this project", "bootstrap my context setup", "migrate off memory-bank or .cursorrules", "my AGENTS.md is too big", or when starting work in a repo with no setup.
+---
+
+# agent-os for Cursor — set up or repair
+
+The Cursor counterpart of Claude Code's `/agent-os:init`. Same layout, same
+agents, same memory — only the file names differ.
+
+| Tier | Lives in | Startup cost | Holds |
+|---|---|---|---|
+| Always-loaded | `AGENTS.md` (from `.agent-os/AGENTS.md`), ≤200 lines | small, fixed | Only what is true in *every* session |
+| On-demand | `.cursor/rules/*.mdc` with `globs:` (from `.agent-os/rules/*.md` with `paths:`) | **zero** | Durable facts scoped to some files |
+| Explored | `.claude/agent-memory/agent-os-feature-cartographer/` | **zero** (subagent context) | How each feature is actually built |
+| Task state | the project's own vault / handoff file | zero (read selectively) | What is in flight right now |
+
+Agent memory stays under `.claude/agent-memory/` on purpose: Claude Code's
+agent-os agents use the same directories, so a team on both tools shares one map.
+
+**Storing a fact and loading a fact are different acts.** Anything that makes
+them the same act — a handbook `AGENTS.md`, a memory bank read at every startup,
+an always-apply rule that only matters for one directory — is the bug.
+
+## Arguments
+
+| Argument | Do |
+|---|---|
+| *(none)* | The full pass below |
+| `audit` | Steps 1 and 3 only. Change nothing. |
+
+`/agent-os-map` builds the architecture map; `/agent-os-memory` inspects and
+repairs what the project remembers.
+
+## Step 1 — Read the state
+
+Three commands. Do not rediscover this with a dozen file reads — they are
+deterministic:
+
+```bash
+npx -y @sayansr26/agent-os detect
+npx -y @sayansr26/agent-os check
+npx -y @sayansr26/agent-os memory
+```
+
+`check` lists every generated file — rules, `AGENTS.md`, the `agent-os-*`
+subagents and skills, the hook scripts and `.cursor/hooks.json` — as `ok`,
+`MISSING` or `DRIFTED`. `memory` lists every agent's memory, which features are
+mapped, and a health list.
+
+**Show the output to the user before you change anything.**
+
+## Step 2 — Fresh setup or repair?
+
+| State | Do |
+|---|---|
+| no `.agent-os/` | `npx -y @sayansr26/agent-os init`, then carry on with Step 3 |
+| `check` reports `MISSING` or `DRIFTED` | `npx -y @sayansr26/agent-os sync` — it rewrites only what it generated |
+| `sync` names files it did not generate | stop and ask: move their content into `.agent-os/` (preferred), or `--force` after a commit |
+| everything `ok` | nothing to repair |
+
+Never edit a generated file by hand. They carry a banner, the pre-edit hook
+blocks the edit, and the next `sync` would revert it. Edit `.agent-os/` and sync.
+
+## Step 3 — Decide what this run is for
+
+Judge from what Step 1 printed and a look at the source tree:
+
+| Mode | Evidence | Do |
+|---|---|---|
+| `TOO-EARLY` | Barely any source (under ~5 files) | **Build nothing.** A layer over an empty project is invented conventions. |
+| `ESTABLISH` | `.agent-os/AGENTS.md` is still the placeholder, or the only rule is `example.md` | `references/establishing.md` — build the layer *from the code* |
+| `MAP` | Layer real, but `memory` shows no `_architecture.md` | `references/establishing.md`, "Map the architecture" — or `/agent-os-map` |
+| `MIGRATE` | `.cursorrules`, `memory-bank/`, `.serena/memories/`, or an always-apply rule that only concerns part of the tree | fix it; `references/migrating.md` for legacy stores |
+| `MAINTAIN` | Real layer, architecture mapped | report and stop |
+
+`references/changing-a-feature.md` is the workflow that pays all this back —
+point the user at it once the layer exists.
+
+The references were written for Claude Code. Read them through this table:
+
+| They say | In Cursor |
+|---|---|
+| `CLAUDE.md` | `.agent-os/AGENTS.md` (compiled to `AGENTS.md`). Draft it yourself from the code — there is no `/init` to run first. |
+| `.claude/rules/*.md` | `.agent-os/rules/*.md`, then `sync` (compiled to `.cursor/rules/*.mdc`) |
+| `agent-os:<name>` | the `agent-os-<name>` subagent |
+| `/agent-os:init`, `/agent-os:map`, `/agent-os:memory` | `/agent-os-init`, `/agent-os-map`, `/agent-os-memory` |
+| `node "${CLAUDE_PLUGIN_ROOT}/…/<script>.mjs"` | `npx -y @sayansr26/agent-os <script>` |
+| "Wire the agents into CLAUDE.md" (Step 4b) | already done: `.cursor/rules/agent-os-agents.mdc` is always applied — skip it |
+| the settings pass, `permissions.deny`, task tools | see "Git write protection" below; Cursor has its own to-do list |
+
+## Step 4 — Verify by re-running
+
+Run `check` and `memory` again and show before and after: generated files all
+`ok`, features mapped, health findings. Do not declare success on vibes — the
+commands produce the numbers, so quote them.
+
+## Git write protection
+
+Claude Code gets git write protection as `permissions.deny` rules. Cursor has no
+deny list, so `sync` registers a `beforeShellExecution` hook in
+`.cursor/hooks.json` (`.cursor/hooks/agent-os/hooks/git-guard.mjs`) that refuses
+the same commands: every git command that changes the repository. Read-only git
+stays available. `references/git-permissions.md` explains each rule.
+
+If the user wants it off: `{ "cursor": { "gitProtection": false } }` in
+`.agent-os/config.json`, then `sync`. Say what that gives up.
+
+## What this skill will not do
+
+- It will not write facts it has not verified in the repo. An invented rule is
+  worse than a missing one, because it will be trusted.
+- It will not delete a legacy store before its content has landed in `.agent-os/`.
+- It will not hand-edit generated files, or another agent's memory.
+- It will not add a memory MCP server. The common failure is that nothing was
+  *written*, which a graph does not fix and the cartographer's memory does.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sayansr26/agent-os",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "One source of truth for AI coding agent config. Write your rules once; compile them to Claude Code, Cursor, Cline, Windsurf, Antigravity, Gemini CLI, OpenCode and Kilo.",
   "keywords": [
     "ai",
@@ -34,6 +34,7 @@
     "bin",
     "src",
     "plugins",
+    "cursor",
     ".claude-plugin",
     "README.md",
     "LICENSE",
@@ -43,7 +44,6 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node scripts/validate-plugin.mjs && node src/selftest.mjs",
-    "prepublishOnly": "npm test"
+    "test": "node scripts/validate-plugin.mjs && node src/selftest.mjs"
   }
-}
+}

package/plugins/agent-os/.claude-plugin/plugin.json

@@ -1,15 +1,15 @@
 {
   "name": "agent-os",
   "description": "A context-engineered agent system for Claude Code. Ships a durable per-project memory layer, a cartographer that maps your codebase once and remembers it, and a coordinated agent set that reads your project's rules rather than hardcoding them.",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "author": {
     "name": "Sayan Choudhury",
     "email": "sayan.choudhury.in@gmail.com"
   },
   "homepage": "https://github.com/sayansr26/agent-os",
   "repository": "https://github.com/sayansr26/agent-os",
-  "privacyPolicyUrl": "https://s3techpulse.com/privacy-policy",
-  "supportUrl": "https://s3techpulse.com/support",
+  "privacyPolicyUrl": "https://github.com/sayansr26/agent-os/blob/master/PRIVACY.md",
+  "supportUrl": "https://github.com/sayansr26/agent-os/issues",
   "license": "MIT",
   "keywords": [
     "context-engineering",

package/plugins/agent-os/hooks/pre-edit.mjs

@@ -10,11 +10,16 @@
  *      Deny, and name the source to edit instead.
  *   2. Cartographer reminder (advisory, never blocks). The first edit to an
  *      existing feature with no cartographer map adds a note telling Claude to
- *      ask agent-os:feature-cartographer first. Once per feature per session.
+ *      ask agent-os:feature-cartographer first (agent-os-feature-cartographer
+ *      in Cursor). Once per feature per session.
  *
  * Stays silent for new (untracked) features, paths outside a feature
  * directory, and anything it cannot work out. Turn the reminder off with
  * `{ "claude": { "cartographerReminder": false } }` in `.agent-os/config.json`.
+ *
+ * `--cursor` is the same hook as Cursor's preToolUse on Write. Cursor reads a
+ * missing or empty response as a block, so in that mode every exit answers
+ * explicitly: `allow` (with the reminder as `agent_message`) or `deny`.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -24,17 +29,33 @@ import { claudeConfig, featureOf, findMap, mapFiles, tracked } from "../lib/feat
 // Must stay a substring of BANNER in src/source.mjs.
 const BANNER = "agent-os: generated from .agent-os/";
 
-const quiet = () => process.exit(0);
+const CURSOR = process.argv.includes("--cursor");
+const agent = (name) => `agent-os${CURSOR ? "-" : ":"}${name}`;
+
+const quiet = () => {
+  if (CURSOR) process.stdout.write(JSON.stringify({ permission: "allow" }));
+  process.exit(0);
+};
 const emit = (hookSpecificOutput) => {
-  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", ...hookSpecificOutput } }));
+  if (CURSOR) {
+    const deny = hookSpecificOutput.permissionDecision === "deny";
+    const text = deny ? hookSpecificOutput.permissionDecisionReason : hookSpecificOutput.additionalContext;
+    process.stdout.write(JSON.stringify(deny
+      ? { permission: "deny", user_message: text, agent_message: text }
+      : { permission: "allow", agent_message: text }));
+  } else
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", ...hookSpecificOutput } }));
   process.exit(0);
 };
 
 let payload;
 try { payload = JSON.parse(readFileSync(0, "utf8") || "{}"); } catch { quiet(); }
 
-const root = process.env.CLAUDE_PROJECT_DIR || payload?.cwd || process.cwd();
-const raw = String(payload?.tool_input?.file_path ?? "");
+// Claude Code may run inside Cursor's terminal, so CURSOR_PROJECT_DIR counts only in --cursor mode.
+const root = (CURSOR && process.env.CURSOR_PROJECT_DIR) || process.env.CLAUDE_PROJECT_DIR || payload?.cwd || process.cwd();
+// Cursor does not document its Write tool's input, so take the usual names.
+const input = payload?.tool_input || {};
+const raw = String(input.file_path ?? input.path ?? input.target_file ?? input.filePath ?? "");
 if (!raw) quiet();
 const abs = isAbsolute(raw) ? raw : join(root, raw);
 const rel = relative(root, abs).replace(/\\/g, "/");
@@ -44,6 +65,14 @@ if (rel.startsWith("..")) quiet();
 try {
   if (existsSync(join(root, ".agent-os")) && existsSync(abs) && readFileSync(abs, "utf8").includes(BANNER)) {
     let source = ".agent-os/";
+    // Cursor's agent-os layer is compiled from the package, not from .agent-os/.
+    if (/^\.cursor\/(?:agents\/agent-os-|skills\/agent-os-|hooks\/agent-os\/|rules\/agent-os-agents\.mdc$)/.test(rel))
+      emit({
+        permissionDecision: "deny",
+        permissionDecisionReason:
+          `${rel} is part of the agent-os layer for Cursor and the next sync would revert this edit. ` +
+          `To customise it, set \`{ "cursor": { "agentOs": false } }\` in .agent-os/config.json and keep your own copy.`,
+      });
     const rule = rel.match(/^\.(?:claude|clinerules|cursor|windsurf|kilocode|gemini|agents?)\/(?:rules\/)?(.+?)\.(?:md|mdc)$/);
     if (rel === "AGENTS.md") source = ".agent-os/AGENTS.md";
     else if (rule && existsSync(join(root, ".agent-os/rules", `${basename(rule[1])}.md`)))
@@ -67,7 +96,7 @@ try {
 
   const dir = join(tmpdir(), "agent-os-reminders");
   mkdirSync(dir, { recursive: true });
-  const session = String(payload?.session_id ?? "nosession").replace(/[^\w-]/g, "");
+  const session = String(payload?.session_id ?? payload?.conversation_id ?? "nosession").replace(/[^\w-]/g, "");
   const marker = join(dir, `${session}--${feature.dir.replace(/[^\w-]/g, "_")}`);
   if (existsSync(marker)) quiet();
   writeFileSync(marker, "");
@@ -75,7 +104,7 @@ try {
   emit({
     additionalContext:
       `agent-os (advisory): ${feature.dir}/ is an existing feature with no cartographer map. ` +
-      `Before changing it further, ask agent-os:feature-cartographer how "${feature.name}" is built — ` +
+      `Before changing it further, ask ${agent("feature-cartographer")} how "${feature.name}" is built — ` +
       `it answers and files the map for every later session. This applies in plan mode too ` +
       `(ask it read-only; it writes the map after plan mode ends). Shown once per feature per session.`,
   });

package/plugins/agent-os/hooks/session-resume.mjs

@@ -16,6 +16,9 @@
  *   - The snapshot is hard-capped (MAX_LINES); the contract is fixed-size.
  *   - Fails silent: any error exits 0, so a broken hook never blocks a session.
  *   - Read-only. Runs git for reading only; never writes, never mutates.
+ *
+ * `--cursor` is the same hook as Cursor's sessionStart: agent names in Cursor's
+ * `agent-os-<name>` form, and the text wrapped as `{ additional_context }`.
  */
 
 import { execSync } from "node:child_process";
@@ -24,7 +27,13 @@ import { join } from "node:path";
 import { coverage } from "../lib/features.mjs";
 
 const MAX_LINES = 40;
-const cwd = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const CURSOR = process.argv.includes("--cursor");
+// Claude Code may run inside Cursor's terminal, so CURSOR_PROJECT_DIR counts only in --cursor mode.
+const cwd = (CURSOR && process.env.CURSOR_PROJECT_DIR) || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+// Claude Code namespaces plugin agents and skills with `:`; Cursor names allow
+// only letters and hyphens, so its generated copies use `-`.
+const agent = (name) => `agent-os${CURSOR ? "-" : ":"}${name}`;
+const skill = (name) => `/agent-os${CURSOR ? "-" : ":"}${name}`;
 const out = [];
 
 const sh = (cmd) => {
@@ -135,13 +144,13 @@ function snapshot() {
 
 // The agents and what triggers each. `subagent_type` is the namespaced name.
 const AGENTS = [
-  ["agent-os:feature-cartographer", "BEFORE changing any existing feature — ask how it is built (files, state, API, blast radius). It answers from its map, or maps the feature and files the map."],
-  ["agent-os:architect", "before a new subsystem, a cross-module change, or a data model others will depend on."],
-  ["agent-os:builder", "to write the code once the shape is settled; it enforces the project's rules while writing."],
-  ["agent-os:tester", "after building, to verify the change actually works."],
-  ["agent-os:reviewer", "before calling any change done or opening a PR."],
-  ["agent-os:documenter", "once work is verified, to update the changelog, task state and docs the change invalidated."],
-  ["agent-os:orchestrator", "for work spanning several of the above, or that cannot be stated in one sentence."],
+  ["feature-cartographer", "BEFORE changing any existing feature — ask how it is built (files, state, API, blast radius). It answers from its map, or maps the feature and files the map."],
+  ["architect", "before a new subsystem, a cross-module change, or a data model others will depend on."],
+  ["builder", "to write the code once the shape is settled; it enforces the project's rules while writing."],
+  ["tester", "after building, to verify the change actually works."],
+  ["reviewer", "before calling any change done or opening a PR."],
+  ["documenter", "once work is verified, to update the changelog, task state and docs the change invalidated."],
+  ["orchestrator", "for work spanning several of the above, or that cannot be stated in one sentence."],
 ];
 
 function contract() {
@@ -153,15 +162,17 @@ function contract() {
     return [
       "## agent-os",
       "",
-      "The agent-os plugin is installed but this project is not set up. If the user starts feature work, suggest `/agent-os:init` once.",
+      `agent-os is installed but this project is not set up. If the user starts feature work, suggest \`${skill("init")}\` once.`,
     ];
 
   const lines = [
     "## agent-os is active in this project",
     "",
-    "These agents are how work is done here — use them without being asked (Agent tool, `subagent_type` as shown):",
+    CURSOR
+      ? "These subagents are how work is done here — delegate to them without being asked, by the names shown:"
+      : "These agents are how work is done here — use them without being asked (Agent tool, `subagent_type` as shown):",
   ];
-  for (const [name, when] of AGENTS) lines.push(`- \`${name}\` — ${when}`);
+  for (const [name, when] of AGENTS) lines.push(`- \`${agent(name)}\` — ${when}`);
 
   const cov = coverage(cwd);
   lines.push("");
@@ -173,12 +184,14 @@ function contract() {
   } else if (cov.dir) {
     lines.push(`Cartographer maps are indexed in \`${cov.dir.slice(cwd.length + 1)}/MEMORY.md\`.`);
   }
-  if (!cov.architecture) lines.push("No architecture map yet — `/agent-os:map` builds it.");
+  if (!cov.architecture) lines.push(`No architecture map yet — \`${skill("map")}\` builds it.`);
 
   lines.push("");
-  lines.push("Plan mode: its \"Explore agents only\" phase does not replace the cartographer. Ask the cartographer read-only during planning (it will not write), and let it file its map once plan mode ends.");
+  lines.push(CURSOR
+    ? "Plan mode: ask the cartographer read-only during planning (it will not write), and let it file its map once plan mode ends."
+    : "Plan mode: its \"Explore agents only\" phase does not replace the cartographer. Ask the cartographer read-only during planning (it will not write), and let it file its map once plan mode ends.");
   if (existsSync(join(cwd, ".agent-os/rules")))
-    lines.push("Rules: `.claude/rules/*` and other tool copies are generated. Edit `.agent-os/rules/`, then run `npx @sayansr26/agent-os sync`.");
+    lines.push(`Rules: \`${CURSOR ? ".cursor/rules/*" : ".claude/rules/*"}\` and other tool copies are generated. Edit \`.agent-os/rules/\`, then run \`npx @sayansr26/agent-os sync\`.`);
   return lines;
 }
 
@@ -186,7 +199,8 @@ try {
   const blocks = [];
   try { const s = snapshot(); if (s.length) blocks.push(s.join("\n")); } catch {}
   try { blocks.push(contract().join("\n")); } catch {}
-  if (blocks.length) process.stdout.write(blocks.join("\n\n") + "\n");
+  if (CURSOR) process.stdout.write(JSON.stringify(blocks.length ? { additional_context: blocks.join("\n\n") } : {}));
+  else if (blocks.length) process.stdout.write(blocks.join("\n\n") + "\n");
 } catch {
   // Never let a resume hook break a session.
 }

package/plugins/auto-handoff/.claude-plugin/plugin.json

@@ -0,0 +1,49 @@
+{
+  "name": "auto-handoff",
+  "version": "0.8.6",
+  "description": "Hands a Claude Code session off to a fresh one before the context fills: a Haiku-written brief, /clear, and a seed that points the new session at the brief.",
+  "author": {
+    "name": "Alex Hillman",
+    "url": "https://github.com/alexknowshtml"
+  },
+  "repository": "https://github.com/alexknowshtml/claude-auto-handoff",
+  "license": "MIT",
+  "userConfig": {
+    "threshold": {
+      "type": "number",
+      "title": "Handoff threshold (tokens)",
+      "description": "Context size that triggers a handoff. AUTO_HANDOFF_TOKENS overrides it for a test run. A seeded session hands off no sooner than 40k past its starting size; the panel above the prompt says so when this is set lower.",
+      "default": 160000
+    },
+    "maxConsecutiveHandoffs": {
+      "type": "number",
+      "title": "Handoffs in a row without a message",
+      "description": "Handoffs allowed before you type a prompt. Past this the mod pauses until you send one.",
+      "default": 2
+    },
+    "briefTemplate": {
+      "type": "string",
+      "title": "Brief template file",
+      "description": "Markdown file that tells Haiku which sections to write. Created with the defaults on first run; edit it to change the brief.",
+      "default": "~/.claude/auto-handoff/brief.md"
+    },
+    "instructionsTemplate": {
+      "type": "string",
+      "title": "Instructions template file",
+      "description": "Markdown file that tells the fresh session how to read the brief. Created with the defaults on first run.",
+      "default": "~/.claude/auto-handoff/instructions.md"
+    },
+    "ignoreFiles": {
+      "type": "string",
+      "title": "Ignored files (regex)",
+      "description": "Edited files matching this pattern are left out of the brief, such as auto-synced state or caches. Leave blank for none.",
+      "default": ""
+    },
+    "viewer": {
+      "type": "string",
+      "title": "Viewer address",
+      "description": "Where the mod serves a readable page for each brief, as host:port, e.g. 127.0.0.1:3846. \"tailscale\" as the host means this machine's Tailscale IP, so only your tailnet can open it; without Tailscale it serves on 127.0.0.1. Blank (the default here) runs no server; the link is then the local file.",
+      "default": ""
+    }
+  }
+}

package/plugins/auto-handoff/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Hillman
+
+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.