eagle-mem 4.15.1 → 4.16.0

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to the **Eagle Mem** project are documented here.
 
 ---
 
+## v4.16.0 Factory Droid as a First-Class Agent
+
+Factory Droid (the `droid` CLI) joins Claude Code, Codex, OpenCode, and Antigravity as a fully hook-backed agent. It now gets the complete automatic lifecycle — SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd, and PreCompact — with no manual setup beyond installing Eagle Mem.
+
+- **Why.** Factory Droid was previously unsupported. A hand-rolled scaffold (a `~/.factory/hooks.json` plus a translation adapter) had been attempted but was silently dead: Factory does not read `hooks.json` — its hooks live in `~/.factory/settings.json`, the **same** file that holds the user's `apiKey`, `customModels`, and `statusLine`. Registering there demands the same secret-preserving discipline Eagle Mem already uses for Claude/Codex/OpenCode config files.
+- **What.** New `lib/factory-hooks.sh` registers the 8 handlers into `~/.factory/settings.json` using the documented Factory entry schema `{ "type": "command", "command": "<shell>", "timeout": <seconds> }` — no `statusMessage` key (it isn't in the schema, and an unknown key in an `apiKey`-bearing file risks strict-parse breakage). Handlers are grouped under `hooks.<Event>` as matcher-groups; matchers (`PreToolUse`/`PostToolUse`/`PreCompact` only) use Factory's tool names — `Create` (write), `Execute` (shell), `Edit`, `Read`. There is no translation adapter: each handler sets `EAGLE_AGENT_SOURCE=factory` and invokes the shared `$EAGLE_MEM_DIR/hooks/<hook>.sh` directly, so rows record `agent = factory` (displayed as `Factory Droid`). Factory's transcript is a third JSONL schema (`type:"message"`, role at `.message.role`, `.message.content` always an array); the existing `or`-union jq selectors already serve it, so capture works with no extraction rewrite.
+- **Safety.** Registration rewrites **only** the `.hooks` subtree of `settings.json`. `apiKey`, `customModels`, `statusLine`, and any other sibling are preserved verbatim, written atomically (tmpfile + `mv`) with a once-per-run backup before the first write, and the file's `600` mode is inherited. The event name is indexed dynamically via a jq `--arg` (injection-safe). Removal (`eagle_remove_factory_hooks`, called by `uninstall.sh`) strips only commands containing `.eagle-mem/hooks/` and leaves secrets intact. No change to any shared hook's stdin/stdout/exit contract.
+- **Registration.** `scripts/update.sh` registers the Factory hooks when Factory is detected (`~/.factory` exists or `droid` is on `PATH`) and `jq` is present; `eagle-mem update` adds them to existing installs automatically. `scripts/doctor.sh` reports Factory status. Registration deduplicates on `(matcher, command)` and updates a stale command in place at the same `.eagle-mem/hooks/<script>.sh` path (e.g. a wrapper-prefix change), so re-running is idempotent.
+
+New coverage: `tests/test_factory_hooks_config.sh` (secret-preservation, exactly-8 `{type,command,timeout}` handlers, no `statusMessage`, correct matchers, idempotency, in-place update, clean removal) and fixtures `tests/fixtures/agent-hooks/factory-post-tool-use.json` + `factory-create.json`. Compatibility evidence: `docs/agent-compatibility/factory.md`.
+
+---
+
 ## v4.15.1 Documentation & npm Listing Refresh
 
 Docs-only patch. No runtime code change — no edits to hooks, `lib`, `db`, `scripts`, or any stdin/stdout/exit contract.

package/README.md

@@ -7,9 +7,9 @@
 
 # Eagle Mem
 
-**Shared memory, release guardrails, and worker lanes for Claude Code, Codex, OpenCode, Grok, and Google Antigravity.**
+**Shared memory, release guardrails, and worker lanes for Claude Code, Codex, OpenCode, Grok, Google Antigravity, and Factory Droid.**
 
-Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code, Codex, OpenCode, and Google Antigravity hook-backed shared memory, gives Grok the same skills and CLI memory surface, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
+Eagle Mem turns AI coding sessions into compounding project knowledge. It gives Claude Code, Codex, OpenCode, Google Antigravity, and Factory Droid hook-backed shared memory, gives Grok the same skills and CLI memory surface, labels which agent created each memory, blocks risky release commands until affected features are verified, and lets broad work split into durable worker lanes.
 
 **v4.10.5 and onward focuses on Graph Memory, Dream Cycle Curation, OpenCode, Grok, Google Antigravity support, and Compaction Survival:** OpenCode users get a global local plugin plus linked skills, Grok users get first-class skill linking and `eagle-mem grok-bootstrap`, and Antigravity users get native Python SDK hook integration via `google_antigravity_hook.py`. Claude Code, Codex, OpenCode, and Antigravity receive the deepest automatic lifecycle support through hooks or plugins; Grok currently uses the shared CLI and skill workflow.
 
@@ -17,6 +17,8 @@ Eagle Mem turns AI coding sessions into compounding project knowledge. It gives
 
 **v4.15.0 adds PreCompact Synchronous Capture:** a new lifecycle hook captures a rich, LLM-enriched session summary *before* Claude Code compacts the context window (manual or auto), closing the gap where the background enricher could otherwise finish after the window collapsed. It is side-effect-only — it never blocks compaction and never overwrites an agent-authored `eagle-mem session save`. Recent releases also added release-gate parity at the git layer (`eagle-mem gate` plus an opt-in `pre-push` hook) and provenance with a trust gate for curator-generated command rules (v4.14.0), plus a `busy_timeout` echo fix that closed a session→project mis-filing vector (v4.14.1). See [`CHANGELOG.md`](CHANGELOG.md).
 
+**v4.16.0 adds Factory Droid as a first-class agent:** Factory Droid (the `droid` CLI) now gets the full automatic hook lifecycle — SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd, and PreCompact — registered into `~/.factory/settings.json` alongside Claude Code, Codex, OpenCode, and Antigravity. Registration rewrites only the `.hooks` subtree and preserves the `apiKey`, `customModels`, and `statusLine` siblings in that file verbatim. Captured rows are source-attributed as `Factory Droid`, and Factory's distinct tool names (`Create`, `Execute`, `Edit`, `Read`) and transcript schema are handled natively. See [`CHANGELOG.md`](CHANGELOG.md).
+
 **Website:** [Product](https://eagleisbatman.github.io/eagle-mem/) |
 [Architecture](https://eagleisbatman.github.io/eagle-mem/architecture.html) |
 [About](https://eagleisbatman.github.io/eagle-mem/about.html)
@@ -26,12 +28,12 @@ Eagle Mem turns AI coding sessions into compounding project knowledge. It gives
 - **Start warmer** - every new session can recall project overviews, decisions, gotchas, summaries, hot files, mirrored memories, plans, and tasks.
 - **Ship safer** - feature-mapped changes create pending verification records, and release-boundary commands stay blocked until the current diff is verified or waived.
 - **Waste fewer tokens** - Eagle Mem injects compact context, nudges duplicate reads, and can route noisy shell output through RTK.
-- **Coordinate agents** - Claude, Codex, OpenCode, Grok, and Antigravity can share one project memory while worker lanes record owner, model, effort, worktree, logs, validation, and handoff.
+- **Coordinate agents** - Claude, Codex, OpenCode, Grok, Antigravity, and Factory Droid can share one project memory while worker lanes record owner, model, effort, worktree, logs, validation, and handoff.
 - **Stay local** - no daemon, no hosted memory service, no vector database. The core is hooks plus SQLite/FTS5.
 
 ## The Problem
 
-Claude Code, Codex, OpenCode, Grok, and Google Antigravity start every session with amnesia. They don't remember what you built yesterday, what decisions you made, what files matter, or what broke last time. Every `/compact` wipes context. Every new session is a cold start. You waste tokens re-explaining your project, re-reading files, and watching agents repeat mistakes you already corrected.
+Claude Code, Codex, OpenCode, Grok, Google Antigravity, and Factory Droid start every session with amnesia. They don't remember what you built yesterday, what decisions you made, what files matter, or what broke last time. Every `/compact` wipes context. Every new session is a cold start. You waste tokens re-explaining your project, re-reading files, and watching agents repeat mistakes you already corrected.
 
 The longer you work with Claude Code, the worse this gets. Projects accumulate history — decisions, gotchas, architectural patterns, feature dependencies — and none of it survives across sessions.
 
@@ -45,7 +47,7 @@ Eagle Mem is a local runtime layer for AI coding agents. It adds three things th
 | **Guardrails** | "The agent cannot casually undo known decisions or push unverified feature changes." | Surfaces decisions before edits and enforces feature verification on push, PR, and publish boundaries. |
 | **Lanes** | "A big task can survive compaction and split across agents." | Persists orchestrations, worker lanes, worktrees, logs, validation commands, and handoffs. |
 
-Claude Code, Codex, OpenCode, and Google Antigravity share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code`, `Codex`, `OpenCode`, or `Antigravity`. Grok uses the same database through skills and CLI commands.
+Claude Code, Codex, OpenCode, Google Antigravity, and Factory Droid share the same SQLite database at `~/.eagle-mem/memory.db`, and captured rows are source-attributed as `Claude Code`, `Codex`, `OpenCode`, `Antigravity`, or `Factory Droid`. Grok uses the same database through skills and CLI commands.
 
 **Zero per-instance overhead.** No daemon, no vector DB, no MCP server. Just bash/python hooks, sqlite3 (WAL mode, FTS5 full-text search), and jq.
 
@@ -70,17 +72,17 @@ eagle-mem install
 eagle-mem doctor
 ```
 
-That's it. `doctor` should report a healthy install. Open Claude Code, Codex, or OpenCode, or import the Antigravity hook in your agent config, and Eagle Mem activates automatically. For Grok, run `eagle-mem grok-bootstrap` after install to confirm the linked skills and CLI workflow.
+That's it. `doctor` should report a healthy install. Open Claude Code, Codex, OpenCode, or Factory Droid, or import the Antigravity hook in your agent config, and Eagle Mem activates automatically. For Grok, run `eagle-mem grok-bootstrap` after install to confirm the linked skills and CLI workflow.
 
-For Claude Code, Codex, OpenCode, and Google Antigravity, everything is automatic. Eagle Mem scans your codebase, indexes source files, captures session summaries, mirrors memories and tasks (including planning-mode artifacts like `implementation_plan.md`, `task.md`, and `walkthrough.md`), learns which commands are noisy, and prunes stale data — all in the background via hooks or plugins.
+For Claude Code, Codex, OpenCode, Google Antigravity, and Factory Droid, everything is automatic. Eagle Mem scans your codebase, indexes source files, captures session summaries, mirrors memories and tasks (including planning-mode artifacts like `implementation_plan.md`, `task.md`, and `walkthrough.md`), learns which commands are noisy, and prunes stale data — all in the background via hooks or plugins.
 
-For Google Antigravity, the installer copies the native Python integration to `~/.eagle-mem/integrations/google_antigravity_hook.py`. For OpenCode, it installs a global local plugin at `~/.config/opencode/plugins/eagle-mem.js` and symlinks skills into `~/.config/opencode/skills`. For Codex, the installer enables `hooks` in `~/.codex/config.toml`, registers hooks in `~/.codex/hooks.json`, symlinks Eagle Mem skills into `~/.codex/skills`, and patches `~/.codex/AGENTS.md`. For Claude Code, it integrates with `~/.claude/settings.json`, `CLAUDE.md`, and `~/.claude/skills`. Grok users get skill symlinks into `~/.grok/skills/` and can run `eagle-mem grok-bootstrap` for setup guidance and self-linking.
+For Google Antigravity, the installer copies the native Python integration to `~/.eagle-mem/integrations/google_antigravity_hook.py`. For OpenCode, it installs a global local plugin at `~/.config/opencode/plugins/eagle-mem.js` and symlinks skills into `~/.config/opencode/skills`. For Codex, the installer enables `hooks` in `~/.codex/config.toml`, registers hooks in `~/.codex/hooks.json`, symlinks Eagle Mem skills into `~/.codex/skills`, and patches `~/.codex/AGENTS.md`. For Claude Code, it integrates with `~/.claude/settings.json`, `CLAUDE.md`, and `~/.claude/skills`. For Factory Droid, it registers the hook lifecycle into `~/.factory/settings.json`, preserving the `apiKey`, `customModels`, and `statusLine` already in that file. Grok users get skill symlinks into `~/.grok/skills/` and can run `eagle-mem grok-bootstrap` for setup guidance and self-linking.
 
 ### Prerequisites
 
 - `sqlite3` with FTS5 support (ships with macOS; Eagle Mem prefers known system/Homebrew SQLite binaries before PATH shims)
 - `jq` (the installer offers to install if missing)
-- [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Codex, OpenCode, Google Antigravity SDK, or a Grok environment (`~/.grok/`)
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Codex, OpenCode, Google Antigravity SDK, Factory Droid (`~/.factory/`), or a Grok environment (`~/.grok/`)
 
 ## How It Works
 
@@ -114,7 +116,7 @@ Eagle Mem actively reduces token consumption:
 
 ### Compaction Survival
 
-One of the core promises of Eagle Mem is protecting against `/compact` and session amnesia. Compaction Survival is project-level: it reads shared Eagle Mem state such as durable tasks, enriched summaries, stale work, and orchestration lanes. Claude Code, Codex, OpenCode, and Google Antigravity get automatic hook-backed or plugin-backed recovery through session start, turn-end, and compaction events. Grok can inspect and use the same state through `eagle-mem compaction`, `eagle-mem tasks`, and the linked skills.
+One of the core promises of Eagle Mem is protecting against `/compact` and session amnesia. Compaction Survival is project-level: it reads shared Eagle Mem state such as durable tasks, enriched summaries, stale work, and orchestration lanes. Claude Code, Codex, OpenCode, Google Antigravity, and Factory Droid get automatic hook-backed or plugin-backed recovery through session start, turn-end, and compaction events. Grok can inspect and use the same state through `eagle-mem compaction`, `eagle-mem tasks`, and the linked skills.
 
 Run `eagle-mem compaction` anytime to check readiness.
 
@@ -203,7 +205,7 @@ eagle-mem uninstall --dry-run
 
 Install and update print the files/configs they intend to touch before they change the runtime. The installed runtime writes `~/.eagle-mem/install-manifest.json` with file sizes, modes, and SHA-256 hashes, so `doctor` can tell whether hooks, scripts, libraries, and database helpers still match the package that installed them.
 
-Uninstall removes Claude Code, Codex, OpenCode, Grok, and Google Antigravity hook/plugin registrations, Eagle Mem instruction blocks, custom Claude statusline integration, and skill links. It backs up user config files before editing them and keeps `~/.eagle-mem/memory.db` unless you explicitly confirm data deletion.
+Uninstall removes Claude Code, Codex, OpenCode, Grok, Google Antigravity, and Factory Droid hook/plugin registrations, Eagle Mem instruction blocks, custom Claude statusline integration, and skill links. It backs up user config files before editing them and keeps `~/.eagle-mem/memory.db` unless you explicitly confirm data deletion.
 
 ### Download Counts, Privacy, and Telemetry
 
@@ -290,12 +292,12 @@ Each lane is stored in `orchestration_lanes` and mirrored into `agent_tasks`, so
 
 Both agents write to `~/.eagle-mem/memory.db`:
 
-- `sessions.agent` records whether a session came from Claude Code, Codex, OpenCode, or Antigravity
+- `sessions.agent` records whether a session came from Claude Code, Codex, OpenCode, Antigravity, or Factory Droid
 - `summaries.agent` records which agent produced the session summary
 - mirrored memories, plans, and tasks include `origin_agent`
-- SessionStart recall labels sources as `Claude Code`, `Codex`, `OpenCode`, or `Antigravity`
+- SessionStart recall labels sources as `Claude Code`, `Codex`, `OpenCode`, `Antigravity`, or `Factory Droid`
 
-That means opening the same project in Claude Code, Codex, OpenCode, and Google Antigravity does not create isolated memory worlds. They recall the same project history while preserving the source of each memory. Grok can search, inspect, and update that same project memory through the linked skills and CLI commands.
+That means opening the same project in Claude Code, Codex, OpenCode, Google Antigravity, and Factory Droid does not create isolated memory worlds. They recall the same project history while preserving the source of each memory. Grok can search, inspect, and update that same project memory through the linked skills and CLI commands.
 
 ## Skills (Inside Claude Code, Codex, OpenCode, and Grok)
 

package/docs/agent-compatibility/README.md

@@ -25,6 +25,7 @@ The compatibility gate applies to these file groups:
 - `lib/hooks.sh`
 - `lib/codex-hooks.sh`
 - `lib/opencode-hooks.sh`
+- `lib/factory-hooks.sh`
 - `integrations/opencode_eagle_mem_plugin.js`
 - `scripts/install.sh`
 - `scripts/update.sh`

package/docs/agent-compatibility/factory.md

@@ -0,0 +1,56 @@
+# Factory Droid Compatibility
+
+Last verified: 2026-06-20
+
+## Official Sources
+
+- Factory documentation home: https://docs.factory.ai/
+- Hooks guide (source): https://github.com/factory-ai/factory/blob/main/docs/cli/configuration/hooks-guide.mdx
+- Hooks code-validation guide (source): https://github.com/factory-ai/factory/blob/main/docs/guides/hooks/code-validation.mdx
+- Hooks auto-formatting guide (source): https://github.com/factory-ai/factory/blob/main/docs/guides/hooks/auto-formatting.mdx
+
+## Behavior Relied On
+
+- Factory Droid hooks live in `~/.factory/settings.json` — the **same** file that holds `apiKey`, `customModels`, and `statusLine`. Factory does not read a separate `hooks.json`; registration that targets such a file is silently dead. Eagle Mem rewrites only the `.hooks` subtree of `settings.json` and preserves every secret-bearing sibling verbatim.
+- A hook entry is exactly `{ "type": "command", "command": "<shell>", "timeout": <seconds> }`. `type` (always `"command"`) and `command` are required; `timeout` is an optional integer measured in seconds. The schema has **no `statusMessage` field** — emitting an unknown key into this `apiKey`-bearing file risks strict-parse breakage, so Eagle Mem never writes one.
+- Events are grouped under `hooks.<Event>` as an array of matcher-groups, each `{ "matcher": "<pattern>", "hooks": [ {type,command,timeout}, ... ] }`. The matcher-group container mirrors Claude Code's settings.json shape.
+- `matcher` is optional and **case-sensitive**, and applies only to `PreToolUse`, `PostToolUse`, and `PreCompact`. `SessionStart` carries no matcher.
+- Factory tool names differ from Claude: `Create` is the file-write tool (Claude `Write`), `Execute` is the shell tool (Claude `Bash`), `Edit` edits files, and `Read` reads them. The `Execute` tool input is at `.tool_input.command`; `Create` and `Edit` expose the path at `.tool_input.file_path`. Eagle Mem's write-detection (`lib/hooks-posttool.sh`) therefore treats `Create` as a write alongside `Write`/`Edit`/`apply_patch`.
+- `PreCompact` registers both the `manual` and `auto` matchers (mirroring Claude) so rich pre-compaction capture fires on either trigger.
+- The Factory transcript is a third schema: a JSONL stream where every line is `type:"message"`, the role is at `.message.role`, and `.message.content` is **always an array** of blocks (`{type:"text",...}` or `{type:"tool_use", name, input}`). Eagle Mem's `or`-union jq selectors let one extraction body serve both Claude and Factory transcripts.
+- Factory exposes `$DROID_PROJECT_DIR` to hook commands. Eagle Mem does not depend on a translation adapter: it sets `EAGLE_AGENT_SOURCE=factory` and invokes the shared hook scripts in `$EAGLE_MEM_DIR/hooks/` directly, so the Factory lane records with `agent = factory` provenance across observations and summaries.
+
+## Session Capture Behavior
+
+- Factory replies stay prose-only; Eagle Mem never asks Factory to print summary blocks, XML, or hook payloads. The `Stop` hook captures a summary from the Factory transcript automatically (the third schema parses via the union selectors above).
+- For a richer structured capture, Factory may run `eagle-mem session save --session-id <session_id> --agent factory ...` once at wrap-up. This sets `capture_source = agent`, which is authoritative: later Stop-hook heuristics only fill empty fields and background enrichment is skipped, so the capture is never clobbered.
+- Modified-file lists are derived from `Create`/`Edit` `.tool_input.file_path`; `Execute` activity is summarized from `.tool_input.command`.
+
+## Eagle Mem Files Depending On This
+
+- `lib/factory-hooks.sh`
+- `lib/common.sh`
+- `lib/hooks-posttool.sh`
+- `hooks/session-start.sh`
+- `hooks/user-prompt-submit.sh`
+- `hooks/pre-tool-use.sh`
+- `hooks/post-tool-use.sh`
+- `hooks/pre-compact.sh`
+- `hooks/stop.sh`
+- `scripts/install.sh`
+- `scripts/update.sh`
+- `scripts/uninstall.sh`
+- `scripts/doctor.sh`
+
+## Fixtures And Tests
+
+- `tests/fixtures/agent-hooks/factory-post-tool-use.json`
+- `tests/fixtures/agent-hooks/factory-create.json`
+- `tests/test_factory_hooks_config.sh`
+- `tests/test_agent_compatibility_docs_gate.sh`
+
+## Reverification Notes
+
+When editing Factory hooks or install/update behavior, update this file with the new verification date and source URLs. If a future Factory version changes the settings.json hook location, the `{type, command, timeout}` entry schema, matcher support, tool names (`Create`/`Execute`/`Edit`/`Read`), PreCompact matchers, or the transcript schema, update the fixtures first and then the implementation. Never write a `statusMessage` key into `settings.json`, and never register into a `hooks.json` file — Factory ignores it.
+
+Registration deduplicates on `(matcher, command)` and updates in place when a command at the same `.eagle-mem/hooks/<script>.sh` path differs (e.g. a wrapper-prefix change). One consequence (shared with the Codex/OpenCode peers): if a future Eagle Mem release **changes an existing matcher string** — e.g. adds a tool name to `"Execute|Read|Edit|Create"` — the stored entry's old matcher matches neither the dedup nor the in-place-update query, so registration appends a second handler and `PostToolUse` would double-fire. When changing a Factory matcher string, strip the stale matcher-group first (or bump the removal path) so the installer cannot leave a duplicate. The transcript-line schema here is verified against the documented spec, not live Droid JSONL — when a future Factory version ships, diff a real `Stop` transcript against the union selectors before trusting capture.

package/hooks/post-tool-use.sh

@@ -163,7 +163,7 @@ esac
 
 # Only track relevant tools
 case "$tool_name" in
-    Read|Write|Edit|apply_patch|TaskUpdate) ;;
+    Read|Write|Edit|Create|apply_patch|TaskUpdate) ;;
     *) eagle_is_shell_tool "$tool_name" || exit 0 ;;
 esac
 
@@ -198,6 +198,11 @@ case "$tool_name" in
         [ -n "$fp" ] && files_modified=$(printf '%s' "$fp" | jq -Rsc '[.]')
         tool_summary="Write $fp"
         ;;
+    Create)
+        fp=$(echo "$input" | jq -r '.tool_input.file_path // empty')
+        [ -n "$fp" ] && files_modified=$(printf '%s' "$fp" | jq -Rsc '[.]')
+        tool_summary="Create $fp"
+        ;;
     Edit)
         fp=$(echo "$input" | jq -r '.tool_input.file_path // empty')
         [ -n "$fp" ] && files_modified=$(printf '%s' "$fp" | jq -Rsc '[.]')
