hilos-agent 0.7.0 → 0.9.1

package/README.md

@@ -82,9 +82,24 @@ hilos-agent --channel <id>   # scope to one channel
   `repos`. No mapping → the agent says so and stops.
 - **Run** — it branches off `defaultBranch` (refuses a dirty tree), runs
   `codingCmd` with the task, and stages the result.
+- **Continue the thread's PR** — when the mention lands in a thread hilos says is
+  about a pull request, the daemon works on *that* PR instead of opening a second
+  one: it fetches the PR's head branch, commits there, and the same PR updates.
+  It confirms with `gh` that the PR is still open first — a merged, closed, or
+  fork PR gets a fresh branch, and the run says so.
+- **Merge / close on request** — "merge it" from a workspace owner or admin in a
+  PR thread is executed, not described. The daemon relays the request to hilos
+  with the id of the message that asked; hilos verifies the person's role and
+  that their message really asks for it, then acts with the workspace's GitHub
+  App. The daemon never merges on its own judgment and holds no merge rights.
 - **Open a PR** (default) — it commits, pushes with *your* `git`/`gh`, opens a PR,
   and posts a report card with the link. Review on the card: **Approve** merges,
   **Reject** closes, **Request changes** re-works.
+- **Recover an over-eager coding CLI** — if the child commits or switches
+  branches despite the edit-only prompt, the daemon pushes that HEAD under the
+  task branch it owns. It never asks GitHub to open the default branch against
+  itself, and a rejected PR creation includes GitHub's actual error in the
+  report.
 - **Approve-before-push** (`gate:true`) — instead, it posts the staged diff as a
   card and polls for your decision; **Approve** pushes + opens the PR, **Reject**
   discards the branch, **Request changes** re-runs with your note (bounded rounds).
@@ -221,24 +236,32 @@ bridge; Claude Code, Codex, Cursor, and other adapters still follow their own
 CLI permission modes until their native approval hooks join the same
 vendor-neutral hilos substrate.
 
-## Hooks — stream a raw Claude Code session
+## Hooks — keep a raw Codex, Claude Code, or Cursor session in the room
 
-Don't want to run a persistent daemon? You can still make your Claude Code CLI
-sessions visible to your team in real time. **Claude Code hooks** (shipped in
-0448) let every tool call your session makes stream directly into your agent's
-live status card in hilos — no daemon, no extra process.
+Keep working in the interactive coding tool you already use. Project hooks make
+Codex, Claude Code, or Cursor visible on the agent's live card and bind a successful
+hilos `post_message` / `post_report` to that exact provider session. With the
+normal `hilos-agent` process running, a person's reply in the bound hilos thread
+becomes the next turn in the same local session and checkout.
 
 ```sh
 # Inside the repo you want to stream:
 npx hilos-agent hooks install
 
-# Or stream all your Claude Code sessions, everywhere:
+# Install only one provider, if you prefer:
+npx hilos-agent hooks install --codex
+npx hilos-agent hooks install --claude
+npx hilos-agent hooks install --cursor
+
+# Or opt in every repo on this machine:
 npx hilos-agent hooks install --global
 ```
 
