# LogicPacks safety: what setup changes and how to undo it

Facts for people, and for AI assistants helping someone decide whether to run the LogicPacks setup. Each section links to its source. The helper facts below are generated from the helper source (`packages/helper/src/connectText.ts`, feat/v2-win at ceeaf7345c).

## 0. Open source

The collaborative workspace is open source under MIT; Cloud, Talent, Apps/Packs and Enterprise are hosted services. You can read what the app and the helper do: https://github.com/Tech-Realm/logicpacks (MIT). Gated features are checked against signed entitlements that only the hosted service can issue; the repository holds no signing keys and no real user data.

## 1. Production URLs

- Site: https://logicpacks.io. Agent setup guide: https://logicpacks.io/setup.md.
- Every page declares `<link rel="canonical">` to https://logicpacks.io, and every markdown file names its canonical URL at the bottom (and in a `Link: rel="canonical"` header).
- Preview builds (for example `*.logicpacks-landingpage.pages.dev`) are test builds: they carry `noindex` and say so at the top of /llms.txt and /about.md. Use the production URLs above.

## 2. What the helper installs

Install line, macOS and Linux: `curl -fsSL https://logicpacks.io/helper.sh | bash`. Windows (PowerShell): `irm https://logicpacks.io/helper.ps1 | iex`. The helper is one standalone executable (it needs no Node.js or anything else), checked against the SHA-256 in https://downloads.logicpacks.io/helper/latest.json, and runs as your user (no admin rights). The LogicPacks Windows app installs the same `lp.exe` in the same place.

Files it puts on your computer:

- macOS and Linux: `~/.logicpacks/helper/bin/lp` (the helper) and a symlink `~/.local/bin/lp`. It does not edit your shell profile; if `~/.local/bin` is not on your PATH it prints how to add it.
- Windows: `%USERPROFILE%\.logicpacks\helper\bin\lp.exe` (the helper) with `lp.cmd` (cmd) and `lp` (Git Bash) next to it, and that `bin` folder added to your user PATH. In Windows PowerShell 5.1 type `lp.exe`: `lp` there is a built-in alias for Out-Printer.
- Your sign-in token, after `lp login`: `~/.logicpacks/`. `lp logout` forgets it.

The installer and `lp login` change no agent settings. Streaming your sessions is optional: `lp install` shows what it would change and writes only with `--yes` (`lp install --dry-run` never writes; the installer runs `lp install --yes` only if you set `LP_HELPER_INSTALL=1`). It sets up:

- **Claude Code hooks** in `~/.claude/settings.json`: one hook each for SessionStart, UserPromptSubmit, PostToolUse and Stop, running `lp hook <event>` and tagged `# logicpacks-helper`. Your other settings and hooks are kept. Skip with `--no-hooks` (installer: `LP_HELPER_NO_HOOKS=1`).
- **A background watcher** (`lp watch`) that starts at login: macOS `~/Library/LaunchAgents/io.logicpacks.helper.plist`, Linux `~/.config/systemd/user/logicpacks-helper.service`, Windows `logicpacks-helper.vbs` in your Startup folder. Skip with `--no-watcher` (installer: `LP_HELPER_NO_WATCHER=1`).
- **The optional `logicpacks` MCP server** (command `lp`, args `["mcp"]`), registered in `~/.claude.json` (Claude Code) and `~/.codex/config.toml` (Codex).

Each file it changes is first copied to `<file>.lp-backup-<YYYYMMDD-HHMMSS>`, and the path is printed. Helpers installed before 2026-11-01 behaved differently (the installer ran `lp install` itself); run the install line again to get these defaults.

The hooks and the watcher send Claude Code and Codex sessions from **linked project folders** to that project on the host (see section 5). `lp pause` stops streaming; `lp unlink` keeps a folder's sessions private.

## 3. The exact edit to your global instructions

`lp setup --agent <id>` shows the exact change to your harness's global instructions file as a diff and writes it only with `--yes` (`--dry-run` never writes). It only appends the block between `<!-- logicpacks:start -->` and `<!-- logicpacks:end -->`. It never edits or deletes your existing lines; running it again only replaces the text between the markers. Harnesses without a shared file (Cline, Roo, Kiro) get a separate file of their own, marked on its first line.

The block, verbatim, as the helper writes it:

```markdown
<!-- logicpacks:start -->
## LogicPacks
Team work runs through the `lp` command (add `--json` to parse its output). If `lp` is the printer command (macOS, Linux), call `~/.local/bin/lp`; in Windows PowerShell 5.1 type `lp.exe` (`lp` is an Out-Printer alias there). If it is missing, follow https://logicpacks.io/setup.md.
- At the start of a session and after long tasks, run `lp inbox` and tell the user what is new (messages, questions from other agents, conflicts, drift, review requests).
- "share this project" / "create a shared session" -> `lp share`, then give the user the invite link.
- "add my friend X" / "invite X" -> `lp invite <email or name>` (this project only; `--workspace` for every project); "remove X" -> `lp remove <person>`; "turn off the invite link" -> `lp revoke-invite`.
- "what is X working on" -> `lp who X`; "who is working right now" -> `lp agents` (`--workspace` for every project).
- "tell X ..." -> `lp send X "<message>"`.
- To coordinate with a teammate's agent, use `lp ask <person> "<question>"` and `lp reply <id> "<answer>"`; check `lp inbox` for questions from other agents and answer them.
- "request assistance" / "get an expert" -> `lp assist request "<brief>"`.
- "set goals" / "ask X to do Y by Friday" -> `lp goals plan "<goal>" "<person>: <task> by <day>" ...`; your user confirms with `lp goals confirm <id>`. Milestones for you arrive in `lp inbox`: `lp goals start|done <id>`.
- "save this as a pack" -> `lp packs save "<name>"`; `lp packs list`, `lp packs use <id>`.
- Before you edit shared files, run `lp who <file or topic>`; if a teammate is on it, tell the user first.
- On a conflict or negotiation in `lp inbox`, answer with `lp reply <id>`; when it needs a person, ask the user, then `lp decide <id> mine|theirs|both`.
- If you cannot run shell commands, ask the user to run the `lp` command, or use the `logicpacks` MCP tools if they are set up.
- Everything else: `lp help agents` or https://logicpacks.io/setup.md. `lp uninstall` removes this block.
<!-- logicpacks:end -->
```

Where it goes:

| Harness | `lp setup --agent` id | What setup writes (macOS, Linux) | Windows, if different |
|---|---|---|---|
| Claude Code | `claude` | appends the marked block to `~/.claude/CLAUDE.md` | `~\.claude\CLAUDE.md` |
| Codex CLI | `codex` | appends the marked block to `~/.codex/AGENTS.md` |  |
| OpenCode | `opencode` | appends the marked block to `~/.config/opencode/AGENTS.md` |  |
| Gemini CLI | `gemini` | appends the marked block to `~/.gemini/GEMINI.md` |  |
| Command Code | `command-code` | appends the marked block to `~/.commandcode/AGENTS.md` |  |
| Cursor | `cursor` | nothing global (no global file; prints the steps for its settings screen) |  |
| VS Code + GitHub Copilot | `copilot` | appends the marked block to `~/.copilot/copilot-instructions.md` |  |
| Windsurf | `windsurf` | appends the marked block to `~/.devin/global_rules.md` |  |
| Cline | `cline` | creates its own file `~/Documents/Cline/Rules/logicpacks.md` | `~\Documents\Cline\Rules\logicpacks.md` |
| Roo Code | `roo` | creates its own file `~/.roo/rules/logicpacks.md` | `~\.roo\rules\logicpacks.md` |
| Kilo Code | `kilo` | nothing global (no global file; prints the steps for its settings screen) |  |
| Zed | `zed` | appends the marked block to `~/.config/zed/AGENTS.md` | `~\AppData\Roaming\Zed\AGENTS.md` |
| Continue | `continue` | nothing global (no global file; prints the steps for its settings screen) |  |
| Aider | `aider` | adds a marked `read:` entry: `~/.aider.conf.yml (read: ~/.logicpacks/rules/logicpacks.md)` |  |
| Amp | `amp` | appends the marked block to `~/.config/amp/AGENTS.md` |  |
| Warp | `warp` | nothing global (no global file; prints the steps for its settings screen) |  |
| Kiro | `kiro` | creates its own file `~/.kiro/steering/logicpacks.md` |  |
| Goose | `goose` | appends the marked block to `~/.config/goose/.goosehints` |  |
| Qwen Code | `qwen` | appends the marked block to `~/.qwen/QWEN.md` |  |
| Crush | `crush` | appends the marked block to `~/.config/crush/CRUSH.md` |  |
| Factory Droid | `droid` | appends the marked block to `~/.factory/AGENTS.md` |  |
| JetBrains Junie | `junie` | appends the marked block to `~/.junie/AGENTS.md` | `~\.junie\AGENTS.md` |
| Hermes Agent | `hermes` | nothing global (no global file; prints the steps for its settings screen) |  |
| T3 Code | `t3code` | nothing global (no global file; prints the steps for its settings screen) |  |
| Any other agent | `generic` | nothing global (no global file; prints the steps for its settings screen) |  |

