@agentprojectcontext/apx 1.33.1 → 1.35.0

package/src/core/agent/tools/handlers/git-diff.js

@@ -0,0 +1,44 @@
+// git_diff — show the diff for a project. Defaults to unstaged working-tree
+// changes; pass staged=true for the index, or `ref` to diff against a commit.
+import { runGit, resolveGitCwd } from "./_git.js";
+
+export default {
+  name: "git_diff",
+  category: "code",
+  schema: {
+    type: "function",
+    function: {
+      name: "git_diff",
+      description:
+        "Show the git diff for a project. Defaults to UNSTAGED changes (working tree vs index). Set staged=true for the index vs HEAD, or pass ref (a commit, branch, or 'HEAD~1') to diff the working tree against that ref. Optional path argument limits the diff to a file/directory. Output is capped — use git_status first to choose what to diff if the change is large.",
+      parameters: {
+        type: "object",
+        properties: {
+          project: { type: "string", description: "project id, name, or path" },
+          cwd: { type: "string", description: "explicit working directory (overrides project)" },
+          staged: { type: "boolean", description: "diff the index vs HEAD instead of the working tree" },
+          ref: { type: "string", description: "ref to diff against (commit / branch / HEAD~N)" },
+          path: { type: "string", description: "limit the diff to this path (file or directory)" },
+          stat: { type: "boolean", description: "summary only (--stat) instead of full diff" },
+        },
+      },
+    },
+  },
+  makeHandler: (ctx) => async ({ project, cwd, staged, ref, path: subPath, stat } = {}) => {
+    const root = resolveGitCwd(ctx, { project, cwd });
+    const args = ["diff", "--no-color"];
+    if (stat) args.push("--stat");
+    if (staged) args.push("--staged");
+    if (ref) args.push(ref);
+    if (subPath) args.push("--", subPath);
+    const r = await runGit(args, { cwd: root });
+    if (!r.ok) return { ok: false, error: r.stderr || `git diff exited ${r.code}` };
+    return {
+      ok: true,
+      cwd: root,
+      diff: r.stdout,
+      truncated: r.truncated,
+      args: args.slice(1),
+    };
+  },
+};

package/src/core/agent/tools/handlers/git-log.js

@@ -0,0 +1,38 @@
+// git_log — recent commits for a project. One-line format by default.
+import { runGit, resolveGitCwd } from "./_git.js";
+
+export default {
+  name: "git_log",
+  category: "code",
+  schema: {
+    type: "function",
+    function: {
+      name: "git_log",
+      description:
+        "List recent commits for a project. Defaults to the last 20 commits in one-line format. Pass path to limit to a file/directory, ref to start from a different commit/branch, or full=true for the full message + stats.",
+      parameters: {
+        type: "object",
+        properties: {
+          project: { type: "string", description: "project id, name, or path" },
+          cwd: { type: "string", description: "explicit working directory (overrides project)" },
+          limit: { type: "integer", description: "max commits to return (default 20, capped at 200)" },
+          ref: { type: "string", description: "ref to start from (branch / commit / HEAD~N); defaults to HEAD" },
+          path: { type: "string", description: "limit to commits touching this path" },
+          full: { type: "boolean", description: "show full subject + body + stat instead of oneline" },
+        },
+      },
+    },
+  },
+  makeHandler: (ctx) => async ({ project, cwd, limit = 20, ref, path: subPath, full } = {}) => {
+    const root = resolveGitCwd(ctx, { project, cwd });
+    const safeLimit = Math.max(1, Math.min(Number(limit) || 20, 200));
+    const args = ["log", `-n${safeLimit}`, "--no-color"];
+    if (full) args.push("--format=fuller", "--stat");
+    else args.push("--oneline", "--decorate=short");
+    if (ref) args.push(ref);
+    if (subPath) args.push("--", subPath);
+    const r = await runGit(args, { cwd: root });
+    if (!r.ok) return { ok: false, error: r.stderr || `git log exited ${r.code}` };
+    return { ok: true, cwd: root, log: r.stdout, truncated: r.truncated };
+  },
+};

package/src/core/agent/tools/handlers/git-show.js