-This writes `PostToolUse`, `Stop`, and `SessionEnd` hook entries into
-`.claude/settings.json` (project) or `~/.claude/settings.json` (global),
-preserving any hooks you already have. Preview the block without writing anything:
+This writes lifecycle entries into `.codex/hooks.json`, `.claude/settings.json`,
+and `.cursor/hooks.json` (or their home-directory equivalents with `--global`),
+preserving any hooks you already have. Codex asks you to review new project
+hooks once; open `/hooks` and trust the hilos entries. Preview all three blocks
+without writing anything:
 
 ```sh
 npx hilos-agent hooks print
@@ -246,21 +269,34 @@ npx hilos-agent hooks print
 
 **Requirements:**
 - `npm i -g hilos-agent` so the `hilos-agent hook` command resolves at hook time.
-- A `~/.hilos/agent.json` with `url`, `token`, and `channelId`. Generate these in
-  the agent's **Connect via MCP** panel in hilos (same panel as `--join`).
+- A `~/.hilos/agent.json` with `url` and the owned agent's `token`; `channelId`
+  is needed only for the fallback live card. Generate these in the agent's
+  **Connect via MCP** panel in hilos (same panel as `--join`).
+- Keep `hilos-agent` running to pick replies up. Hooks alone still stream live
+  steps, but MCP has no server-push channel that can wake an idle local client.
 
 **What you get:**
 - Team members see "Editing lib/x.ts" or "Running pnpm test" on the agent's live
   card as each tool fires — without you doing anything beyond the install.
+- A successful hilos post binds its returned message to this provider session.
+  A person's later reply to that exact thread resumes the same session while
+  `hilos-agent` is running. Ambient messages, older thread history, and agent
+  replies do not wake it.
+- The room's normal execution gate still applies; a chat-only guest room cannot
+  resume local code.
 - Steps are coalesced into ~2s batches to keep traffic light.
 - When a turn ends (`Stop`), the card settles to done. The next turn revives the
   same card — one card per session, not one per turn.
 - Up to 20 unique files touched are surfaced so reviewers can glance at the scope
   before the report card arrives.
 
-**Privacy:** project-level by default (only repos you opt into stream). Global
-kill switch: `HILOS_HOOKS=off`. The hook always exits 0 — it will never interrupt
-or break your CLI session.
+**Privacy:** project-level by default (only repos you opt into stream). Hook
+state stays in `~/.hilos/hook-state` and contains session ids, checkout paths,
+hilos message ids, progress steps, and any completed result waiting for a
+delivery retry — never the coding transcript. Kill
+switches: `HILOS_HOOKS=off` pauses streaming and new bindings;
+`HILOS_REPLY_BRIDGE=off` pauses inbound replies. The hook always exits 0 — it
+will never interrupt or break your CLI session.
 
 ## Security
 
@@ -271,10 +307,33 @@ hilos's GitHub App only for workspace owners/admins). Want a human checkpoint
 before anything is pushed? Set `"gate": true`. Keep your token in the config file
 or `HILOS_TOKEN`, never in shared shell history.
 
+### Run transcripts are opt-in
+
+The room gets what a teammate needs to see: a plan, live progress, a report, a
+PR. The coding tool's own stream is **not** part of that by default — the live
+card is an eight-step window and nothing keeps it after the run.
+
+Set `"uploadTranscripts": true` and the daemon, after posting its report, sends
+the tail of that run's stream to hilos, where it becomes the same transcript a
+hosted run gets: openable from the report card, readable only by workspace
+members, never by guests.
+
+It is off until you turn it on, because every other option here changes how work
+happens on your machine and this one moves bytes off it. When on: the last ~1 MB
+of the run, cut at a whole record; credentials redacted here before sending and
+again on arrival; a permission-gated run records its tool calls too, not just
+the assistant's prose; each round of an iterate appends to the previous round
+rather than replacing it; and the upload is never able to fail your run,
+whatever goes wrong with it.
+
+`HILOS_UPLOAD_TRANSCRIPTS=1` turns it on, `=0` forces it off, and either
+overrides the config file. Turning it off takes effect on the next run, with no
+restart — and **deleting** the key counts as off, not as "leave it as it was".
+
 ## Flags
 
 `--join <blob>` · `--channel <id>` · `--config <path>` · `--coding-cmd <cmd>` ·
 `--chat-cmd <cmd>` · `--once` · `--backfill` · `--no-gate` · `--help`
 
 Env: `HILOS_TOKEN`, `HILOS_URL`, `HILOS_CHANNEL`, `CODING_CMD`, `HILOS_ONCE=1`,
-`HILOS_BACKFILL=1`.
+`HILOS_BACKFILL=1`, `HILOS_UPLOAD_TRANSCRIPTS=1|0`.

package/bin/hilos-agent.mjs

@@ -44,7 +44,12 @@ function parseArgs(argv) {
     else if (a === "--once") flags.once = true;
     else if (a === "--backfill") flags.backfill = true;
     else if (a === "--no-gate") flags.gate = false;
+    else if (a === "--no-reply-bridge") flags.replyBridge = false;
     else if (a === "--global") flags.global = true;
+    else if (a === "--claude") flags.hookClient = "claude";
+    else if (a === "--codex") flags.hookClient = "codex";
+    else if (a === "--cursor") flags.hookClient = "cursor";
+    else if (a === "--vendor") flags.vendor = argv[++i];
     else if (a === "-h" || a === "--help") flags.help = true;
     else if (a === "-v" || a === "--version") flags.version = true;
     else positional.push(a);
@@ -57,10 +62,12 @@ const HELP = `hilos-agent — your coding agent as a teammate in hilos
   hilos-agent --join <blob>      connect using a link copied from hilos
   hilos-agent init               write a starter config to ~/.hilos/agent.json
   hilos-agent                    run the daemon (watch @mentions, propose diffs)
-  hilos-agent hooks install      stream this repo's Claude Code sessions to your
-                                 hilos channel (writes .claude/settings.json;
-                                 --global for every repo). "hooks print" shows
-                                 the snippet; HILOS_HOOKS=off pauses streaming.
+  hilos-agent hooks install      stream this repo's Codex, Claude, and Cursor
+                                 sessions to hilos and continue replies in the same
+                                 local session. Installs all three hook formats;
+                                 use --codex, --claude, or --cursor to choose, and
+                                 --global for every repo. HILOS_HOOKS=off pauses
+                                 streaming; HILOS_REPLY_BRIDGE=off pauses pickup.
 
 Options:
   --channel <id>     watch only one channel (per-channel override)
@@ -78,6 +85,7 @@ Options:
   --once             one poll then exit (cron-friendly)
   --backfill         also act on mentions that predate startup
   --no-gate          propose only; don't wait for approval / push
+  --no-reply-bridge  don't resume local sessions from replies in bound threads
   -v, --version      print the installed version
   -h, --help         this help
 
@@ -98,11 +106,11 @@ async function main() {
   // fast, silent, and always exit 0, so it short-circuits before any daemon
   // machinery.
   if (cmd === "hook") {
-    await hookMain();
+    await hookMain({ vendor: flags.vendor || "unknown" });
     return;
   }
   if (cmd === "hooks") {
-    hooksMain(positional[1], { global: Boolean(flags.global) });
+    hooksMain(positional[1], { global: Boolean(flags.global), client: flags.hookClient || "all" });
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.7.0",
+  "version": "0.9.1",
   "description": "Run your own coding agent (Claude Code / Codex / Cursor) as an autonomous teammate in a hilos channel. Picks up @mentions in channels and threads, makes the change, and opens a PR for review — your code and credentials never leave your machine. (Approve-before-push is available via gate:true.)",
   "type": "module",
   "bin": {