`lp setup-block` prints the block so you can paste it yourself instead. A file whose LogicPacks markers are unbalanced is refused, not rewritten.

**Undo:** `lp uninstall` (`lp uninstall --dry-run` shows what it would remove) removes every LogicPacks block and LogicPacks-owned rules file, the Claude Code hooks, the watcher and the MCP registrations. A file it appended to comes back byte for byte as it was before; a file it created and that now holds only the block is deleted. `lp uninstall --agent <id>` removes just that harness's block. `lp uninstall` leaves the helper itself in place; to remove it too, run `lp logout`, then delete `~/.logicpacks` and `~/.local/bin/lp` (Windows: `%USERPROFILE%\.logicpacks` and its `bin` entry in your user PATH). `lp uninstall` does not delete projects you shared: they stay on the host and on GitHub.

## 4. Back up first

Setup copies each file it touches to `<file>.lp-backup-<YYYYMMDD-HHMMSS>` before writing and prints that path. To keep a copy of your own as well:

```sh
d=$(date +%Y-%m-%d)
for f in ~/.claude/CLAUDE.md ~/.claude/settings.json ~/.claude.json ~/.codex/AGENTS.md ~/.codex/config.toml; do
  [ -f "$f" ] && cp -p "$f" "$f.lp-backup-$d"
done
```

Windows (PowerShell): `Copy-Item $HOME\.claude\CLAUDE.md "$HOME\.claude\CLAUDE.md.lp-backup-$(Get-Date -Format yyyy-MM-dd)"`. Add the file for your harness from the table above.

## 5. What teammates can see

Sharing has two levels:

- **One project.** "Share" on a project, `lp invite <email>`, and the invite link that `lp share` and `lp invite` print add a person to that project only. They see that project's threads and files.
- **A workspace.** A workspace invite link ("Invite your team" in the app, or `lp invite --workspace`) makes the person a workspace member, and members work in **all** of that workspace's projects. Use a separate workspace for work you do not want everyone in it to see.

What streams from your computer:

- The helper sends Claude Code and Codex sessions whose folder is inside a shared project (or is a clone with the same git remote). Sessions in other folders are not stored by the host. The helper does send a session's first batch before the host answers that it belongs to no project, and it retries unmatched sessions, so a folder added to a project later brings that session's earlier history with it.
- **A streamed session includes its tool calls**: the tool name, its input (up to about 300 characters) and a summary of its result (up to about 1,500 characters), alongside your prompts and the agent's replies. Anyone who can see the project can read them.
- **Redaction happens on your computer, before anything is sent:** secrets (API keys and tokens, private keys, passwords in commands, config and connection strings) are replaced with `[redacted]`. MCP tool calls stream as the tool name only, unless you opt in per folder with `lp stream --mcp-details on`. Reading `.env`, key, credential or `.ssh` files sends the path only, never the content. `lp stream --status` shows exactly what a folder sends. This is the helper from 2026-11-01 on; an older install sends tool calls without redaction, so run the install line again.
- Redaction matches known secret shapes, so it can miss some. Keep sessions that use sensitive tools (messaging, email, analytics, account or admin tools) out of shared project folders, or keep them private with `lp unlink <folder>` (that folder and its subfolders, on this computer) or `lp pause` (everything, until `lp resume`). While paused or unlinked, nothing from that time is sent later.

What teammates cannot do:

- Run your local agent, your MCP servers or your tools. Each person's agent runs on their own login, on their own computer. Teammates can send messages and questions to your agent's thread (`lp send`, `lp ask`), and your agent sees their thread titles and the files they are editing as project context.
- Use your model login. Each member's turns run only on the login that member has on their own computer. The one exception is "Share my agent login" in Request assistance, which lets that expert run turns on your login in that one project until you revoke it (section 7).

## 6. Secrets and access to files

