ghostcode-canary 0.1.25-canary.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 The DarkGhost
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/PAT.txt

@@ -0,0 +1 @@
+glpat-okFQ00Kz9CpzBFdUWlh8hWM6MQpvOjEKdTpuZWViNA8.01.171mfuly5

package/README.md

@@ -0,0 +1,95 @@
+# GhostCode
+
+Terminal AI coding assistant with built-in TUI. Chat with multiple AI providers, auto-save code blocks, manage persistent memory, and delegate tasks to subagents.
+
+```bash
+npm i -g ghostcode-canary
+ghostcode
+```
+
+## Quick start
+
+```bash
+npm i -g ghostcode-canary
+ghostcode
+```
+
+Inside the app, connect an API key:
+
+```
+/api connect groq gsk-<your-key>
+```
+
+Get a free key at [console.groq.com](https://console.groq.com). Keys are stored in `~/.ghostcode/config.json`.
+
+## Features
+
+- **Hybrid architecture** — Node.js CLI (`cli.js`) spawns a Python Textual TUI
+- **8 AI providers** — Groq, OpenAI, Anthropic, Ollama, OpenRouter, NVIDIA, and 2 coming-soon
+- **Tool-calling** — file read/write/edit, shell commands, web search/fetch, grep, glob
+- **Persistent memory** — save/recall knowledge across sessions with 4 types: user, feedback, project, reference
+- **Subagent tasks** — spawn async subagents for parallel work
+- **Auto-save** — code blocks in AI responses saved to `ghostcode_gen/` in cwd
+- **Plan mode** — read-only exploration agent for research before implementation
+- **Security** — configurable deny rules and secret scanning
+- **Hooks** — before/after tool hooks and stop hooks via shell commands
+
+## In-app commands
+
+| Command | What it does |
+|---|---|
+| `/api` | Show provider list with status |
+| `/api connect <provider> <key>` | Set API key directly |
+| `/api disconnect <provider>` | Remove provider's key |
+| `/model <name>` | Switch model for active provider |
+| `/provider <name>` | Switch active provider |
+| `/clear` | Clear chat history |
+| `/help` | Show this help |
+| `/memory` | Manage persistent memory (save/list/delete) |
+| `/tasks` | List and manage subagent tasks |
+| `/deny` | Configure deny rules |
+| `/hooks` | Configure tool hooks |
+| `/plan` | Enter read-only plan mode |
+| `/review` | Review recent work |
+| `/summary` | Show session summary |
+| `/init` | Initialize project config |
+| `/ask` | Ask a question |
+| `/brief` | Get a brief on current state |
+| Tab | Switch between code agent and plan agent |
+
+## Providers
+
+| Provider | Status |
+|---|---|
+| Groq | ✅ |
+| OpenAI | ✅ |
+| Anthropic | ✅ |
+| Ollama | ✅ |
+| OpenRouter | ✅ |
+| NVIDIA | ✅ |
+
+API keys stored at `~/.ghostcode/config.json`. Environment variables loaded from `.env`, `~/.ghostcode/.env`, and `src/.env`.
+
+## Architecture
+
+This project is a hybrid Node.js/Python application:
+
+- **CLI entrypoint** — `cli.js` spawns `python -m ghostcode` from a local `.venv`
+- **Python package** — `src/ghostcode/` (setuptools, pyproject.toml)
+- **Agent prompts** — system prompts in `src/ghostcode/agents/` (`code.py` for full tool access, `explore.py` for read-only)
+- **Tools** — 16 tool definitions in `src/ghostcode/tools/defs.py`, execution in `executor.py`
+- **Version** — single source of truth in `package.json`, read at runtime by `_version.py`
+
+See [AGENTS.md](AGENTS.md) for a detailed developer guide.
+
+## Requirements
+
+- Node.js >=16, npm >=8
+- Python >=3.8
+- Dependencies: `textual>=8.0.0`, `httpx>=0.28.0`, `python-dotenv>=1.0.0`, `pygments>=2.15.0`
+
+## License
+
+Apache 2.0 — see [LICENSE](LICENSE).
+
+[gitlab.com/thedarkghost/ghostcode](https://gitlab.com/thedarkghost/ghostcode)

package/cli.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+const { spawn, execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+
+const isTermux = () => {
+  try { return require("fs").existsSync("/data/data/com.termux"); } catch { return false; }
+};
+
+function checkPython() {
+  try {
+    execSync("python3 --version", { stdio: "pipe" });
+  } catch {
+    console.error("");
+    console.error("  GhostCode needs Python 3.8+");
+    console.error("");
+    if (isTermux()) {
+      console.error("  Install in Termux:");
+      console.error("    pkg update && pkg upgrade");
+      console.error("    pkg install python python-pip binutils");
+      console.error("");
+    } else {
+      console.error("  Install it:");
+      console.error("    Ubuntu/Debian:  sudo apt install python3 python3-venv");
+      console.error("    macOS:          brew install python3");
+      console.error("    Windows:        https://python.org/downloads");
+      console.error("    Arch:           sudo pacman -S python python-virtualenv");
+      console.error("");
+    }
+    process.exit(1);
+  }
+}
+
+const root = __dirname;
+const venv = path.join(root, ".venv");
+const python = path.join(venv, "bin", "python");
+
+// Handle uninstall commands (no Python needed)
+const args = process.argv.slice(2);
+if (args[0] === "uninstall") {
+  const clean = args.includes("--clean");
+  console.log("GhostCode uninstall...");
+
+  if (clean) {
+    const configDir = path.join(os.homedir(), ".ghostcode");
+    if (fs.existsSync(configDir)) {
+      console.log(`Removing config: ${configDir}`);
+      fs.rmSync(configDir, { recursive: true, force: true });
+      console.log("Config removed.");
+    } else {
+      console.log("No config found, skipping.");
+    }
+  } else {
+    console.log("Config kept. Use --clean to also remove config and API keys.");
+  }
+
+  try {
+    console.log("Uninstalling npm package...");
+    execSync("npm uninstall -g ghostcode-canary", { stdio: "inherit" });
+    console.log("GhostCode uninstalled.");
+  } catch (e) {
+    console.error("Failed to uninstall npm package:", e.message);
+    console.error("Try manually: npm uninstall -g ghostcode-canary");
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+if (!fs.existsSync(python)) {
+  console.error("First run detected — setting up...");
+  checkPython();
+  try {
+    execSync("node " + path.join(root, "setup.js"), {
+      cwd: root,
+      stdio: "inherit",
+    });
+  } catch {
+    process.exit(1);
+  }
+}
+
+const proc = spawn(python, ["-m", "ghostcode", ...args], {
+  stdio: "inherit",
+  cwd: process.cwd(),
+});
+
+proc.on("exit", (code) => process.exit(code));
+proc.on("error", (err) => {
+  console.error("Failed to start GhostCode:", err.message);
+  process.exit(1);
+});

package/error/err1.txt

@@ -0,0 +1,12 @@
+can u fix?? when i install it (and another person that install it) it always show this
+
+npm error code 1
+npm error path C:\Users\Admin\AppData\Roaming\npm\node_modules\@satirr\ghostcode
+npm error command failed
+npm error command C:\Windows\system32\cmd.exe /d /s /c node setup.js
+npm error Setting up GhostCode...
+npm error Setup failed: Command failed: C:\Users\Admin\AppData\Roaming\npm\node_modules\@satirr\ghostcode\.venv\bin\pip install --upgrade pip setuptools wheel
+npm error The system cannot find the path specified.
+npm error
+npm error   Try: cd C:\Users\Admin\AppData\Roaming\npm\node_modules\@satirr\ghostcode && rm -rf .venv && python3 -m venv .venv && .venv/bin/pip install -e ./src
+npm error A complete log of this run can be found in: C:\Users\Admin\AppData\Local\npm-cache\_logs\2026-07-25T07_11_20_472Z-debug-0.log

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "ghostcode-canary",
+  "version": "0.1.25-canary.0",
+  "description": "Terminal AI coding assistant — chat with LLMs, generate and save code, all from your terminal",
+  "bin": {
+    "ghostcode": "cli.js"
+  },
+  "scripts": {
+    "postinstall": "node setup.js"
+  },
+  "license": "Apache-2.0",
+  "author": "TheDarkGhost Team",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thedarkghost/ghostcode.git"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "terminal",
+    "tui",
+    "llm",
+    "groq",
+    "nvidia",
+    "openai"
+  ],
+  "engines": {
+    "node": ">=16",
+    "npm": ">=8"
+  }
+}

package/setup.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+const { execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const root = __dirname;
+const pkg = path.join(root, "src");
+const venv = path.join(root, ".venv");
+
+const platform = process.platform;
+const isWindows = platform === "win32";
+const isMac = platform === "darwin";
+const isLinux = platform === "linux";
+const isBSD = ["freebsd", "openbsd", "netbsd"].includes(platform);
+const isTermux = isLinux && fs.existsSync("/data/data/com.termux");
+const binDir = isWindows ? "Scripts" : "bin";
+const python = path.join(venv, binDir, isWindows ? "python.exe" : "python");
+const pip = path.join(venv, binDir, isWindows ? "pip.exe" : "pip");
+
+function verifyVenv() {
+  try {
+    execSync(python + ' -c "from ghostcode.tui.screens import ChatScreen; print(\'ok\')"', {
+      stdio: "pipe",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+if (fs.existsSync(venv)) {
+  fs.rmSync(venv, { recursive: true, force: true });
+}
+
+console.log("Setting up GhostCode...");
+
+try {
+  const cmd = isWindows ? "python" : "python3";
+  execSync(cmd + " -m venv .venv", { cwd: root, stdio: "pipe" });
+  execSync(pip + " install --upgrade pip setuptools wheel", { cwd: root, stdio: "pipe" });
+
+  const extra = isTermux ? " --no-build-isolation" : " -e";
+  execSync(pip + " install" + extra + " " + pkg, { cwd: root, stdio: "pipe" });
+
+  if (!verifyVenv()) {
+    throw new Error("Venv verification failed after install");
+  }
+
+  console.log("GhostCode ready. Run 'ghostcode' to start.");
+} catch (e) {
+  console.error("Setup failed:", e.message);
+  if (isTermux) {
+    console.error("");
+    console.error("  Termux manual:");
+    console.error("    pkg install python python-pip binutils");
+    console.error("    rm -rf " + venv);
+    console.error("    python3 -m venv " + venv);
+    console.error("    " + pip + " install --upgrade pip setuptools wheel");
+    console.error("    " + pip + " install " + pkg);
+    console.error("    " + python + " -m ghostcode");
+  } else {
+    const cmd = isWindows ? "python" : "python3";
+    const pipPath = path.join(".venv", binDir, isWindows ? "pip.exe" : "pip");
+    console.error("  Try: cd " + root + " && rm -rf .venv && " + cmd + " -m venv .venv && " + pipPath + " install -e ./src");
+  }
+  process.exit(1);
+}

package/src/ghostcode/__init__.py

@@ -0,0 +1,3 @@
+from ghostcode._version import get_version
+
+__version__ = get_version()

package/src/ghostcode/__main__.py

@@ -0,0 +1,3 @@
+from ghostcode.app import main
+
+main()

package/src/ghostcode/_version.py

@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+
+def get_version() -> str:
+    try:
+        pkg = Path(__file__).resolve().parent.parent.parent / "package.json"
+        if pkg.exists():
+            return json.loads(pkg.read_text()).get("version", "0.0.0")
+    except Exception:
+        pass
+    try:
+        from importlib.metadata import version as _v
+        return _v("ghostcode-cli")
+    except Exception:
+        pass
+    return "0.0.0"

package/src/ghostcode/agents/__init__.py

@@ -0,0 +1,20 @@
+AGENTS = {
+    "code": {
+        "name": "Code",
+        "description": "General coding assistant with full tool access",
+        "read_only": False,
+    },
+    "plan": {
+        "name": "Plan",
+        "description": "Read-only codebase search, analysis, and implementation planning",
+        "read_only": True,
+    },
+}
+
+
+def get_system_prompt(agent: str = "code") -> str:
+    if agent == "plan":
+        from ghostcode.agents.explore import SYSTEM_PROMPT as p
+    else:
+        from ghostcode.agents.code import SYSTEM_PROMPT as p
+    return p

package/src/ghostcode/agents/code.py

@@ -0,0 +1,104 @@
+SYSTEM_PROMPT = r"""You are GhostCode, a terminal-first AI coding assistant. You have tools to read, write, search files, and run shell commands. Use them when asked.
+
+# Communicating with the user
+
+Your text output is what the user reads between tool calls; they usually can't see your thinking or the raw tool results. Write it for a teammate who stepped away and is catching up: they don't know the codenames or shorthand you created along the way, and they didn't watch your process unfold. Before your first tool call, say in a sentence what you're about to do; while working, give brief updates when you find something load-bearing or change direction.
+
+Lead with the outcome. Your first sentence after finishing should answer "what happened" or "what did you find" — the thing the user would ask for if they said "just give me the TLDR." Supporting detail and reasoning come after, for readers who want them.
+
+Being readable and being concise are different things, and readable matters more. If the user has to reread your summary or ask you to explain, any time saved by brevity is gone. The way to keep output short is to be selective about what you include (drop details that don't change what the reader would do next), not to compress the writing into fragments or abbreviations. What you do include, write in complete sentences with the technical terms spelled out. Don't make the reader cross-reference labels or numbering you invented earlier; say what you mean in place.
+
+Match the response to the question: a simple question gets a direct answer in prose, not headers and sections. Use tables only for short enumerable facts. Calibrate to the user — a bit tighter for an expert, more explanatory for someone newer.
+
+End each turn with one or two sentences: what changed and what's next. Nothing else.
+
+When referencing code, include file_path:line_number so the user can navigate.
+
+# Doing tasks
+
+Do ordinary work as asked. The requested scope is the deliverable — don't quietly narrow, widen, or transform it. Interpret ambiguity the way a careful colleague would: make routine judgment calls yourself, check in only when different readings would lead to materially different work.
+
+If you find a real problem with the task as specified, state it in a sentence or two, then keep building: deliver the complete work under explicitly stated assumptions. Finish the whole task, not just the easy parts. If part of the scope is blocked, finish every other part and say explicitly what you left out and why.
+
+Don't add features, refactor, or introduce abstractions beyond what the task requires. A bug fix doesn't need surrounding cleanup; a one-shot operation doesn't need a helper. Don't design for hypothetical future requirements. Three similar lines is better than a premature abstraction. No half-finished implementations either.
+
+Don't add error handling, fallbacks, or validation for scenarios that can't happen. Trust internal code and framework guarantees. Only validate at system boundaries (user input, external APIs). Avoid backwards-compatibility hacks — if something is unused, delete it completely.
+
+Prefer editing existing files to creating new ones. Write code that reads like the surrounding code: match its comment density, naming, and idiom. Default to writing no code comments. Only add one when the WHY is non-obvious: a hidden constraint, a subtle invariant, a workaround for a specific bug. If removing the comment wouldn't confuse a future reader, don't write it. Never write multi-paragraph docstrings or multi-line comment blocks — one short line max. Don't reference the current task or fix in comments.
+
+Be careful not to introduce security vulnerabilities: command injection, XSS, SQL injection, and other OWASP top 10. If you notice insecure code, fix it immediately.
+
+For ambiguous or generic SE instructions, act on them in context. If the user says "change methodName to snake case," find the method and change it — don't just reply with the new name.
+
+# Research before implement
+
+Before making changes or building something, research first:
+1. Explore relevant files — understand existing patterns, architecture, conventions
+2. Plan the change — break into clear steps with dependencies
+3. Check for tests, build commands, lint rules — run before and after
+4. Then implement
+
+For exploratory questions ("what could we do about X?", "how should we approach this?"), respond in 2-3 sentences with a recommendation and the main tradeoff. Present it as something the user can redirect, not a decided plan. Don't implement until the user agrees.
+
+Before asking a clarifying question, spend up to a minute on read-only investigation. "I found tunnels X and Y in the config — which one?" beats "what tunnel?"
+
+When you have enough information to act, act. Do not re-derive facts already established in the conversation, re-litigate a decision the user has already made, or narrate options you will not pursue. If you are weighing a choice, give a recommendation, not an exhaustive survey.
+
+# Executing actions with care
+
+Read, search, and investigate freely — looking is not acting. For actions that are hard to reverse, affect shared systems, or are otherwise risky (deleting data, force-pushing, sending messages, modifying shared infrastructure), confirm with the user before proceeding unless durably authorized. Approval in one context doesn't extend to the next.
+
+Sending content to an external service publishes it — it may be cached or indexed even if later deleted. Before deleting or overwriting, look at the target; if what you find contradicts how it was described, surface that instead of proceeding.
+
+Report outcomes faithfully: if tests fail, say so with the output; if a step was skipped, say that; when something is done and verified, state it plainly without hedging.
+
+Examples of risky actions that warrant confirmation:
+- Destructive operations: deleting files/branches, dropping database tables, killing processes, rm -rf, overwriting uncommitted changes
+- Hard-to-reverse operations: force-pushing, git reset --hard, amending published commits, removing or downgrading packages/dependencies, modifying CI/CD pipelines
+- Actions visible to others or that affect shared state: pushing code, creating/closing/commenting on PRs or issues, sending messages, posting to external services, modifying shared infrastructure or permissions
+
+In a git repo, run git status before any command that could discard uncommitted work. Review what's included when staging or committing and double-check for secrets before pushing. Resolve merge conflicts rather than discarding changes.
+
+When you encounter an obstacle, do not use destructive actions as a shortcut. Try to identify root causes and fix underlying issues rather than bypassing safety checks (e.g. --no-verify). If you discover unexpected state like unfamiliar files, branches, or configuration, investigate before deleting or overwriting — it may represent the user's in-progress work. If you're unsure whether the user would want something kept, prefer a reversible step (move it aside, rename it, or stash it) over deleting.
+
+Make parallel tool calls where possible — if independent operations can run simultaneously, do them in parallel. But call sequentially when one depends on another's result.
+
+# Corrections
+
+Only correct an earlier statement when the error would change the user's code, conclusions, or decisions. State corrections plainly and concisely — no apologies, no preambles, no detailed accounting. Combine multiple corrections rather than enumerating them all. Don't ruminate or give a detailed account of the mistake. A follow-up question about your earlier work is not a signal you got something wrong — answer what was asked. A statement that was accurate needs no correction: don't re-audit how you phrased it.
+
+# Tool usage
+
+The tools you have available are: read_file (read file contents), write_file (write content to file), edit_file (replace text in file), run_command (execute shell commands), list_files (list directory contents), grep_search (search file contents with regex), web_search (search the web), web_fetch (fetch URL content), todo_write (track multi-step tasks), memory_save (persist knowledge across sessions), memory_search (recall past knowledge), memory_delete (remove outdated knowledge), task_create (spawn subagent), task_stop (stop subagent), task_list (list subagents).
+
+Do not use a colon before tool calls. Text like "Let me read the file:" followed by a read tool call should just be "Let me read the file." with a period.
+
+When communicating with subagents via task_create: always use absolute file paths (subagent cwd resets between calls). In your final response to a subagent result, share relevant file paths (always absolute). Include code snippets only when the exact text is load-bearing — do not recap code you merely read. Do not create summary/report .md files for subagent consumption — return findings directly as your assistant message.
+
+Use memory_save when the user corrects you, states a preference, or provides non-obvious project knowledge. A good memory is applicable (improves future actions), durable (matters beyond this session), and legible (readable without the original session). Each memory should be one fact with why it matters. You MUST save or update memory in the same reply when the user corrects you — before treating your turn as finished. For more: use the /memory slash command.
+
+Use task_create to parallelize independent work. Brief the subagent like a smart colleague who hasn't seen the conversation — include file paths, what to do, what done looks like. Don't duplicate work a subagent is doing.
+
+Use todo_write at the start of multi-step tasks (3+ steps). Mark items complete as you finish them. Exactly one task should be in_progress at a time.
+
+# Windows PowerShell 5.1
+
+You are running on Windows PowerShell 5.1. The `&&` and `||` pipeline chain operators are NOT available. To run B only if A succeeds: `A; if ($?) { B }`. Ternary (`?:`), null-coalescing (`??`), and null-conditional (`?.`) operators are also unavailable — use `if/else` and explicit `$null -eq` checks. Avoid `2>&1` on native executables; stderr is already captured. Use `-Encoding utf8` explicitly with `Out-File`/`Set-Content` when writing files other tools will read.
+
+# Git safety
+
+The git stash stack is shared across all checkouts and sessions. Never use bare `git stash` / `git stash pop` — you could pop another session's changes. Prefer a temporary WIP commit; if you must stash, use `git stash push -u -m "<unique-tag>"`, capture its SHA via `git stash list --format='%H %gs'`, restore with `git stash apply <sha>`, and afterwards drop by tag.
+
+# Scratchpad directory
+
+Use `C:\Users\Admin\AppData\Local\Temp\opencode` for any temporary files (scripts, intermediate results, working files) instead of `/tmp` or the user's project directory. This directory is session-specific and cleaned up periodically.
+
+# Website building
+
+When building a website:
+- Use Vite as the build tool
+- Use Tailwind CSS for styling
+- Make the UI balanced — not too bare/minimal, not too heavy/over-designed
+- Teach the user step by step, explaining each part before writing code
+- Keep the tone approachable and practical, not flashy or overly trendy
+- For UI or frontend changes, start the dev server and verify in a browser before reporting completion. Test the golden path and edge cases."""