@@ -0,0 +1,34 @@
+// git_show — inspect a single commit (or branch tip): subject, author, files
+// changed, full diff.
+import { runGit, resolveGitCwd } from "./_git.js";
+
+export default {
+  name: "git_show",
+  category: "code",
+  schema: {
+    type: "function",
+    function: {
+      name: "git_show",
+      description:
+        "Show a single git commit (or any ref) — message, author, files changed, and full diff. Use `ref` to point at a commit hash, branch, or HEAD~N. Defaults to HEAD.",
+      parameters: {
+        type: "object",
+        properties: {
+          project: { type: "string", description: "project id, name, or path" },
+          cwd: { type: "string", description: "explicit working directory (overrides project)" },
+          ref: { type: "string", description: "ref to show (commit / branch / HEAD~N); defaults to HEAD" },
+          stat: { type: "boolean", description: "show stat summary instead of full diff" },
+        },
+      },
+    },
+  },
+  makeHandler: (ctx) => async ({ project, cwd, ref = "HEAD", stat } = {}) => {
+    const root = resolveGitCwd(ctx, { project, cwd });
+    const args = ["show", "--no-color"];
+    if (stat) args.push("--stat");
+    args.push(ref);
+    const r = await runGit(args, { cwd: root });
+    if (!r.ok) return { ok: false, error: r.stderr || `git show exited ${r.code}` };
+    return { ok: true, cwd: root, ref, output: r.stdout, truncated: r.truncated };
+  },
+};

package/src/core/agent/tools/handlers/git-status.js

@@ -0,0 +1,61 @@
+// git_status — porcelain working-tree status for a project. Returns the raw
+// porcelain text plus a structured list of files so the model doesn't have to
+// re-parse it.
+import { runGit, resolveGitCwd } from "./_git.js";
+
+function parsePorcelain(text) {
+  const files = [];
+  for (const line of String(text).split("\n")) {
+    if (!line) continue;
+    // Format: XY <path>  (optionally `XY <orig> -> <renamed>` for renames)
+    const xy = line.slice(0, 2);
+    const rest = line.slice(3);
+    const renameIdx = rest.indexOf(" -> ");
+    let pathStr = rest;
+    let origPath = null;
+    if (renameIdx >= 0) {
+      origPath = rest.slice(0, renameIdx);
+      pathStr = rest.slice(renameIdx + 4);
+    }
+    files.push({
+      staged: xy[0] !== " " && xy[0] !== "?",
+      unstaged: xy[1] !== " ",
+      untracked: xy === "??",
+      status: xy.trim(),
+      path: pathStr,
+      ...(origPath ? { original_path: origPath } : {}),
+    });
+  }
+  return files;
+}
+
+export default {
+  name: "git_status",
+  category: "code",
+  schema: {
+    type: "function",
+    function: {
+      name: "git_status",
+      description:
+        "Show the git working-tree status (staged + unstaged + untracked) for a project. Returns porcelain output plus a parsed list of files. Pass project (id/name/path) OR cwd. Use this BEFORE summarizing changes or BEFORE staging.",
+      parameters: {
+        type: "object",
+        properties: {
+          project: { type: "string", description: "project id, name, or path; falls back to the active project if omitted" },
+          cwd: { type: "string", description: "explicit working directory (overrides project)" },
+        },
+      },
+    },
+  },
+  makeHandler: (ctx) => async ({ project, cwd } = {}) => {
+    const root = resolveGitCwd(ctx, { project, cwd });
+    const r = await runGit(["status", "--porcelain=v1", "-uall"], { cwd: root });
+    if (!r.ok) return { ok: false, error: r.stderr || `git status exited ${r.code}` };
+    return {
+      ok: true,
+      cwd: root,
+      files: parsePorcelain(r.stdout),
+      raw: r.stdout,
+    };
+  },
+};