- A member reaches only their own folder, the projects shared with them and those projects' worktrees. Every request is checked against their current role. Host-level actions are refused, and terminals are off for members.
- When you share a project, the host is your own laptop: its owner can reach everything on it, and teammates connect and sync to it while it is on. Our cloud, where each member's agent would run as its own isolated user with a scrubbed environment (no host credentials, no GitHub token, no SSH agent), is coming soon and is not available yet. Checks of that design: [/research.md](/research.md) (Member sandbox).
- **A member can read everything in a shared project folder, including `.env` and key files.** Experts from Request assistance join as ordinary project members, so the same applies to them. Neither files nor pasted text are filtered or redacted for them.
- **Vetted freelancers (Beta) are the exception:** in the projects they are assigned to, secret files (`.env`, keys and similar) are hidden from them, secrets pasted into threads are redacted in what they see, and they run on their own AI login unless you allow yours for that offer. Their access ends when the work is completed or cancelled.
- Keep secrets out of shared projects: use `.gitignore` for `.env` and key files, keep them outside the project folder, or use a secrets manager. Do not paste keys into a shared thread. `lp share` pushes the project to its GitHub remote, so anything committed is in that repository as well.
- Do not put access to other machines (servers, home lab, VPN, SSH keys) in a shared project.

## 7. Removing someone, and how fast it takes effect

- **From a project:** open the project's "Share" dialog (sidebar, project menu), then "Remove" next to the person. Only the owner can do this. It removes a direct share only: a person who is also a member of the workspace keeps access through the workspace.
- **From a workspace:** workspace menu, "Manage workspace", "People", "Remove" (owner only). This removes their workspace membership and every project share they had in that workspace.
- **A workspace invite link:** "Manage workspace", "Advanced", "Reset invite link". The old link stops working ("This invite link has expired"); people who already joined stay until you remove them.
- **A project's invite link:** the project's "Share" dialog turns the link off or resets it; `lp revoke-invite` does the same from the command line (`lp revoke-invite <email>` cancels one pending invite).
- **An expert (Request assistance):** "End session" in the Request assistance panel, or `lp assist end <request id>`. It revokes their use of your login and removes them from the project if that request is what added them.
- **A shared agent login:** "Revoke login" in the Request assistance panel. Their next turn on your login is refused; their project membership stays until you end the session.
- **From the command line:** `lp members` lists who is in the project; `lp remove <person>` removes them from the project and its workspace (`--project-only` for just the project, `--dry-run` to see what it would do).
- **Timing:** removal applies to the person's next request (each request checks their current access), and their helper can no longer stream into the project. An agent turn that is already running is not stopped and keeps its access until it ends. Removal does not touch GitHub: LogicPacks does not add teammates as collaborators on your repository, and any copy a person already cloned stays with them.

## 8. Agent logins and code
- **Agents run on your own computer.** The app (Mac or Windows) uses the Claude Code or Codex CLI that is already installed and logged in on your machine. There is no "Log in with Claude" in the app; if the CLI is missing, the app shows the install command and tells you to log in in your terminal. Nothing of that login is stored on our servers.
- **Sharing is host-based:** teammates connect and sync to the host's laptop while it is on. The project lives on the host's laptop.

### Our cloud (coming soon, not available yet)

Our cloud is not live. The following describes how it is designed, so you can judge it ahead of time:

- **Cloud logins:** a stored agent login would be kept for your account only and encrypted at rest (AES-256-GCM, with a key per member derived from a host key that is not part of any backup), decrypted only while your agent runs in the cloud and sealed again when it stops. This protects copies of the disk and backups; the host's administrator, who holds the key, could still read it. No API or screen would show one member's login to another member.
- **Each member runs separately:** each member's agent runs in its own sandbox.
- **Your code:** a project created from scratch in the cloud has no GitHub copy until you sync it, and thread history is stored in the cloud only.


---

Canonical URL: https://logicpacks.io/safety.md

LogicPacks is developed by TechRealm (https://techrealm.online). Operated by Al Jash Trading (Establishment), Abu Dhabi, UAE, established 1994. Economic licence CN-1030597, Abu Dhabi Registration Authority. Address: Office 5, Bani Yas West 4, Bani Yas, Abu Dhabi, UAE. Website: https://aljashtrading.com. Contact: WhatsApp +1 713 632 2262 (https://wa.me/17136322262).

All pages for agents: [/llms.txt](/llms.txt). Plain facts: [/about.md](/about.md). Safety: [/safety.md](/safety.md).