forge-delegate 1.0.5 → 1.0.7

package/cli.mjs

@@ -48,15 +48,20 @@ function installClaudeSkill(scope, projectDir) {
   console.log(`  \u2713 delegate-work skill (${dest})`);
 }
 
-function registerClaude(launch, scope) {
+// `claude mcp` writes .mcp.json relative to its own cwd, so a project-scope install
+// must run from projectDir — otherwise it lands in whatever directory setup was
+// invoked from, and installClaudeSkill (which does honour projectDir) disagrees
+// with it.
+function registerClaude(launch, scope, projectDir) {
+  const opts = scope === "project" ? { cwd: projectDir } : {};
   try {
-    execSync(`claude mcp remove --scope ${scope} forge-delegate`, { stdio: "ignore" });
+    execSync(`claude mcp remove --scope ${scope} forge-delegate`, { ...opts, stdio: "ignore" });
   } catch {}
   try {
-    execSync(`claude mcp remove forge-delegate`, { stdio: "ignore" });
+    execSync(`claude mcp remove forge-delegate`, { ...opts, stdio: "ignore" });
   } catch {}
-  execSync(`claude mcp add --scope ${scope} forge-delegate -- ${launch}`, { stdio: "inherit" });
-  console.log(`  ✓ Claude Code (scope=${scope})`);
+  execSync(`claude mcp add --scope ${scope} forge-delegate -- ${launch}`, { ...opts, stdio: "inherit" });
+  console.log(`  ✓ Claude Code (scope=${scope}${scope === "project" ? `, ${projectDir}` : ""})`);
 }
 
 function codexConfigPath(scope, projectDir) {
@@ -139,7 +144,7 @@ async function setup() {
   for (const target of targets) {
     try {
       if (target === "claude") {
-        registerClaude(launch, scope);
+        registerClaude(launch, scope, projectDir);
         if (!flags["no-skill"]) installClaudeSkill(scope, projectDir);
       }
       else if (target === "codex") registerCodex(launchArr, scope, projectDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-delegate",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "MCP server that relays coding work to other AI models (DeepSeek, Gemini, OpenAI, Ollama) so Claude Code saves tokens",
   "type": "module",
   "bin": {

package/server.mjs

@@ -27,6 +27,33 @@ const RUNS_DIR = join(homedir(), ".forge-delegate", "runs");
 const here = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(here, "package.json"), "utf8")).version;
 
+// The server auto-updates (npx re-resolves latest on each spawn) but the installed
+// skill is a file on disk that only `setup` rewrites — so a published skill change
+// goes unnoticed. Compare the two and say so, rather than running stale in silence.
+function skillStatus() {
+  const src = join(here, "skills", "delegate-work", "SKILL.md");
+  if (!existsSync(src)) return null;
+  const dests = [
+    join(homedir(), ".claude", "skills", "delegate-work", "SKILL.md"),
+    join(process.cwd(), ".claude", "skills", "delegate-work", "SKILL.md"),
+  ];
+  const installed = dests.filter(existsSync);
+  if (!installed.length) return { state: "missing", detail: "not installed" };
+  const want = readFileSync(src, "utf8");
+  const stale = installed.filter((d) => readFileSync(d, "utf8") !== want);
+  return stale.length
+    ? { state: "stale", detail: `out of date: ${stale.join(", ")}` }
+    : { state: "ok", detail: "up to date" };
+}
+
+const SKILL_STATUS = skillStatus();
+if (SKILL_STATUS && SKILL_STATUS.state !== "ok") {
+  // stderr only — stdout is the JSON-RPC channel.
+  process.stderr.write(
+    `forge-delegate: delegate-work skill ${SKILL_STATUS.detail}. Run: npx -y forge-delegate setup\n`
+  );
+}
+
 const INSTRUCTIONS = `forge-delegate hands coding work to cheap external models running as full agents. They read the project and write the code in their own loop, so the work never passes through your context. Spend your context on judgment; delegate the typing.
 
 DELEGATE BY DEFAULT — do not hand-write these yourself:
@@ -37,8 +64,9 @@ DELEGATE BY DEFAULT — do not hand-write these yourself:
 - Ports and translations between languages, frameworks, or file formats.
 - The same edit repeated across 3 or more files.
 - Reading a large file or directory to answer one narrow question — delegate the reading, keep your context clean.
+- The survey half of an audit ("does this follow X standards", "is this secure", "where is the tech debt", "how does X work"). Delegate the gathering, keep the verdict: ask for a structured digest with a file path behind every claim, then judge it yourself. A claim with no path is not a finding.
 
-KEEP FOR YOURSELF: architecture, debugging an unknown root cause, security-sensitive code, anything where being wrong is expensive, and the review of whatever comes back. Delegation does not transfer responsibility for the result.
+KEEP FOR YOURSELF: architecture, debugging an unknown root cause, security-sensitive code, anything where being wrong is expensive, and the verdict on whatever comes back. Delegation does not transfer responsibility for the result.
 
 Routing:
 - One-shot question, no file access needed -> ask_model.
@@ -162,7 +190,7 @@ server.tool(
 
 server.tool(
   "delegate",
-  "USE THIS INSTEAD OF WRITING THE CODE YOURSELF when the task is: tests for code that already exists; a mechanical refactor (rename, signature change, import rewrite, API migration); fixing lint/type/build errors; boilerplate or scaffolding (CRUD endpoints, config, schemas, adapters, fixtures); a port between languages or frameworks; the same edit repeated across 3 or more files; or reading a large file/directory to answer one narrow question. Hands the task to another AI model running as a full agent via local opencode: it reads your project, explores, and writes concrete code in its own tool loop — none of which enters your context. Keep architecture, unknown-root-cause debugging, and security-sensitive code for yourself, and always review what comes back. Runs INLINE by default (result returned when done; Claude Code auto-backgrounds calls past 2 minutes). Pass background:true to run detached and get a job id instantly, then poll check_delegation — use that for parallel fan-out or hosts that block on long calls. Pass continue_session (returned by a previous delegation) to keep the same agent session instead of re-exploring. Never paste file contents into task: name the paths and let the agent read them. model/directory/agent/autoApprove default from config — omit them.",
+  "USE THIS INSTEAD OF WRITING THE CODE YOURSELF when the task is: tests for code that already exists; a mechanical refactor (rename, signature change, import rewrite, API migration); fixing lint/type/build errors; boilerplate or scaffolding (CRUD endpoints, config, schemas, adapters, fixtures); a port between languages or frameworks; the same edit repeated across 3 or more files; reading a large file/directory to answer one narrow question; or the survey half of an audit (delegate the gathering, keep the verdict — demand a file path behind every claim). Hands the task to another AI model running as a full agent via local opencode: it reads your project, explores, and writes concrete code in its own tool loop — none of which enters your context. Keep architecture, unknown-root-cause debugging, and security-sensitive code for yourself, and always review what comes back. Runs INLINE by default (result returned when done; Claude Code auto-backgrounds calls past 2 minutes). Pass background:true to run detached and get a job id instantly, then poll check_delegation — use that for parallel fan-out or hosts that block on long calls. Pass continue_session (returned by a previous delegation) to keep the same agent session instead of re-exploring. Never paste file contents into task: name the paths and let the agent read them. model/directory/agent/autoApprove default from config — omit them.",
   {
     model: z.string().optional().describe("provider/model format, e.g. opencode/mimo-v2.5-free (defaults to config defaultModel)"),
     task: z.string(),
@@ -243,7 +271,8 @@ server.tool(
     const { profiles, ...rest } = cfg;
     const lines = Object.entries(rest).map(([k, v]) => `  ${k}: ${v ?? "(unset)"}`);
     const prof = Object.entries(profiles).map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`).join("\n") || "  (none)";
-    return { content: [{ type: "text", text: `config: ${configPath()}\n${lines.join("\n")}\nprofiles:\n${prof}` }] };
+    const skill = SKILL_STATUS ? `\nskill (delegate-work): ${SKILL_STATUS.detail}${SKILL_STATUS.state === "ok" ? "" : " — run: npx -y forge-delegate setup"}` : "";
+    return { content: [{ type: "text", text: `config: ${configPath()}\n${lines.join("\n")}\nprofiles:\n${prof}${skill}` }] };
   }
 );
 

package/skills/delegate-work/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: delegate-work
-description: Hand a coding task to a cheap external model via forge-delegate instead of writing it yourself. Load BEFORE starting work that is high-volume and low-judgment - writing tests for code that already exists, mechanical refactors (renames, signature changes, import rewrites, API migrations), fixing lint/type/build errors, boilerplate and scaffolding (CRUD endpoints, config files, schemas, adapters, fixtures), porting code between languages or frameworks, the same edit repeated across 3 or more files, or reading a large file or directory to answer one narrow question. Triggers on - "write tests for", "add tests", "rename X to Y everywhere", "refactor", "migrate", "port this to", "fix the lint errors", "fix the type errors", "scaffold", "boilerplate", "do the same for the other files".
+description: Hand a coding task to a cheap external model via forge-delegate instead of writing it yourself. Load BEFORE starting work that is high-volume and low-judgment - writing tests for code that already exists, mechanical refactors (renames, signature changes, import rewrites, API migrations), fixing lint/type/build errors, boilerplate and scaffolding (CRUD endpoints, config files, schemas, adapters, fixtures), porting code between languages or frameworks, the same edit repeated across 3 or more files, or reading a large file or directory to answer one narrow question. ALSO load for audit and survey questions - "does my codebase follow X", "audit", "review the architecture", "is this idiomatic", "where is the tech debt", "is this secure", "explore the codebase", "how does X work", "find where" - where the reading is wide but the judgment is narrow: delegate the survey, keep the verdict. Triggers on - "write tests for", "add tests", "rename X to Y everywhere", "refactor", "migrate", "port this to", "fix the lint errors", "fix the type errors", "scaffold", "boilerplate", "do the same for the other files".
 ---
 
 # Delegating work to a cheap model
@@ -30,6 +30,28 @@ answer is already known, and the work is typing it out across files.
 Delegating does not transfer responsibility. Review what comes back before you
 report it as done.
 
+## Delegate the survey, keep the verdict
+
+An audit looks like judgment work, so it reads as "keep" — but only the *verdict* is
+judgment. The input gathering is mechanical, wide, and the single most expensive
+thing you can do to your own context. Split them:
+
+1. **Delegate the survey.** Ask for a structured digest, not an opinion:
+   "Report which framework this repo uses. List every routing and data-fetching
+   entry point: path, 3-line summary. Paths only, no assessment."
+2. **Keep the verdict.** Judge the digest yourself. You are now reading a page
+   instead of a repo, and the expensive-if-wrong part never left your hands.
+
+This covers "does this follow X standards", "is this secure", "where is the tech
+debt", "how does X work", "explore the codebase" — broad read, narrow judgment.
+
+**Demand paths as evidence.** A survey's worth depends on the cheap model reporting
+*absence* honestly, and "there is no Next.js here" is exactly the answer a weak model
+is least likely to give — it will produce a plausible audit of a framework you do not
+use rather than contradict the question's premise. Require a file path for every
+claim. A claim with no path attached is not a finding; spot-check two of them before
+you trust the rest.
+
 ## Do it
 
 1. Do the judgment part yourself first — decide the interface, write the first
@@ -58,4 +80,5 @@ second opinion — use `ask_model` instead; it is a direct API call with no agen
 - Don't delegate a task you cannot describe precisely. Vague task, vague diff.
 - Don't delegate and walk away. Unreviewed delegated code is worse than no code.
 - Don't paste large files into the task text.
+- Don't accept a survey finding with no file path behind it.
 - Don't override `model` upward because a task "seems hard" — split it instead.