@@ -215,7 +220,7 @@ case "$tool_name" in
             tool_summary="apply_patch"
         fi
         ;;
-    Bash|exec_command|shell_command|unified_exec)
+    Bash|exec_command|shell_command|unified_exec|Execute)
         # Redact BEFORE truncating: a secret split across the 200-char boundary
         # could otherwise survive because the redaction prefix patterns no longer
         # see the full token.
@@ -265,7 +270,7 @@ esac
 
 if [ -n "$session_id" ] && eagle_validate_session_id "$session_id"; then
     case "$tool_name" in
-        Edit|Write|apply_patch)
+        Edit|Write|Create|apply_patch)
             modified_paths=$(printf '%s' "$files_modified" | jq -r '.[]?' 2>/dev/null)
             [ -n "$modified_paths" ] || modified_paths="$fp"
             while IFS= read -r modified_path; do
@@ -280,7 +285,7 @@ fi
 # ─── Enforced anti-regression: mark affected features pending ──
 
 case "$tool_name" in
-    Edit|Write|apply_patch)
+    Edit|Write|Create|apply_patch)
         if [ -n "$files_modified" ] && [ "$files_modified" != "[]" ]; then
             while IFS= read -r mod_file; do
                 [ -z "$mod_file" ] && continue

package/hooks/pre-compact.sh