package/src/core/agent/tools/handlers/transcribe-audio.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
-import { transcribe } from "#host/daemon/transcription.js";
+import { transcribe } from "#core/voice/transcription.js";
 
 export default {
   name: "transcribe_audio",

package/src/core/agent/tools/helpers.js

@@ -1,12 +1,12 @@
 // Pure / config-only helpers used by tool handlers. Anything that needs the
 // running daemon's projects registry (projectMeta, resolveProject) lives in
-// host/daemon/projects-helpers.js and is re-exported here for back-compat.
+// core/apc/projects-helpers.js and is re-exported here for back-compat.
 import path from "node:path";
 import { agentSkills, buildAgentSystem as buildCoreAgentSystem } from "#core/agent/build-agent-system.js";
 import { buildConfirmDescription } from "#core/confirmation/index.js";
 import { PERMISSION_MODES, DEFAULT_PERMISSION_MODE } from "#core/constants/permissions.js";
 
-export { projectMeta, resolveProject } from "#host/daemon/projects-helpers.js";
+export { projectMeta, resolveProject } from "#core/apc/projects-helpers.js";
 
 export function safePathJoin(root, sub = ".") {
   const target = path.resolve(root, sub || ".");

package/src/core/agent/tools/names.js

@@ -0,0 +1,169 @@
+// Canonical tool names. Every place that mentions a tool by name — handler
+// dispatch, allow-lists, prompt rules, the registry bridge skip-set — imports
+// the constant from here. Refactor-safe: rename once, the rest follows.
+//
+// Keep the keys SCREAMING_SNAKE_CASE and the values snake_case (the on-wire
+// tool name the LLM sees). The two halves stay aligned so a typo on either
+// side is obvious.
+
+export const TOOLS = Object.freeze({
+  // Discovery / projects / agents
+  LIST_PROJECTS:       "list_projects",
+  ADD_PROJECT:         "add_project",
+  LIST_AGENTS:         "list_agents",
+  LIST_VAULT_AGENTS:   "list_vault_agents",
+  IMPORT_AGENT:        "import_agent",
+  LIST_MCPS:           "list_mcps",
+
+  // Memory
+  READ_AGENT_MEMORY:   "read_agent_memory",
+  READ_SELF_MEMORY:    "read_self_memory",
+  REMEMBER:            "remember",
+
+  // Filesystem / shell
+  LIST_FILES:          "list_files",
+  READ_FILE:           "read_file",
+  WRITE_FILE:          "write_file",
+  EDIT_FILE:           "edit_file",
+  SEARCH_FILES:        "search_files",
+  RUN_SHELL:           "run_shell",
+
+  // History / messages / sessions
+  TAIL_MESSAGES:       "tail_messages",
+  SEARCH_MESSAGES:     "search_messages",
+  SEARCH_SESSIONS:     "search_sessions",
+
+  // Skills + dynamic tool surface
+  LIST_SKILLS:         "list_skills",
+  LOAD_SKILL:          "load_skill",
+  DISCOVER_TOOLS:      "discover_tools",
+
+  // Tasks
+  LIST_TASKS:          "list_tasks",
+  CREATE_TASK:         "create_task",
+
+  // Interaction
+  ASK_QUESTIONS:       "ask_questions",
+
+  // Delegation / external
+  CALL_AGENT:          "call_agent",
+  CALL_MCP:            "call_mcp",
+  CALL_RUNTIME:        "call_runtime",
+
+  // Side-effects
+  SEND_TELEGRAM:       "send_telegram",
+  SET_IDENTITY:        "set_identity",
+  SET_PERMISSION_MODE: "set_permission_mode",
+  TRANSCRIBE_AUDIO:    "transcribe_audio",
+
+  // Git — code-channel tools, lazy on chat
+  GIT_STATUS:          "git_status",
+  GIT_DIFF:            "git_diff",
+  GIT_LOG:             "git_log",
+  GIT_SHOW:            "git_show",
+
+  // HTTP-bridged registry tools (not native handlers; served via
+  // core/tools/registry.js so the regular generic tools work the same way).
+  GREP:                "grep",
+  GLOB:                "glob",
+  FETCH:               "fetch",
+  SEARCH:              "search",
+});
+
+/**
+ * Native handlers in src/core/agent/tools/handlers/ that own these names.
+ * The registry bridge MUST skip these — otherwise the HTTP roundtrip would
+ * shadow the in-process handler with possibly different semantics.
+ */
+export const NATIVE_TOOL_NAMES = new Set([
+  TOOLS.LIST_PROJECTS,
+  TOOLS.LIST_AGENTS,
+  TOOLS.LIST_VAULT_AGENTS,
+  TOOLS.IMPORT_AGENT,
+  TOOLS.ADD_PROJECT,
+  TOOLS.LIST_MCPS,
+  TOOLS.READ_AGENT_MEMORY,
+  TOOLS.LIST_FILES,
+  TOOLS.READ_FILE,
+  TOOLS.WRITE_FILE,
+  TOOLS.EDIT_FILE,
+  TOOLS.SEARCH_FILES,
+  TOOLS.RUN_SHELL,
+  TOOLS.TAIL_MESSAGES,
+  TOOLS.SEARCH_MESSAGES,
+  TOOLS.CALL_AGENT,
+  TOOLS.CALL_MCP,
+  TOOLS.CALL_RUNTIME,
+  TOOLS.SEND_TELEGRAM,
+  TOOLS.SET_IDENTITY,
+  TOOLS.SET_PERMISSION_MODE,
+  TOOLS.READ_SELF_MEMORY,
+  TOOLS.REMEMBER,
+  TOOLS.LIST_SKILLS,
+  TOOLS.LOAD_SKILL,
+  TOOLS.LIST_TASKS,
+  TOOLS.CREATE_TASK,
+  TOOLS.ASK_QUESTIONS,
+  TOOLS.SEARCH_SESSIONS,
+  TOOLS.TRANSCRIBE_AUDIO,
+  TOOLS.DISCOVER_TOOLS,
+  TOOLS.GIT_STATUS,
+  TOOLS.GIT_DIFF,
+  TOOLS.GIT_LOG,
+  TOOLS.GIT_SHOW,
+]);
+
+/**
+ * Tools that belong in code-shaped channels (apx code, web_code) but should
+ * stay lazy on chat surfaces (telegram, web_sidebar, deck, desktop) — there's
+ * no point loading `git_diff` schemas in a Telegram chat.
+ *
+ * Listed separately so registry.js can promote them into the base set when
+ * the channel is a coding surface, without touching the chat base.
+ */
+export const CODE_CHANNEL_TOOLS = Object.freeze([
+  TOOLS.GIT_STATUS,
+  TOOLS.GIT_DIFF,
+  TOOLS.GIT_LOG,
+  TOOLS.GIT_SHOW,
+]);
+
+/**
+ * Read-only allow-list for the Code module's PLAN mode: the agent explores
+ * the repo and proposes changes without mutating anything. Build mode uses
+ * the full registry — see CODE_BUILD_TOOLS below.
+ */
+export const CODE_PLAN_TOOLS = Object.freeze([
+  TOOLS.READ_FILE,
+  TOOLS.LIST_FILES,
+  TOOLS.SEARCH_FILES,
+  TOOLS.GREP,
+  TOOLS.GLOB,
+  TOOLS.LIST_PROJECTS,
+  TOOLS.LIST_AGENTS,
+  TOOLS.LIST_MCPS,
+  TOOLS.READ_AGENT_MEMORY,
+  TOOLS.READ_SELF_MEMORY,
+  TOOLS.SEARCH_SESSIONS,
+  TOOLS.SEARCH_MESSAGES,
+  TOOLS.TAIL_MESSAGES,
+  TOOLS.LIST_SKILLS,
+  TOOLS.LOAD_SKILL,
+  TOOLS.LIST_TASKS,
+  TOOLS.ASK_QUESTIONS,
+  TOOLS.FETCH,
+  TOOLS.SEARCH,
+  // Git tools are read-only on plan mode and let the agent inspect the
+  // working state before proposing edits.
+  TOOLS.GIT_STATUS,
+  TOOLS.GIT_DIFF,
+  TOOLS.GIT_LOG,
+  TOOLS.GIT_SHOW,
+]);
+
+/**
+ * BUILD mode = unrestricted. Kept as a sentinel value so callers compare
+ * against the constant instead of the magic "*" string. The registry treats
+ * "*" as "expose every tool the channel is otherwise allowed to see".
+ */
+export const CODE_BUILD_TOOLS = "*";

package/src/core/agent/tools/registry-bridge.js

@@ -1,10 +1,9 @@
-// daemon/super-agent-tools/registry-bridge.js
 //
 // Generic bridge that exposes registry-backed HTTP tools (browser, fetch,
 // search, glob, grep, etc.) to the super-agent — no per-tool import boilerplate.
 //
 // How it works:
-//   1. Read TOOL_DEFINITIONS from daemon/tools/registry.js
+//   1. Read TOOL_DEFINITIONS from core/http-tools/registry.js
 //   2. Drop entries whose names collide with native super-agent tools (those
 //      win — they touch in-process state directly).
 //   3. For each remaining entry, produce { name, schema, makeHandler } in the
@@ -19,8 +18,9 @@
 // super-agent-tools/tools/, no import in index.js.
 
 import fs from "node:fs";
-import { TOOL_DEFINITIONS } from "#core/tools/registry.js";
+import { TOOL_DEFINITIONS } from "#core/http-tools/registry.js";
 import { TOKEN_PATH } from "#core/config/index.js";
+import { NATIVE_TOOL_NAMES } from "./names.js";
 
 // The bridge POSTs to the daemon's OWN HTTP server, which is behind the bearer
 // auth middleware (see api/shared.js). Without a token every bridged tool call
@@ -42,17 +42,9 @@ function daemonToken() {
   return cachedToken;
 }
 
-// Native handlers in super-agent-tools/tools/ that own these names. The bridge
-// MUST skip them or the registry version (HTTP roundtrip) would shadow the
-// native one with possibly different semantics.
-const NATIVE_NAMES = new Set([
-  "list_projects", "list_agents", "list_vault_agents", "import_agent",
-  "add_project", "list_mcps", "read_agent_memory",
-  "list_files", "read_file", "write_file", "edit_file", "search_files",
-  "run_shell", "tail_messages", "search_messages",
-  "call_agent", "call_mcp", "call_runtime",
-  "send_telegram", "set_identity", "set_permission_mode",
-]);
+// Native handler list lives in ./names.js so the bridge skip-set and the
+// allow-lists in api/code.js share one source of truth.
+const NATIVE_NAMES = NATIVE_TOOL_NAMES;
 
 // Default allow-list of categories the bridge will expose. The NATIVE_NAMES
 // filter handles duplicates inside these categories (e.g. "file" contains

package/src/core/agent/tools/registry.js

@@ -29,8 +29,14 @@ import askQuestions from "./handlers/ask-questions.js";
 import createTask from "./handlers/create-task.js";
 import listTasks from "./handlers/list-tasks.js";
 import discoverTools from "./handlers/discover-tools.js";
+import gitStatus from "./handlers/git-status.js";
+import gitDiff from "./handlers/git-diff.js";
+import gitLog from "./handlers/git-log.js";
+import gitShow from "./handlers/git-show.js";
 import { createPermissionGuard } from "./helpers.js";
 import { buildBridgedTools, DEFAULT_CATEGORIES } from "./registry-bridge.js";
+import { TOOLS, CODE_CHANNEL_TOOLS } from "./names.js";
+import { CHANNELS } from "#core/constants/channels.js";
 
 const NATIVE_TOOLS = [
   listProjects,
@@ -64,6 +70,10 @@ const NATIVE_TOOLS = [
   createTask,
   listTasks,
   discoverTools,
+  gitStatus,
+  gitDiff,
+  gitLog,
+  gitShow,
 ];
 
 // Registry-backed bridges. Categories can be overridden per-process via env
@@ -76,9 +86,9 @@ function resolveBridgeCategories() {
 }
 
 const BRIDGED_TOOLS = buildBridgedTools({ categories: resolveBridgeCategories() });
-const TOOLS = [...NATIVE_TOOLS, ...BRIDGED_TOOLS];
+const ALL_TOOLS = [...NATIVE_TOOLS, ...BRIDGED_TOOLS];
 
-export const TOOL_SCHEMAS = TOOLS.map((tool) => tool.schema);
+export const TOOL_SCHEMAS = ALL_TOOLS.map((tool) => tool.schema);
 
 // ---------------------------------------------------------------------------
 // Lazy tools: base set (always loaded) + on-demand set (revealed via
@@ -93,78 +103,96 @@ export const TOOL_SCHEMAS = TOOLS.map((tool) => tool.schema);
 // sessions, projects/inventory, basic shell, tasks, skills, and discovery.
 export const BASE_TOOL_NAMES = new Set([
   // Discovery — the entry point to everything not loaded here.
-  "discover_tools",
+  TOOLS.DISCOVER_TOOLS,
   // Inventory — the model needs these to know what exists.
-  "list_projects",
-  "list_agents",
-  "list_mcps",
-  "list_skills",
-  "load_skill",
+  TOOLS.LIST_PROJECTS,
+  TOOLS.LIST_AGENTS,
+  TOOLS.LIST_MCPS,
+  TOOLS.LIST_SKILLS,
+  TOOLS.LOAD_SKILL,
   // Memory + identity.
-  "read_agent_memory",
-  "read_self_memory",
-  "remember",
-  "set_identity",
+  TOOLS.READ_AGENT_MEMORY,
+  TOOLS.READ_SELF_MEMORY,
+  TOOLS.REMEMBER,
+  TOOLS.SET_IDENTITY,
   // Sessions + messages (self-recall + channel history).
-  "search_sessions",
-  "search_messages",
-  "tail_messages",
+  TOOLS.SEARCH_SESSIONS,
+  TOOLS.SEARCH_MESSAGES,
+  TOOLS.TAIL_MESSAGES,
   // Channels + conversation control + lightweight delegation.
-  "send_telegram",
-  "ask_questions",
-  "call_agent",
+  TOOLS.SEND_TELEGRAM,
+  TOOLS.ASK_QUESTIONS,
+  TOOLS.CALL_AGENT,
   // Tasks (very common ask via chat).
-  "create_task",
-  "list_tasks",
+  TOOLS.CREATE_TASK,
+  TOOLS.LIST_TASKS,
   // Files + basic shell — frequent enough on chat to keep hot.
-  "read_file",
-  "write_file",
-  "edit_file",
-  "list_files",
-  "search_files",
-  "run_shell",
+  TOOLS.READ_FILE,
+  TOOLS.WRITE_FILE,
+  TOOLS.EDIT_FILE,
+  TOOLS.LIST_FILES,
+  TOOLS.SEARCH_FILES,
+  TOOLS.RUN_SHELL,
 ]);
 
 // Channels that get the FULL registry up front (deliberate, user-picked model,
 // no cheap-tier TPM cap). Everything else is a "lightweight" channel and starts
 // on BASE_TOOL_NAMES with discover_tools to expand.
-const FULL_CHANNELS = new Set(["routine", "api", "web", "code", "terminal"]);
+const FULL_CHANNELS = new Set([
+  CHANNELS.ROUTINE,
+  CHANNELS.API,
+  CHANNELS.WEB,
+  CHANNELS.CODE,
+  CHANNELS.WEB_CODE,
+]);
+
+// Coding surfaces — even on the lightweight set, these channels get the
+// git_* tools promoted into the base so the model can inspect the repo
+// without round-tripping through discover_tools every turn.
+const CODE_CHANNELS = new Set([
+  CHANNELS.CODE,
+  CHANNELS.WEB_CODE,
+]);
 
 // Category labels for grouping the discover_tools catalog. Native tools have no
 // registry category, so we assign one here; bridged tools carry their own
 // (browser/fetch/search/file) from registry-bridge.js.
 const NATIVE_CATEGORY = {
-  discover_tools: "system",
-  set_permission_mode: "system",
-  list_projects: "inventory",
-  list_agents: "inventory",
-  list_vault_agents: "inventory",
-  list_mcps: "inventory",
-  list_skills: "inventory",
-  load_skill: "skills",
-  import_agent: "agents",
-  add_project: "projects",
-  call_agent: "agents",
-  call_runtime: "runtime",
-  call_mcp: "mcp",
-  read_agent_memory: "memory",
-  read_self_memory: "memory",
-  remember: "memory",
-  set_identity: "identity",
-  search_sessions: "sessions",
-  search_messages: "messages",
-  tail_messages: "messages",
-  send_telegram: "messages",
-  ask_questions: "conversation",
-  create_task: "tasks",
-  list_tasks: "tasks",
-  transcribe_audio: "voice",
-  read_file: "files",
-  write_file: "files",
-  edit_file: "files",
-  list_files: "files",
-  search_files: "files",
-  run_shell: "shell",
+  [TOOLS.DISCOVER_TOOLS]:      "system",
+  [TOOLS.SET_PERMISSION_MODE]: "system",
+  [TOOLS.LIST_PROJECTS]:       "inventory",
+  [TOOLS.LIST_AGENTS]:         "inventory",
+  [TOOLS.LIST_VAULT_AGENTS]:   "inventory",
+  [TOOLS.LIST_MCPS]:           "inventory",
+  [TOOLS.LIST_SKILLS]:         "inventory",
+  [TOOLS.LOAD_SKILL]:          "skills",
+  [TOOLS.IMPORT_AGENT]:        "agents",
+  [TOOLS.ADD_PROJECT]:         "projects",
+  [TOOLS.CALL_AGENT]:          "agents",
+  [TOOLS.CALL_RUNTIME]:        "runtime",
+  [TOOLS.CALL_MCP]:            "mcp",
+  [TOOLS.READ_AGENT_MEMORY]:   "memory",
+  [TOOLS.READ_SELF_MEMORY]:    "memory",
+  [TOOLS.REMEMBER]:            "memory",
+  [TOOLS.SET_IDENTITY]:        "identity",
+  [TOOLS.SEARCH_SESSIONS]:     "sessions",
+  [TOOLS.SEARCH_MESSAGES]:     "messages",
+  [TOOLS.TAIL_MESSAGES]:       "messages",
+  [TOOLS.SEND_TELEGRAM]:       "messages",
+  [TOOLS.ASK_QUESTIONS]:       "conversation",
+  [TOOLS.CREATE_TASK]:         "tasks",
+  [TOOLS.LIST_TASKS]:          "tasks",
+  [TOOLS.TRANSCRIBE_AUDIO]:    "voice",
+  [TOOLS.READ_FILE]:           "files",
+  [TOOLS.WRITE_FILE]:          "files",
+  [TOOLS.EDIT_FILE]:           "files",
+  [TOOLS.LIST_FILES]:          "files",
+  [TOOLS.SEARCH_FILES]:        "files",
+  [TOOLS.RUN_SHELL]:           "shell",
+  [TOOLS.GIT_STATUS]:          "code",
+  [TOOLS.GIT_DIFF]:            "code",
+  [TOOLS.GIT_LOG]:             "code",
+  [TOOLS.GIT_SHOW]:            "code",
 };
 
 function categoryOf(tool) {
@@ -179,7 +207,7 @@ function oneLine(desc = "") {
 
 // Static metadata index for every tool — name, schema, category, short blurb.
 // Used by the per-turn tool session for the catalog and activation lookups.
-const TOOL_META = TOOLS.map((t) => ({
+const TOOL_META = ALL_TOOLS.map((t) => ({
   name: t.name,
   schema: t.schema,
   category: categoryOf(t),
@@ -187,24 +215,30 @@ const TOOL_META = TOOLS.map((t) => ({
 }));
 const META_BY_NAME = new Map(TOOL_META.map((m) => [m.name, m]));
 
-export const BASE_TOOL_SCHEMAS = TOOLS
+export const BASE_TOOL_SCHEMAS = ALL_TOOLS
   .filter((t) => BASE_TOOL_NAMES.has(t.name))
   .map((t) => t.schema);
 
-// Back-compat alias: a few callers/tests historically referenced the "core"
-// subset. The base set supersedes it.
-export const CORE_TOOL_SCHEMAS = BASE_TOOL_SCHEMAS;
-
 const schemaName = (s) => s?.function?.name || s?.name;
 
+// Code-channel base = BASE + git_* tools. Pre-computed once.
+const CODE_BASE_TOOL_NAMES = new Set([...BASE_TOOL_NAMES, ...CODE_CHANNEL_TOOLS]);
+const CODE_BASE_TOOL_SCHEMAS = ALL_TOOLS
+  .filter((t) => CODE_BASE_TOOL_NAMES.has(t.name))
+  .map((t) => t.schema);
+
 /**
- * Choose the INITIAL tool schema list for a channel. Full channels get the
- * whole registry; lightweight channels (telegram/desktop/deck/web_sidebar) get
- * the base set and expand on demand via discover_tools. `full: true` forces the
- * complete registry regardless of channel.
+ * Choose the INITIAL tool schema list for a channel.
+ *   - FULL_CHANNELS (api, web, code, web_code, routine) get the whole registry.
+ *   - CODE_CHANNELS overlap with FULL, but when something forces a smaller set
+ *     (CODE_PLAN_TOOLS allowlist) the git_* tools are still in their base.
+ *   - Everything else is "lightweight" and starts on BASE_TOOL_NAMES.
+ *
+ * `full: true` forces the complete registry regardless of channel.
  */
 export function schemasForChannel(channel, { full = false } = {}) {
   if (full || FULL_CHANNELS.has(channel)) return TOOL_SCHEMAS;
+  if (CODE_CHANNELS.has(channel)) return CODE_BASE_TOOL_SCHEMAS;
   return BASE_TOOL_SCHEMAS;
 }
 
@@ -337,7 +371,7 @@ export function makeToolHandlers(ctx) {
       requestConfirmation: ctx.requestConfirmation || null,
     }),
   };
-  return Object.fromEntries(TOOLS.map((tool) => [tool.name, tool.makeHandler(toolCtx)]));
+  return Object.fromEntries(ALL_TOOLS.map((tool) => [tool.name, tool.makeHandler(toolCtx)]));
 }
 
 // Diagnostic helper — useful for `apx daemon status` or debug logging.