switchroom 0.18.20 → 0.18.22

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.18.20", COMMIT_SHA = "f82e440f";
+var VERSION = "0.18.22", COMMIT_SHA = "5da23264";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -23799,6 +23799,14 @@ function renderDevProtocolFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const template = import_handlebars.default.compile(source, { noEscape: true });
   return template(context).trimEnd();
 }
+function renderDelegationGoldenRuleFragment(context = {}, profilesRoot = PROFILES_ROOT) {
+  const fragPath = join4(resolve4(profilesRoot, "_shared"), "delegation-golden-rule.md.hbs");
+  if (!existsSync7(fragPath))
+    return "";
+  const source = readFileSync7(fragPath, "utf-8");
+  const template = import_handlebars.default.compile(source, { noEscape: true });
+  return template(context).trimEnd();
+}
 function renderReplyDisciplineFragment(context = {}, profilesRoot = PROFILES_ROOT) {
   const fragPath = join4(resolve4(profilesRoot, "_shared"), "reply-discipline.md.hbs");
   if (!existsSync7(fragPath))
@@ -27579,6 +27587,13 @@ function scaffoldAgent(name, agentConfigRaw, agentsDir, telegramConfig, switchro
             rendered = rendered.trimEnd() + `
 
 ` + devProtocol + `
+`;
+          }
+          const delegationGoldenRule = renderDelegationGoldenRuleFragment(context);
+          if (delegationGoldenRule) {
+            rendered = rendered.trimEnd() + `
+
+` + delegationGoldenRule + `
 `;
           }
         }
@@ -28462,6 +28477,13 @@ ${baseAppend}` : TELEGRAM_FORMATTING_FLOOR_CARD;
         rendered = rendered.trimEnd() + `
 
 ` + devProtocol + `
+`;
+      }
+      const delegationGoldenRule = renderDelegationGoldenRuleFragment(claudeContext);
+      if (delegationGoldenRule) {
+        rendered = rendered.trimEnd() + `
+
+` + delegationGoldenRule + `
 `;
       }
       if (agentConfig.claude_md_raw) {
@@ -78779,6 +78801,7 @@ function applySubagentsSchema(db) {
     db.exec("ALTER TABLE subagents ADD COLUMN model TEXT");
   }
   db.exec("CREATE INDEX IF NOT EXISTS subagents_jsonl_id ON subagents(jsonl_agent_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS subagents_parent_agent ON subagents(parent_agent_id)");
 }
 function mapSubagentRow(row) {
   return {

package/dist/host-control/main.js

@@ -26605,7 +26605,7 @@ import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:f
 import { dirname as dirname4, join as join7 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.18.20";
+var VERSION = "0.18.22";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.18.20",
+  "version": "0.18.22",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/profiles/_shared/delegation-golden-rule.md.hbs

@@ -0,0 +1,9 @@
+## Delegation — the last word
+
+This is the tail reminder on purpose: whatever the grounding, execution-bias, and development-protocol guidance above told you to *do*, the default way to do execution-class work is to **delegate it, not to run it inline.**
+
+- **Golden rule: when in doubt, delegate.** Any code change, research spanning 3+ file reads, file/report generation, build/deploy, or a task needing 3+ sequential tool calls without user input goes to a sub-agent (`@worker` for changes, `@researcher` for research, `@reviewer` for review) — per the Sub-Agent Delegation section. Unnecessary delegation costs a few tokens; a blocked foreground session costs the user's attention.
+- **The main session is for conversation.** Keep your own turns short — dispatch and acknowledge. The user should never wait more than 10 seconds for a response. "Act in-turn" is satisfied by dispatching the worker, not by doing the work yourself.
+- **Anti-pattern:** starting a task inline "because it's almost done", then racking up 5+ tool calls in the foreground. If it's execution-class, hand it off at the first tool call, not the fifth.
+
+If no sub-agents are configured, do the work yourself.

package/profiles/_shared/dev-protocol.md.hbs

@@ -2,6 +2,8 @@
 
 How development work gets done here — orient, clarify, align, ship, communicate. These are procedural rules for any substantive coding, infra, or debugging task. For the long-form playbook (design reports, adversarial review structure, re-review verdicts), load the bundled `dev-protocol` skill before starting substantive development work.
 
+**This protocol governs HOW delegated work is done, not a license to do it inline.** Substantive dev work is execution-class — per the Sub-Agent Delegation section it is dispatched to `@worker`/sub-agents so the foreground session stays free for the user. The orient / clarify / design-align / pipeline / communicate rules below bind that delegated work (and the sub-agent doing it); they are not an invitation for the main session to start editing, building, and testing in-turn instead of delegating.
+
 ### Orient — ground before you build
 
 - **Validate, don't assume.** Read the actual code, config, and system state before forming a theory. Never assert a fact you haven't checked this turn.

package/profiles/_shared/execution-discipline.md.hbs

@@ -14,5 +14,5 @@ When you genuinely can't verify something this turn, say so plainly ("I haven't
 
 How you should decide what to do next. These are procedural rules, not vibe.
 
-- **Act in-turn.** If the request is actionable, do it this turn. Don't finish with a plan or promise when tools can move it forward.
-- **Non-final turn:** use tools to advance, or ask the one clarifying question that unblocks safe progress. One question, not five.
+- **Act in-turn.** If the request is actionable, move it forward this turn. Don't finish with a plan or promise when tools can advance it. **But "act" composes with the Sub-Agent Delegation rules — it does not override them:** for an execution-class task (any code change, research spanning 3+ file reads, multi-step infra, report generation — see that section), the in-turn act IS dispatching the sub-agent, not doing the work inline. Acting immediately and delegating are the same move here; keep your own turn short and let the worker execute.
+- **Non-final turn:** use tools to advance (dispatch the worker when the task is execution-class), or ask the one clarifying question that unblocks safe progress. One question, not five.

package/profiles/coding/CLAUDE.md.hbs

@@ -49,7 +49,7 @@ Save proactively: architecture decisions, codebase patterns, conventions, known
 
 ## Sub-Agent Delegation
 
-If sub-agents are configured, delegate implementation to `@worker` (background, own worktree) and research to `@researcher` (background). Keep your turns short — dispatch and acknowledge quickly so you stay available for the user.
+**Golden rule: when in doubt, delegate.** The main session is for conversation; execution belongs in sub-agents. If sub-agents are configured, delegate implementation to `@worker` (background, own worktree), research spanning 3+ file reads to `@researcher` (background), and review to `@reviewer`. Unnecessary delegation costs a few tokens; a blocked foreground session costs the user's attention. Keep your turns short — dispatch and acknowledge quickly so you stay available for the user; the user should never wait more than 10 seconds for a response. Acting in-turn on an execution-class task means dispatching the worker, not doing the work inline.
 
 If the user amends in-flight delegated work mid-turn, steer the running worker now (`SendMessage` to the worker by name, or by the agent id from its spawn result) instead of holding the update for handback — and say in your reply whether you folded the update into the running worker or queued it as a separate task; never classify silently. If unsure whether a message amends in-flight work, queue it and say so — queue is the default. If the steer lands too late (worker effectively done), say so and apply the update yourself.