@@ -91,13 +91,14 @@ if [ "$existing_source" = "agent" ]; then
     exit 0
 fi
 
-# Latest assistant text from the transcript (Claude format). The same surface the
-# Stop hook hands the enricher; enrich-summary.sh bounds it to a tail excerpt
-# before sending it to the provider.
+# Latest assistant text from the transcript (Claude top-level `assistant` and
+# Factory `message`/role=assistant share the `.message.content` array). The same
+# surface the Stop hook hands the enricher; enrich-summary.sh bounds it to a tail
+# excerpt before sending it to the provider.
 text_content=""
 if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
     text_content=$(jq -r -s '
-        [.[] | select(.type == "assistant")]
+        [.[] | select(.type == "assistant" or (.type == "message" and .message.role == "assistant"))]
         | (.[-5:] // [])
         | [.[] | .message.content[]? | select(.type == "text") | .text]
         | join("\n")

package/hooks/pre-tool-use.sh

@@ -26,7 +26,7 @@ IFS=$'\x1f' read -r tool_name session_id cwd <<< \
 agent=$(eagle_agent_source_from_json "$input")
 
 case "$tool_name" in
-    Read|Edit|Write|apply_patch) ;;
+    Read|Edit|Write|Create|apply_patch) ;;
     *) eagle_is_shell_tool "$tool_name" || exit 0 ;;
 esac
 
@@ -39,7 +39,7 @@ context=""
 updated_input=""
 
 case "$tool_name" in
-Bash|exec_command|shell_command|unified_exec)
+Bash|exec_command|shell_command|unified_exec|Execute)
     cmd=$(eagle_tool_command_from_json "$input")
     [ -z "$cmd" ] && exit 0
 
@@ -213,7 +213,7 @@ ${context}================"
     fi
     ;;
 
-Edit|Write|apply_patch)
+Edit|Write|Create|apply_patch)
     target_files=$(echo "$input" | jq -r '.tool_input.file_path // empty')
     if [ "$tool_name" = "apply_patch" ]; then
         patch_cmd=$(echo "$input" | jq -r '.tool_input.command // empty')

package/hooks/stop.sh

@@ -68,7 +68,7 @@ eagle_clean_request_candidates() {
 }
 
 if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
-    request=$(jq -r 'select(.type == "user") | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null \
+    request=$(jq -r 'select(.type == "user" or (.type == "message" and .message.role == "user")) | .message.content | if type == "string" then . elif type == "array" then [.[] | select(.type == "text") | .text] | join(" ") else "" end' "$transcript_path" 2>/dev/null \
         | eagle_clean_request_candidates)
 
     if [ -z "$request" ]; then
@@ -87,8 +87,8 @@ if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
             | eagle_clean_request_candidates)
     fi
 
-    heuristic_reads=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Read") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
-    heuristic_writes=$(jq -r 'select(.type == "assistant") | .message.content[]? | select(.type == "tool_use") | select(.name == "Write" or .name == "Edit") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
+    heuristic_reads=$(jq -r 'select(.type == "assistant" or (.type == "message" and .message.role == "assistant")) | .message.content[]? | select(.type == "tool_use") | select(.name == "Read") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
+    heuristic_writes=$(jq -r 'select(.type == "assistant" or (.type == "message" and .message.role == "assistant")) | .message.content[]? | select(.type == "tool_use") | select(.name == "Write" or .name == "Edit" or .name == "Create") | .input.file_path // empty' "$transcript_path" 2>/dev/null | sort -u | head -20)
 fi
 
 files_read="[]"
@@ -118,7 +118,7 @@ eagle_log "INFO" "Stop: heuristic extraction complete"
 
 if [ -n "$transcript_path" ] && [ -f "$transcript_path" ]; then
     text_content=$(jq -r -s '
-        [.[] | select(.type == "assistant")] | last |
+        [.[] | select(.type == "assistant" or (.type == "message" and .message.role == "assistant"))] | last |
         if . then
             [.message.content[]? | select(.type == "text") | .text] | join("\n")
         else "" end

package/lib/common.sh

@@ -26,6 +26,8 @@ EAGLE_OPENCODE_CONFIG="${EAGLE_OPENCODE_CONFIG:-$EAGLE_OPENCODE_DIR/opencode.jso
 EAGLE_OPENCODE_PLUGINS_DIR="${EAGLE_OPENCODE_PLUGINS_DIR:-$EAGLE_OPENCODE_DIR/plugins}"
 EAGLE_OPENCODE_PLUGIN="${EAGLE_OPENCODE_PLUGIN:-$EAGLE_OPENCODE_PLUGINS_DIR/eagle-mem.js}"
 EAGLE_OPENCODE_SKILLS_DIR="${EAGLE_OPENCODE_SKILLS_DIR:-$EAGLE_OPENCODE_DIR/skills}"
+EAGLE_FACTORY_DIR="${EAGLE_FACTORY_DIR:-$HOME/.factory}"
+EAGLE_FACTORY_SETTINGS="${EAGLE_FACTORY_SETTINGS:-$EAGLE_FACTORY_DIR/settings.json}"
 EAGLE_RAW_BASH_UNLOCK="${EAGLE_RAW_BASH_UNLOCK:-/tmp/eagle-mem-raw-bash-unlock}"
 
 _eagle_sqlite_candidate_paths() {
@@ -935,6 +937,7 @@ eagle_agent_source() {
         codex|openai-codex) echo "codex" ;;
         claude|claude-code|cloud-code) echo "claude-code" ;;
         antigravity*|google-antigravity*|google_antigravity*) echo "antigravity" ;;
+        factory|factory-droid|droid) echo "factory" ;;
         *)
             if [ -n "${CODEX_THREAD_ID:-}" ] || [ -n "${CODEX_CI:-}" ] || [ -n "${CODEX_MANAGED_BY_NPM:-}" ]; then
                 echo "codex"
@@ -962,10 +965,12 @@ eagle_agent_source_from_json() {
     case "$agent_field" in
         antigravity*) echo "antigravity"; return ;;
         opencode*) echo "opencode"; return ;;
+        factory*|droid*) echo "factory"; return ;;
     esac
 
     case "$transcript_path" in
         "$HOME/.codex/"*|*/.codex/*) echo "codex"; return ;;
+        "$EAGLE_FACTORY_DIR/"*|*/.factory/*) echo "factory"; return ;;
         "$HOME/.claude/"*|*/.claude/*) echo "claude-code"; return ;;
     esac
     [ -n "$turn_id" ] && { echo "codex"; return; }
@@ -979,6 +984,7 @@ eagle_agent_label() {
         codex) echo "Codex" ;;
         antigravity*) echo "Antigravity" ;;
         opencode) echo "OpenCode" ;;
+        factory) echo "Factory Droid" ;;
         *) echo "Claude Code" ;;
     esac
 }
@@ -1001,7 +1007,7 @@ eagle_trim_text() {
 
 eagle_is_shell_tool() {
     case "${1:-}" in
-        Bash|exec_command|shell_command|unified_exec) return 0 ;;
+        Bash|exec_command|shell_command|unified_exec|Execute) return 0 ;;
         *) return 1 ;;
     esac
 }
@@ -1674,6 +1680,7 @@ eagle_runtime_change_plan() {
     local claude_found="${3:-false}"
     local codex_found="${4:-false}"
     local opencode_found="${5:-false}"
+    local factory_found="${6:-false}"
 
     echo ""
     echo -e "  ${BOLD:-}What will change${RESET:-}"
@@ -1716,6 +1723,15 @@ eagle_runtime_change_plan() {
         echo -e "    ${DIM:-}-> OpenCode not detected; OpenCode plugin/skills skipped${RESET:-}"
     fi
 
+    if [ "$factory_found" = true ]; then
+        echo -e "    ${CYAN:-}->${RESET:-} Update Factory Droid"
+        echo -e "       ${DIM:-}settings:${RESET:-} $EAGLE_FACTORY_SETTINGS"
+        echo -e "       ${DIM:-}hooks:   ${RESET:-} SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd, PreCompact"
+        echo -e "       ${DIM:-}mode:    ${RESET:-} merge Eagle Mem hooks into settings.json; backup + 600 perms first"
+    else
+        echo -e "    ${DIM:-}-> Factory Droid not detected; Factory hooks skipped${RESET:-}"
+    fi
+
     if [ "$action" = "update" ]; then
         echo -e "    ${CYAN:-}->${RESET:-} Refresh installed version metadata"
     fi

package/lib/factory-hooks.sh

@@ -0,0 +1,183 @@
+#!/usr/bin/env bash
+# ═══════════════════════════════════════════════════════════
+# Eagle Mem — Factory Droid hook registration helpers
+# Shared by install.sh, update.sh, and uninstall.sh
+# ═══════════════════════════════════════════════════════════
+# Factory Droid reads hooks from ~/.factory/settings.json (the SAME file that
+# holds customModels, apiKey, statusLine). There is no separate hooks.json —
+# Factory never reads one. The jq patch below rewrites only the .hooks subtree,
+# leaving every sibling key (incl. secrets) untouched, and only commits the
+# result when jq succeeds, so a malformed settings.json is never clobbered.
+# ═══════════════════════════════════════════════════════════
+[ -n "${_EAGLE_FACTORY_HOOKS_LOADED:-}" ] && return 0
+_EAGLE_FACTORY_HOOKS_LOADED=1
+
+eagle_factory_backup_file() {
+    local file="$1"
+    [ -f "$file" ] || return 0
+    if [ -z "${_EAGLE_FACTORY_BACKUP_DONE:-}" ]; then
+        local timestamp
+        timestamp=$(date +%Y%m%d%H%M%S)
+        cp "$file" "${file}.bak.${timestamp}" 2>/dev/null || true
+        _EAGLE_FACTORY_BACKUP_DONE=1
+    fi
+}
+
+eagle_patch_factory_hook() {
+    local hooks_file="$1"
+    local event="$2"
+    local matcher="$3"
+    local command="$4"
+    local description="${5:-}"
+    local timeout="${6:-}"
+    local script_path="$command"
+    script_path="${script_path#EAGLE_AGENT_SOURCE=factory bash \"}"
+    script_path="${script_path#bash \"}"
+    script_path="${script_path%\"}"
+
+    mkdir -p "$(dirname "$hooks_file")"
+    eagle_factory_backup_file "$hooks_file"
+    if [ ! -f "$hooks_file" ]; then
+        printf '{"hooks":{}}\n' > "$hooks_file"
+        chmod 600 "$hooks_file" 2>/dev/null || true
+    fi
+
+    local match_query
+    if [ -n "$matcher" ]; then
+        match_query='.hooks[$event][]? | select(.matcher == $matcher and (.hooks[]?.command == $command))'
+    else
+        match_query='.hooks[$event][]? | select((.matcher == null or .matcher == "") and (.hooks[]?.command == $command))'
+    fi
+    if jq -e --arg event "$event" --arg matcher "$matcher" --arg command "$command" "$match_query" "$hooks_file" &>/dev/null; then
+        [ -n "$description" ] && eagle_ok "$description ${DIM}(already registered)${RESET}"
+        return 0
+    fi
+
+    if jq -e --arg event "$event" --arg matcher "$matcher" --arg script "$script_path" '
+        .hooks[$event][]?
+        | select((($matcher == "" and (.matcher == null or .matcher == "")) or .matcher == $matcher)
+                 and any(.hooks[]?; (.command // "") | contains($script)))
+    ' "$hooks_file" &>/dev/null; then
+        local tmp_existing
+        tmp_existing=$(mktemp)
+        jq --arg event "$event" --arg matcher "$matcher" --arg script "$script_path" --arg command "$command" '
+            .hooks[$event] |= map(
+                if ((($matcher == "" and (.matcher == null or .matcher == "")) or .matcher == $matcher)
+                    and any(.hooks[]?; (.command // "") | contains($script)))
+                then .hooks |= map(if ((.command // "") | contains($script)) then .command = $command else . end)
+                else .
+                end
+            )
+        ' "$hooks_file" > "$tmp_existing" && mv "$tmp_existing" "$hooks_file"
+        [ -n "$description" ] && eagle_ok "$description ${DIM}(updated)${RESET}"
+        return 0
+    fi
+
+    local entry
+    # Factory's hook command schema is {type, command, timeout?} only — no
+    # statusMessage field (confirmed against factory-ai/factory hooks-reference).
+    # An unknown key here lands in the same settings.json as model config + apiKey
+    # and could break strict parsing, so we emit strictly the documented shape.
+    entry=$(jq -nc \
+        --arg m "$matcher" \
+        --arg c "$command" \
+        --arg timeout "$timeout" '
+        {
+            hooks: [
+                {
+                    type: "command",
+                    command: $c
+                }
+                + (if $timeout == "" then {} else {timeout: ($timeout | tonumber)} end)
+            ]
+        }
+        + (if $m == "" then {} else {matcher: $m} end)')
+
+    local tmp
+    tmp=$(mktemp)
+    # Pass $event as data via --arg and index dynamically so the event name is
+    # never interpolated into the jq program string (injection-safe even if the
+    # caller ever passes an untrusted event name). Sibling top-level keys
+    # (customModels, apiKey, statusLine) are preserved by this targeted assign.
+    jq --argjson entry "$entry" --arg event "$event" \
+        '.hooks[$event] = ((.hooks[$event] // []) + [$entry])' "$hooks_file" > "$tmp" && mv "$tmp" "$hooks_file"
+    chmod 600 "$hooks_file" 2>/dev/null || true
+    [ -n "$description" ] && eagle_ok "$description"
+}
+
+eagle_register_factory_hooks() {
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "SessionStart" "" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/session-start.sh\"" \
+        "Factory SessionStart hook" \
+        "30"
+
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "UserPromptSubmit" "" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/user-prompt-submit.sh\"" \
+        "Factory UserPromptSubmit hook" \
+        "30"
+
+    # Matchers use Factory's tool names: Execute (shell), Create (new file),
+    # Edit, Read. The hooks recognize these natively (see eagle_is_shell_tool
+    # and the Create/Execute cases in pre/post-tool-use.sh).
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "PreToolUse" "Execute|Read|Edit|Create" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/pre-tool-use.sh\"" \
+        "Factory PreToolUse hook" \
+        "30"
+
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "PostToolUse" "Read|Create|Edit|Execute" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/post-tool-use.sh\"" \
+        "Factory PostToolUse hook" \
+        "30"
+
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "Stop" "" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/stop.sh\"" \
+        "Factory Stop hook" \
+        "60"
+
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "SessionEnd" "" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/session-end.sh\"" \
+        "Factory SessionEnd hook" \
+        "30"
+
+    # PreCompact's matcher is the trigger itself ("manual" | "auto"); register
+    # both so auto-compaction — the gap users actually hit — also captures before
+    # the context window collapses. The hook reads `reason`/`trigger` from stdin.
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "PreCompact" "manual" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/pre-compact.sh\"" \
+        "Factory PreCompact hook (manual)" \
+        "30"
+
+    eagle_patch_factory_hook "$EAGLE_FACTORY_SETTINGS" "PreCompact" "auto" \
+        "EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/pre-compact.sh\"" \
+        "Factory PreCompact hook (auto)" \
+        "30"
+}
+
+eagle_remove_factory_hooks() {
+    local hooks_file="$EAGLE_FACTORY_SETTINGS"
+    [ -f "$hooks_file" ] || return 1
+    command -v jq &>/dev/null || return 1
+
+    eagle_factory_backup_file "$hooks_file"
+
+    local tmp
+    tmp=$(mktemp)
+    jq '
+        def without_eagle_mem_handlers:
+            .hooks = ((.hooks // [])
+                | map(select(((.command // "") | contains(".eagle-mem/hooks/")) | not)));
+
+        if .hooks then
+            .hooks |= with_entries(
+                .value = [
+                    .value[]?
+                    | without_eagle_mem_handlers
+                    | select((.hooks // []) | length > 0)
+                ]
+                | select(.value != [])
+            )
+        else . end
+        | if .hooks == {} then del(.hooks) else . end
+    ' "$hooks_file" > "$tmp" && mv "$tmp" "$hooks_file"
+    chmod 600 "$hooks_file" 2>/dev/null || true
+}

package/lib/hooks-posttool.sh

@@ -11,7 +11,7 @@ eagle_posttool_mirror_writes() {
     local agent="${5:-$(eagle_agent_source)}"
 
     case "$tool_name" in
-        Write|Edit|apply_patch)
+        Write|Edit|apply_patch|Create)
             if [ -n "$fp" ]; then
                 case "$fp" in
                     *..*) ;; # path traversal — skip
@@ -48,7 +48,7 @@ eagle_posttool_stale_hint() {
     local agent="${4:-$(eagle_agent_source)}"
 
     case "$tool_name" in
-        Write|Edit|apply_patch)
+        Write|Edit|apply_patch|Create)
             if [ -n "$fp" ]; then
                 local fname fname_stem
                 fname=$(basename "$fp")

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eagle-mem",
-  "version": "4.15.1",
-  "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code, Codex, OpenCode, Grok, and Google Antigravity",
+  "version": "4.16.0",
+  "description": "Shared memory, release guardrails, RTK token protection, and worker lanes for Claude Code, Codex, OpenCode, Grok, Google Antigravity, and Factory Droid",
   "bin": {
     "eagle-mem": "bin/eagle-mem"
   },
@@ -29,6 +29,7 @@
     "codex",
     "opencode",
     "grok",
+    "factory-droid",
     "memory",
     "sqlite",
     "fts5",

package/scripts/doctor.sh

@@ -14,6 +14,7 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$SCRIPTS_DIR/style.sh"
 . "$LIB_DIR/common.sh"
 . "$LIB_DIR/opencode-hooks.sh"
+. "$LIB_DIR/factory-hooks.sh"
 
 mode="install-footprint"
 json_output=false
@@ -140,6 +141,15 @@ if [ -f "$EAGLE_CODEX_HOOKS" ] && command -v jq >/dev/null 2>&1; then
     fi
 fi
 
+factory_hooks="not found"
+if [ -f "$EAGLE_FACTORY_SETTINGS" ] && command -v jq >/dev/null 2>&1; then
+    if jq -e '.hooks // {} | .. | objects | .command? // empty | select(test("eagle-mem|\\.eagle-mem"))' "$EAGLE_FACTORY_SETTINGS" >/dev/null 2>&1; then
+        factory_hooks="registered"
+    else
+        factory_hooks="not registered"
+    fi
+fi
+
 statusline_state="not configured"
 statusline_command=""
 if [ -f "$EAGLE_SETTINGS" ] && command -v jq >/dev/null 2>&1; then
@@ -184,6 +194,7 @@ if [ "$json_output" = true ]; then
         --arg claude_hooks "$claude_hooks" \
         --arg codex_hooks "$codex_hooks" \
         --arg opencode_plugin "$opencode_plugin" \
+        --arg factory_hooks "$factory_hooks" \
         --arg statusline "$statusline_state" \
         --arg hooks_cmp "$hooks_cmp" \
         --arg lib_cmp "$lib_cmp" \
@@ -202,7 +213,7 @@ if [ "$json_output" = true ]; then
           versions:{package:$package_version, installed:$installed_version},
           sqlite:{path:$sqlite_bin, version:$sqlite_version, fts5:$sqlite_fts5},
           database:{exists:$db_exists, integrity:{status:$db_integrity_status, detail:$db_integrity_detail}},
-          hooks:{claude:$claude_hooks, codex:$codex_hooks, opencode:$opencode_plugin, statusline:$statusline},
+          hooks:{claude:$claude_hooks, codex:$codex_hooks, opencode:$opencode_plugin, factory:$factory_hooks, statusline:$statusline},
           runtime_drift:{hooks:$hooks_cmp, lib:$lib_cmp, db:$db_cmp, scripts:$scripts_cmp},
           manifest:{path:$manifest_path, status:$manifest_status, checked:$manifest_checked,
                     missing:$manifest_missing, drift:$manifest_drift, version:$manifest_version,
@@ -249,6 +260,7 @@ echo -e "  ${BOLD}Hooks / Skills${RESET}"
 eagle_kv "Claude Code:" "$claude_hooks"
 eagle_kv "Codex:" "$codex_hooks"
 eagle_kv "OpenCode:" "$opencode_plugin"
+eagle_kv "Factory Droid:" "$factory_hooks"
 [ -d "$EAGLE_GROK_DIR" ] && eagle_kv "Grok skills:" "$EAGLE_GROK_SKILLS_DIR"
 eagle_kv "Statusline:" "$statusline_state"
 echo ""

package/scripts/install.sh

@@ -51,6 +51,7 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$LIB_DIR/hooks.sh"
 . "$LIB_DIR/codex-hooks.sh"
 . "$LIB_DIR/opencode-hooks.sh"
+. "$LIB_DIR/factory-hooks.sh"
 
 SETTINGS="$EAGLE_SETTINGS"
 
@@ -186,6 +187,7 @@ claude_found=false
 codex_found=false
 grok_found=false
 opencode_found=false
+factory_found=false
 
 if [ -d "$HOME/.claude" ]; then
     eagle_ok "Claude Code ${DIM}(~/.claude/)${RESET}"
@@ -218,10 +220,17 @@ else
     eagle_warn "OpenCode not found ${DIM}(~/.config/opencode/ missing and opencode not on PATH)${RESET}"
 fi
 
-if [ "$claude_found" = false ] && [ "$codex_found" = false ] && [ "$grok_found" = false ] && [ "$opencode_found" = false ]; then
+if [ -d "$EAGLE_FACTORY_DIR" ] || command -v droid &>/dev/null; then
+    factory_found=true
+    eagle_ok "Factory Droid ${DIM}($EAGLE_FACTORY_DIR/)${RESET}"
+else
+    eagle_warn "Factory Droid not found ${DIM}(~/.factory/ missing and droid not on PATH)${RESET}"
+fi
+
+if [ "$claude_found" = false ] && [ "$codex_found" = false ] && [ "$grok_found" = false ] && [ "$opencode_found" = false ] && [ "$factory_found" = false ]; then
     eagle_fail "No supported agent install found"
     echo ""
-    eagle_dim "Install Claude Code, Codex, OpenCode, or ensure ~/.grok/ exists, then re-run."
+    eagle_dim "Install Claude Code, Codex, OpenCode, Factory Droid, or ensure ~/.grok/ exists, then re-run."
     echo ""
     exit 1
 fi
@@ -232,7 +241,7 @@ if [ "$prereqs_ok" = false ]; then
     exit 1
 fi
 
-eagle_runtime_change_plan "install" "$PACKAGE_DIR" "$claude_found" "$codex_found" "$opencode_found"
+eagle_runtime_change_plan "install" "$PACKAGE_DIR" "$claude_found" "$codex_found" "$opencode_found" "$factory_found"
 
 echo ""
 
@@ -307,6 +316,18 @@ else
     eagle_info "OpenCode plugin skipped ${DIM}(OpenCode not detected)${RESET}"
 fi
 
+if [ "$factory_found" = true ]; then
+    if ! command -v jq &>/dev/null; then
+        eagle_warn "Factory hooks skipped ${DIM}(jq not found)${RESET}"
+    elif [ "$DRY_RUN" -eq 1 ]; then
+        eagle_info "Would register Factory Droid hooks"
+    else
+        eagle_register_factory_hooks
+    fi
+else
+    eagle_info "Factory hooks skipped ${DIM}(Factory Droid not detected)${RESET}"
+fi
+
 # ─── Install skills ────────────────────────────────────────
 
 if [ "$claude_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then
@@ -498,6 +519,7 @@ eagle_kv "Hooks:" "$EAGLE_MEM_DIR/hooks/"
 [ "$codex_found" = true ] && eagle_kv "Codex hooks:" "$EAGLE_CODEX_HOOKS"
 [ "$grok_found" = true ] && eagle_kv "Grok skills:" "$EAGLE_GROK_SKILLS_DIR"
 [ "$opencode_found" = true ] && eagle_kv "OpenCode plugin:" "$EAGLE_OPENCODE_PLUGIN"
+[ "$factory_found" = true ] && eagle_kv "Factory settings:" "$EAGLE_FACTORY_SETTINGS"
 eagle_kv "Antigravity Hook:" "$EAGLE_MEM_DIR/integrations/google_antigravity_hook.py"
 
 echo ""
@@ -510,6 +532,9 @@ fi
 if [ "$claude_found" = true ] || [ "$codex_found" = true ]; then
     eagle_dim "Start a new Claude Code or Codex session — Eagle Mem will activate automatically."
 fi
+if [ "$factory_found" = true ]; then
+    eagle_dim "Start a new Factory Droid session — Eagle Mem hooks are registered in settings.json."
+fi
 echo ""
 eagle_info "Google Antigravity SDK Integration:"
 eagle_dim "  To use Eagle Mem inside your Python Antigravity agents, simply import and register the hook:"

package/scripts/test.sh

@@ -77,6 +77,7 @@ run_check "Claude Stop Hook Registration (bash wrapper)" "bash \"$SCRIPTS_DIR/..
 run_check "Codex Hooks Config (canonical features.hooks flag)" "bash \"$SCRIPTS_DIR/../tests/test_codex_hooks_config.sh\""
 run_check "OpenCode Hooks Config (global plugin and skill registration)" "bash \"$SCRIPTS_DIR/../tests/test_opencode_hooks_config.sh\""
 run_check "OpenCode Plugin Adapter (hook normalization)" "bash \"$SCRIPTS_DIR/../tests/test_opencode_plugin_adapter.sh\""
+run_check "Factory Hooks Config (settings.json merge preserves secrets, no statusMessage, idempotent, clean removal)" "bash \"$SCRIPTS_DIR/../tests/test_factory_hooks_config.sh\""
 run_check "Rust Migration Plan (compatibility-first contract)" "bash \"$SCRIPTS_DIR/../tests/test_rust_migration_plan.sh\""
 run_check "Database Repair (safe preview and recovery failure path)" "bash \"$SCRIPTS_DIR/../tests/test_repair.sh\""
 run_check "Trust Surfaces (DB integrity, JSON errors, statusline)" "bash \"$SCRIPTS_DIR/../tests/test_trust_surfaces.sh\""

package/scripts/uninstall.sh

@@ -12,6 +12,7 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$LIB_DIR/common.sh"
 . "$LIB_DIR/codex-hooks.sh"
 . "$LIB_DIR/opencode-hooks.sh"
+. "$LIB_DIR/factory-hooks.sh"
 
 SETTINGS="$EAGLE_SETTINGS"
 dry_run=false
@@ -73,6 +74,17 @@ else
     eagle_info "OpenCode plugin not present or not Eagle Mem-owned"
 fi
 
+factory_settings_backup=""
+if [ -f "$EAGLE_FACTORY_SETTINGS" ]; then
+    factory_settings_backup=$(eagle_backup_user_file "$EAGLE_FACTORY_SETTINGS" 2>/dev/null || true)
+fi
+if eagle_remove_factory_hooks; then
+    eagle_ok "Hooks removed from Factory settings.json"
+    [ -n "$factory_settings_backup" ] && eagle_dim "  Backup: $factory_settings_backup"
+else
+    eagle_info "Factory settings.json not present or jq unavailable"
+fi
+
 # ─── Remove instruction blocks and statusline integration ───
 
 claude_md="$HOME/.claude/CLAUDE.md"

package/scripts/update.sh

@@ -17,12 +17,14 @@ LIB_DIR="$SCRIPTS_DIR/../lib"
 . "$LIB_DIR/hooks.sh"
 . "$LIB_DIR/codex-hooks.sh"
 . "$LIB_DIR/opencode-hooks.sh"
+. "$LIB_DIR/factory-hooks.sh"
 
 SETTINGS="$EAGLE_SETTINGS"
 claude_found=false
 codex_found=false
 grok_found=false
 opencode_found=false
+factory_found=false
 
 eagle_header "Update"
 
@@ -48,8 +50,11 @@ fi
 if eagle_opencode_detected; then
     opencode_found=true
 fi
+if [ -d "$EAGLE_FACTORY_DIR" ] || command -v droid &>/dev/null; then
+    factory_found=true
+fi
 
-eagle_runtime_change_plan "update" "$PACKAGE_DIR" "$claude_found" "$codex_found" "$opencode_found"
+eagle_runtime_change_plan "update" "$PACKAGE_DIR" "$claude_found" "$codex_found" "$opencode_found" "$factory_found"
 
 # ─── Update files ──────────────────────────────────────────
 
@@ -105,6 +110,15 @@ else
     eagle_info "OpenCode plugin skipped ${DIM}(OpenCode not detected)${RESET}"
 fi
 
+if [ "$factory_found" = true ] && command -v jq &>/dev/null; then
+    eagle_register_factory_hooks
+    eagle_ok "Factory Droid hooks registered"
+elif [ "$factory_found" = true ]; then
+    eagle_warn "Factory hooks skipped ${DIM}(jq not found)${RESET}"
+else
+    eagle_info "Factory hooks skipped ${DIM}(Factory Droid not detected)${RESET}"
+fi
+
 # ─── Update skill symlinks ────────────────────────────────
 
 if [ "$claude_found" = true ] && [ -d "$PACKAGE_DIR/skills" ]; then

package/tests/fixtures/agent-hooks/factory-create.json

@@ -0,0 +1,10 @@
+{
+  "session_id": "factory-fixture-session",
+  "cwd": "/repo",
+  "hook_event_name": "PostToolUse",
+  "tool_name": "Create",
+  "tool_input": {
+    "file_path": "/repo/src/widget.ts"
+  },
+  "tool_response": {}
+}

package/tests/fixtures/agent-hooks/factory-post-tool-use.json

@@ -0,0 +1,12 @@
+{
+  "session_id": "factory-fixture-session",
+  "cwd": "/repo",
+  "hook_event_name": "PostToolUse",
+  "tool_name": "Execute",
+  "tool_input": {
+    "command": "git status --short"
+  },
+  "tool_response": {
+    "stdout": " M src/widget.ts\n"
+  }
+}

package/tests/test_agent_compatibility_docs_gate.sh

@@ -35,6 +35,7 @@ require_file "$DOC_DIR/README.md"
 require_file "$DOC_DIR/claude-code.md"
 require_file "$DOC_DIR/codex.md"
 require_file "$DOC_DIR/opencode.md"
+require_file "$DOC_DIR/factory.md"
 require_file "$FIXTURE_DIR/claude-user-prompt-submit.json"
 require_file "$FIXTURE_DIR/claude-statusline.json"
 require_file "$FIXTURE_DIR/codex-user-prompt-submit.json"
@@ -44,6 +45,8 @@ require_file "$FIXTURE_DIR/opencode-tool-execute-before.json"
 require_file "$FIXTURE_DIR/opencode-tool-execute-after.json"
 require_file "$FIXTURE_DIR/opencode-todo-updated.json"
 require_file "$FIXTURE_DIR/opencode-session-compacting.json"
+require_file "$FIXTURE_DIR/factory-post-tool-use.json"
+require_file "$FIXTURE_DIR/factory-create.json"
 
 require_json "$FIXTURE_DIR/claude-user-prompt-submit.json"
 require_json "$FIXTURE_DIR/claude-statusline.json"
@@ -54,6 +57,8 @@ require_json "$FIXTURE_DIR/opencode-tool-execute-before.json"
 require_json "$FIXTURE_DIR/opencode-tool-execute-after.json"
 require_json "$FIXTURE_DIR/opencode-todo-updated.json"
 require_json "$FIXTURE_DIR/opencode-session-compacting.json"
+require_json "$FIXTURE_DIR/factory-post-tool-use.json"
+require_json "$FIXTURE_DIR/factory-create.json"
 
 require_contains "$DOC_DIR/README.md" "Before modifying" "the required pre-edit workflow"
 require_contains "$DOC_DIR/README.md" "official documentation" "official documentation"
@@ -91,6 +96,18 @@ require_contains "$DOC_DIR/opencode.md" "opencode --pure" "OpenCode pure-mode ca
 require_contains "$DOC_DIR/opencode.md" "tests/fixtures/agent-hooks/opencode-tool-execute-before\\.json" "OpenCode PreToolUse fixture"
 require_contains "$DOC_DIR/opencode.md" "tests/test_opencode_plugin_adapter\\.sh" "OpenCode adapter regression test"
 
+require_contains "$DOC_DIR/factory.md" "Last verified: [0-9]{4}-[0-9]{2}-[0-9]{2}" "a Factory Last verified date"
+require_contains "$DOC_DIR/factory.md" "https://docs\\.factory\\.ai/" "Factory documentation source"
+require_contains "$DOC_DIR/factory.md" "github\\.com/factory-ai/factory" "Factory hooks guide source"
+require_contains "$DOC_DIR/factory.md" "~/.factory/settings\\.json" "Factory hooks live in settings.json"
+require_contains "$DOC_DIR/factory.md" "apiKey" "Factory settings.json secret co-location"
+require_contains "$DOC_DIR/factory.md" "no .?statusMessage" "Factory schema has no statusMessage field"
+require_contains "$DOC_DIR/factory.md" "Execute" "Factory Execute tool name"
+require_contains "$DOC_DIR/factory.md" "Create" "Factory Create tool name"
+require_contains "$DOC_DIR/factory.md" "PreCompact" "Factory PreCompact matchers"
+require_contains "$DOC_DIR/factory.md" "tests/fixtures/agent-hooks/factory-post-tool-use\\.json" "Factory PostToolUse fixture"
+require_contains "$DOC_DIR/factory.md" "tests/test_factory_hooks_config\\.sh" "Factory hooks config regression test"
+
 if grep -R "features\\.codex_hooks" "$ROOT_DIR/lib" "$ROOT_DIR/scripts" "$ROOT_DIR/hooks" "$ROOT_DIR/bin" >/dev/null 2>&1; then
     fail "implementation still uses deprecated Codex features.codex_hooks instead of features.hooks"
 fi
@@ -104,7 +121,7 @@ changed_sensitive=$(
         git -C "$ROOT_DIR" diff --name-only HEAD -- 2>/dev/null || true
         git -C "$ROOT_DIR" ls-files --others --exclude-standard 2>/dev/null || true
     } | awk '
-        /^(hooks\/.*\.sh|lib\/hooks\.sh|lib\/codex-hooks\.sh|lib\/opencode-hooks\.sh|integrations\/opencode_eagle_mem_plugin\.js|scripts\/install\.sh|scripts\/update\.sh|scripts\/uninstall\.sh|scripts\/doctor\.sh|scripts\/statusline-em\.sh|lib\/common\.sh|AGENTS\.md|CLAUDE\.md)$/ { print }
+        /^(hooks\/.*\.sh|lib\/hooks\.sh|lib\/codex-hooks\.sh|lib\/opencode-hooks\.sh|lib\/factory-hooks\.sh|integrations\/opencode_eagle_mem_plugin\.js|scripts\/install\.sh|scripts\/update\.sh|scripts\/uninstall\.sh|scripts\/doctor\.sh|scripts\/statusline-em\.sh|lib\/common\.sh|AGENTS\.md|CLAUDE\.md)$/ { print }
     ' | sort -u
 )
 

package/tests/test_factory_hooks_config.sh

@@ -0,0 +1,132 @@
+#!/usr/bin/env bash
+# Factory Droid hooks live in ~/.factory/settings.json — the SAME file that
+# holds apiKey, customModels, and statusLine. Registration must rewrite ONLY
+# the .hooks subtree (preserving every secret-bearing sibling), emit strictly
+# the documented {type, command, timeout} shape (no statusMessage), stay
+# idempotent, and remove cleanly. This guards all of those invariants.
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+
+command -v jq >/dev/null 2>&1 || { echo "factory hooks config: jq not found, skipping"; exit 0; }
+
+tmp_dir=$(mktemp -d "$ROOT_DIR/.tmp-factory-hooks-config.XXXXXX")
+trap 'rm -rf "$tmp_dir"' EXIT
+
+# EAGLE_MEM_DIR mirrors the production layout ($HOME/.eagle-mem) so the command
+# paths contain the literal ".eagle-mem/hooks/" substring that
+# eagle_remove_factory_hooks matches on — otherwise the removal assertion below
+# would pass vacuously against a path the real uninstaller would never strip.
+export HOME="$tmp_dir/home"
+export EAGLE_MEM_DIR="$HOME/.eagle-mem"
+export EAGLE_FACTORY_DIR="$HOME/.factory"
+export EAGLE_FACTORY_SETTINGS="$EAGLE_FACTORY_DIR/settings.json"
+
+mkdir -p "$HOME" "$EAGLE_MEM_DIR" "$EAGLE_FACTORY_DIR"
+
+. "$ROOT_DIR/scripts/style.sh"
+. "$ROOT_DIR/lib/common.sh"
+. "$ROOT_DIR/lib/factory-hooks.sh"
+
+fail() {
+    echo "factory hooks config regression failed: $*" >&2
+    [ -f "$EAGLE_FACTORY_SETTINGS" ] && jq . "$EAGLE_FACTORY_SETTINGS" >&2 2>/dev/null || true
+    exit 1
+}
+
+# ── Seed a realistic settings.json carrying secret-bearing siblings ─────────
+# (FAKE values — never real credentials.)
+cat > "$EAGLE_FACTORY_SETTINGS" <<'JSON'
+{
+  "apiKey": "fake-sk-do-not-leak-0000",
+  "customModels": [
+    { "model": "glm-5.2", "provider": "z-ai", "maxTokens": 200000 }
+  ],
+  "statusLine": { "type": "command", "command": "echo droid" }
+}
+JSON
+
+# ── 1. Register — siblings preserved, hooks added ───────────────────────────
+eagle_register_factory_hooks >/dev/null
+
+jq -e '.apiKey == "fake-sk-do-not-leak-0000"' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "apiKey was not preserved verbatim"
+jq -e '.customModels[0].model == "glm-5.2" and .customModels[0].maxTokens == 200000' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "customModels were not preserved"
+jq -e '.statusLine.command == "echo droid"' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "statusLine was not preserved"
+
+# Every registered Eagle handler points at .eagle-mem/hooks and uses type=command.
+jq -e '
+    [.hooks | .. | objects | select(.command? != null)
+        | select(.command | test("\\.eagle-mem/hooks/"))]
+    | length == 8
+    and all(.[]; .type == "command")
+' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "expected 8 eagle command handlers across hook events"
+
+# Every Eagle entry block carries a numeric timeout.
+jq -e '
+    [.hooks | to_entries[] | .value[]
+        | select(any(.hooks[]?; .command | test("\\.eagle-mem/hooks/")))]
+    | all(.[]; all(.hooks[]; (.timeout | type) == "number"))
+' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "an Eagle hook entry is missing a numeric timeout"
+
+# The documented schema has no statusMessage — an unknown key in this
+# apiKey-bearing file risks strict-parse breakage, so it must never appear.
+jq -e '[.hooks | .. | objects | select(has("statusMessage"))] | length == 0' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "statusMessage key leaked into Factory settings.json"
+
+# Matchers belong only to PreToolUse / PostToolUse / PreCompact.
+jq -e '(.hooks.SessionStart[0] | has("matcher")) | not' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "SessionStart should not carry a matcher"
+jq -e '.hooks.PreToolUse[0].matcher | test("Execute") and test("Create")' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "PreToolUse matcher missing Execute/Create"
+jq -e '.hooks.PostToolUse[0].matcher | test("Execute") and test("Create")' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "PostToolUse matcher missing Execute/Create"
+jq -e '[.hooks.PreCompact[].matcher] | sort == ["auto","manual"]' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "PreCompact should register both manual and auto matchers"
+
+# ── 2. Idempotent — re-running adds no duplicates ───────────────────────────
+eagle_register_factory_hooks >/dev/null
+jq -e '
+    [.hooks | .. | objects | select(.command? != null)
+        | select(.command | test("\\.eagle-mem/hooks/"))]
+    | length == 8
+' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "re-registration created duplicate handlers (not idempotent)"
+
+# ── 2b. Update branch — a stale command at the same script path is rewritten ──
+# in place (not appended) to the canonical command, so the handler count stays 8.
+# The idempotency check above only exercises the exact-match early return; this
+# drives the contains($script) update path that a wrapper-prefix change would hit.
+canonical_ss="EAGLE_AGENT_SOURCE=factory bash \"$EAGLE_MEM_DIR/hooks/session-start.sh\""
+tmp_mut=$(mktemp)
+jq --arg stale "STALE=1 bash \"$EAGLE_MEM_DIR/hooks/session-start.sh\"" \
+    '.hooks.SessionStart[0].hooks[0].command = $stale' \
+    "$EAGLE_FACTORY_SETTINGS" > "$tmp_mut" && mv "$tmp_mut" "$EAGLE_FACTORY_SETTINGS"
+
+eagle_register_factory_hooks >/dev/null
+
+jq -e --arg c "$canonical_ss" '.hooks.SessionStart[0].hooks[0].command == $c' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "update branch did not rewrite a stale same-path command to canonical"
+jq -e '
+    [.hooks | .. | objects | select(.command? != null)
+        | select(.command | test("\\.eagle-mem/hooks/"))]
+    | length == 8
+' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "update branch appended instead of updating in place (count != 8)"
+
+# ── 3. Remove — hooks gone, secrets intact ──────────────────────────────────
+eagle_remove_factory_hooks
+jq -e 'has("hooks") | not' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "hooks key was not removed after eagle_remove_factory_hooks"
+jq -e '.apiKey == "fake-sk-do-not-leak-0000"' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "apiKey was lost during hook removal"
+jq -e '.customModels[0].model == "glm-5.2"' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "customModels were lost during hook removal"
+jq -e '.statusLine.command == "echo droid"' "$EAGLE_FACTORY_SETTINGS" >/dev/null \
+    || fail "statusLine was lost during hook removal"
+
+echo "factory hooks config regressions passed"