supipowers 1.2.0 → 1.2.3

package/src/commands/release.ts

@@ -3,7 +3,7 @@ import type { ReleaseChannel, BumpType } from "../types.js";
 import { loadConfig, updateConfig } from "../config/loader.js";
 import { detectChannels } from "../release/detector.js";
 import { parseConventionalCommits, buildChangelogMarkdown, summarizeChanges } from "../release/changelog.js";
-import { getCurrentVersion, suggestBump, bumpVersion, isVersionReleased } from "../release/version.js";
+import { getCurrentVersion, suggestBump, bumpVersion, isVersionReleased, isTagOnRemote } from "../release/version.js";
 import { executeRelease, type ReleaseProgressFn } from "../release/executor.js";
 import { buildPolishPrompt } from "../release/prompt.js";
 import { notifyInfo, notifySuccess, notifyError } from "../notifications/renderer.js";
@@ -20,6 +20,24 @@ const BUMP_OPTIONS = [
   "major — breaking changes",
 ];
 
+/**
+ * Returns true when re-running supi:release should skip the confirmation
+ * dialog and proceed directly to execution.
+ *
+ * This is the resume path: the version in package.json hasn't been tagged yet
+ * AND all channels are already configured — the user staged the release
+ * deliberately when they bumped the version, so no new decisions are needed.
+ * Dry-run is excluded because it is exploratory by intent; the user explicitly
+ * wants to preview and confirm before anything happens.
+ */
+export function isInProgressRelease(opts: {
+  skipBump: boolean;
+  channelsWerePreConfigured: boolean;
+  isDryRun: boolean;
+}): boolean {
+  return opts.skipBump && opts.channelsWerePreConfigured && !opts.isDryRun;
+}
+
 // ── Release progress tracker ────────────────────────────────────
 
 interface ReleaseStep {
@@ -241,6 +259,11 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
       // 1. Ensure channels are configured (or detect + ask)
       progress.activate(1, "Detecting channels");
       let channels = config.release.channels;
+      // Track whether channels were already set in config before any interactive
+      // setup. This distinguishes "user already decided" from "just configured now",
+      // which determines whether we can auto-continue without a confirmation prompt.
+      const channelsWerePreConfigured = config.release.channels.length > 0;
+
       if (channels.length === 0) {
         progress.complete(1, "Awaiting selection");
         channels = await setupChannels(platform, ctx);
@@ -255,11 +278,16 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
       progress.activate(2, "Parsing git history");
       const lastTag = await getLastTag(platform, ctx.cwd);
       const currentVersion = getCurrentVersion(ctx.cwd);
-      const alreadyReleased = await isVersionReleased(
+      const localTagExists = await isVersionReleased(
         platform.exec.bind(platform),
         ctx.cwd,
         currentVersion,
       );
+      // Only check remote when local tag exists — avoids a network call when
+      // the version was never tagged at all.
+      const remoteTagExists = localTagExists
+        ? await isTagOnRemote(platform.exec.bind(platform), ctx.cwd, currentVersion)
+        : false;
 
       // 3. Parse commits since last tag
       const sinceArg = lastTag ? `${lastTag}..HEAD` : "HEAD~50..HEAD";
@@ -280,18 +308,30 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
       const commitCount = commits.features.length + commits.fixes.length + commits.breaking.length + commits.improvements.length + commits.maintenance.length + commits.other.length;
       progress.complete(2, `${commitCount} commits since ${lastTag ?? "start"}`);
 
-      // 4. Version resolution — skip bump when local version is unreleased
+      // 4. Version resolution
+      //    Three states:
+      //    a) No local tag              → version is unreleased, skip bump
+      //    b) Local tag, not on remote  → incomplete release, skip bump + skip tag
+      //    c) Local + remote tag        → fully released, ask for bump
       let nextVersion: string;
       let skipBump: boolean;
+      let skipTag = false;
 
-      if (!alreadyReleased && currentVersion !== "0.0.0") {
-        // Local version hasn't been tagged yet — use it as-is
+      if (!localTagExists && currentVersion !== "0.0.0") {
+        // (a) No tag at all — version in package.json is unreleased
         nextVersion = currentVersion;
         skipBump = true;
         progress.skip(3, `v${currentVersion} (already set, not yet released)`);
-        notifyInfo(ctx, `Using v${currentVersion}`, "Version not yet released — skipping bump");
+        notifyInfo(ctx, `Using v${currentVersion}`, "Version not yet released \u2014 skipping bump");
+      } else if (localTagExists && !remoteTagExists) {
+        // (b) Tag exists locally but never made it to origin — resume
+        nextVersion = currentVersion;
+        skipBump = true;
+        skipTag = true;
+        progress.skip(3, `v${currentVersion} (tag exists locally, not pushed)`);
+        notifyInfo(ctx, `Resuming v${currentVersion}`, "Tag exists locally but not on remote \u2014 will push");
       } else {
-        // Version already released — ask for bump
+        // (c) Fully released — ask for bump
         progress.activate(3, "Awaiting version selection");
         const suggested = suggestBump(commits);
         const bumpChoice = await ctx.ui.select(
@@ -307,7 +347,7 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
         const bump = bumpChoice.split(" \u2014 ")[0] as BumpType;
         nextVersion = bumpVersion(currentVersion, bump);
         skipBump = false;
-        progress.complete(3, `${currentVersion} → ${nextVersion} (${bump})`);
+        progress.complete(3, `${currentVersion} \u2192 ${nextVersion} (${bump})`);
       }
 
       // 5. Build changelog
@@ -343,24 +383,43 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
         return;
       }
 
-      // 7. Confirm via UI
-      const confirmLabel = isDryRun ? `[DRY RUN] Ship v${nextVersion}?` : `Ship v${nextVersion}?`;
-      const confirmDetail = [
-        `${currentVersion} → ${nextVersion}`,
-        `Channels: ${channels.join(", ")}`,
-        `Changes: ${summary}`,
-        "",
-        changelog,
-      ].join("\n");
-
-      const confirmed = ctx.ui.confirm
-        ? await ctx.ui.confirm(confirmLabel, confirmDetail)
-        : (await ctx.ui.select(confirmLabel, ["Yes \u2014 publish", "No \u2014 abort"])) === "Yes \u2014 publish";
-
-      if (!confirmed) {
-        progress.dispose();
-        notifyInfo(ctx, "Release cancelled", "No changes were made");
-        return;
+      // 7. Confirm via UI — skipped when resuming a staged unreleased release.
+      //    When skipBump is true the user already decided on the version; when
+      //    channels were pre-configured there's nothing left to decide. Asking
+      //    again is friction without benefit. Dry-run always asks because the
+      //    user explicitly opted into preview mode.
+      const isResume = isInProgressRelease({ skipBump, channelsWerePreConfigured, isDryRun });
+
+      if (isResume) {
+        notifyInfo(
+          ctx,
+          `Resuming release v${nextVersion}`,
+          "Version staged and channels configured — proceeding without confirmation",
+        );
+      } else {
+        const confirmLabel = isDryRun ? `[DRY RUN] Ship v${nextVersion}?` : `Ship v${nextVersion}?`;
+        // When skipBump=true, currentVersion === nextVersion — avoid the
+        // misleading "0.5.0 → 0.5.0" display.
+        const versionLine = skipBump
+          ? `v${nextVersion} (staged, not yet released)`
+          : `${currentVersion} → ${nextVersion}`;
+        const confirmDetail = [
+          versionLine,
+          `Channels: ${channels.join(", ")}`,
+          `Changes: ${summary}`,
+          "",
+          changelog,
+        ].join("\n");
+
+        const confirmed = ctx.ui.confirm
+          ? await ctx.ui.confirm(confirmLabel, confirmDetail)
+          : (await ctx.ui.select(confirmLabel, ["Yes \u2014 publish", "No \u2014 abort"])) === "Yes \u2014 publish";
+
+        if (!confirmed) {
+          progress.dispose();
+          notifyInfo(ctx, "Release cancelled", "No changes were made");
+          return;
+        }
       }
 
       // 8. Execute release
@@ -374,6 +433,7 @@ export function handleRelease(platform: Platform, ctx: any, args?: string): void
           channels,
           dryRun: isDryRun,
           skipBump,
+          skipTag,
           onProgress: progress.executorProgress(),
         });
 
@@ -499,7 +559,7 @@ function buildReleaseCommands(
 ): string[] {
   const commands: string[] = [
     `git add -A`,
-    `git commit -m "release: v${version}"`,
+    `git commit -m "chore(release): v${version}"`,
     `git tag -a v${version} -m "Release v${version}"`,
     `git push origin HEAD --follow-tags`,
   ];

package/src/deps/registry.ts

@@ -34,7 +34,9 @@ export async function checkBinary(
   exec: ExecFn,
   binary: string,
 ): Promise<{ installed: boolean; version?: string }> {
-  const which = await exec("which", [binary]);
+  // `which` is Unix-only; Windows uses `where` to locate executables
+  const whichCmd = process.platform === "win32" ? "where" : "which";
+  const which = await exec(whichCmd, [binary]);
   if (which.code !== 0) return { installed: false };
 
   const ver = await exec(binary, ["--version"]);

package/src/git/commit.ts

@@ -35,6 +35,50 @@ export interface CommitOptions {
   userContext?: string;
 }
 
+// ── Shared commit primitive ─────────────────────────────────
+
+/** Minimal exec function signature for commitStaged. */
+type ExecFn = (
+  cmd: string,
+  args: string[],
+  opts?: { cwd?: string },
+) => Promise<{ stdout: string; stderr: string; code: number }>;
+
+export interface CommitStagedResult {
+  success: boolean;
+  /** Human-readable error. Present only when success is false. */
+  error?: string;
+}
+
+/**
+ * Validate a commit message and run `git commit` on whatever is currently staged.
+ *
+ * This is the single commit primitive shared between `supi:commit` (AI-powered
+ * plans) and `supi:release` (executor). It ensures every commit in the project
+ * passes the same validation and respects any git hooks.
+ *
+ * Callers are responsible for staging files before calling this function.
+ */
+export async function commitStaged(
+  exec: ExecFn,
+  cwd: string,
+  message: string,
+): Promise<CommitStagedResult> {
+  const validation = validateCommitMessage(message);
+  if (!validation.valid) {
+    return { success: false, error: `Invalid commit message: ${validation.error}` };
+  }
+
+  const result = await exec("git", ["commit", "-m", message], { cwd });
+  if (result.code !== 0) {
+    const detail = result.stderr?.trim() || result.stdout?.trim() || `exit code ${result.code}`;
+    return { success: false, error: `git commit: ${detail}` };
+  }
+
+  return { success: true };
+}
+
+
 // ── Constants ──────────────────────────────────────────────
 
 /** Diff byte budget before we truncate */
@@ -372,20 +416,9 @@ async function manualFallback(
     return null;
   }
 
-  const validation = validateCommitMessage(message);
-  if (!validation.valid) {
-    notifyError(ctx, "Invalid commit message", validation.error);
-    return null;
-  }
-
-  const commitResult = await exec(
-    "git",
-    ["commit", "-m", message],
-    { cwd },
-  );
-
-  if (commitResult.code !== 0) {
-    notifyError(ctx, "git commit failed", commitResult.stderr || "Non-zero exit");
+  const commitResult = await commitStaged(exec, cwd, message);
+  if (!commitResult.success) {
+    notifyError(ctx, "Commit failed", commitResult.error);
     return null;
   }
 
@@ -428,27 +461,12 @@ async function executeCommitPlan(
     // Build commit message
     const message = formatCommitMessage(group);
 
-    const validation = validateCommitMessage(message);
-    if (!validation.valid) {
-      progress.dispose();
-      return reportPartialFailure(ctx, exec, cwd, committedMessages, {
-        step: `Commit ${i + 1}/${plan.commits.length}`,
-        error: `Invalid commit message: ${validation.error}\nMessage: ${message}`,
-      });
-    }
-
-    const commitResult = await exec(
-      "git",
-      ["commit", "-m", message],
-      { cwd },
-    );
-
-    if (commitResult.code !== 0) {
+    const commitResult = await commitStaged(exec, cwd, message);
+    if (!commitResult.success) {
       progress.dispose();
-      const reason = commitResult.stderr?.trim() || "git commit returned non-zero";
       return reportPartialFailure(ctx, exec, cwd, committedMessages, {
         step: `Commit ${i + 1}/${plan.commits.length}`,
-        error: `git commit failed: ${reason}`,
+        error: commitResult.error!,
       });
     }
 

package/src/planning/approval-flow.ts

@@ -12,12 +12,19 @@ import { listPlans, readPlanFile } from "../storage/plans.js";
 let planningActive = false;
 let plansBefore: string[] = [];
 let planCwd: string = "";
+/** newSession function captured from the command context at plan start. */
+let capturedNewSession: ((options?: any) => Promise<{ cancelled: boolean }>) | null = null;
 
 /** Mark planning as started (called by plan command after sending steer). */
-export function startPlanTracking(cwd: string, paths: any): void {
+export function startPlanTracking(
+  cwd: string,
+  paths: any,
+  newSession?: (options?: any) => Promise<{ cancelled: boolean }>,
+): void {
   planningActive = true;
   planCwd = cwd;
   plansBefore = listPlans(paths, cwd);
+  capturedNewSession = newSession ?? null;
 }
 
 /** Cancel plan tracking (e.g., session change). */
@@ -25,6 +32,7 @@ export function cancelPlanTracking(): void {
   planningActive = false;
   plansBefore = [];
   planCwd = "";
+  capturedNewSession = null;
 }
 
 /** Whether a planning session is currently active. */
@@ -81,14 +89,14 @@ async function executeApproveFlow(
 ): Promise<void> {
   const prompt = buildExecutionPrompt(planContent, planPath);
 
-  if (typeof ctx.newSession === "function") {
-    const result = await ctx.newSession();
+  if (capturedNewSession) {
+    const result = await capturedNewSession();
     if (result?.cancelled) {
       // User dismissed the new-session prompt — keep plan state intact.
       ctx.ui.notify("Session start cancelled. Plan saved; run /supi:plan again to execute.");
       return;
     }
-    ctx.sendUserMessage(prompt);
+    platform.sendUserMessage(prompt);
   } else {
     // Fallback: headless/SDK mode — steer in the current session.
     platform.sendMessage(

package/src/platform/omp.ts

@@ -14,6 +14,7 @@ export function createOmpAdapter(api: any): Platform {
         triggerTurn: opts?.triggerTurn ?? false,
       });
     },
+    sendUserMessage: (text: string) => api.sendUserMessage(text),
     registerMessageRenderer: (type, fn) => api.registerMessageRenderer(type, fn),
 
     setModel(model: string): void {

package/src/platform/test-utils.ts

@@ -11,6 +11,7 @@ export function createMockPlatform(overrides?: Partial<Platform>): Platform {
     getActiveTools: mock(() => []),
     exec: mock(async () => ({ stdout: "", stderr: "", code: 0 })),
     sendMessage: mock(),
+    sendUserMessage: mock(),
     registerMessageRenderer: mock(),
     on: mock(),
     createAgentSession: mock(async () => ({

package/src/platform/types.ts

@@ -125,6 +125,7 @@ export interface Platform {
   // Execution
   exec(cmd: string, args: string[], opts?: ExecOptions): Promise<ExecResult>;
   sendMessage(content: any, opts?: SendMessageOptions): void;
+  sendUserMessage(text: string): void;
 
   // Introspection
   getActiveTools(): string[];

package/src/release/commit-types.ts

@@ -13,6 +13,7 @@ export const VALID_COMMIT_TYPES = [
   "test",
   "docs",
   "style",
+  "release",
 ] as const;
 
 export type ConventionalCommitType = (typeof VALID_COMMIT_TYPES)[number];
@@ -32,4 +33,5 @@ export const MAINTENANCE_TYPES = new Set<ConventionalCommitType>([
   "test",
   "docs",
   "style",
+  "release",
 ]);

package/src/release/executor.ts

@@ -2,6 +2,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ReleaseChannel, ReleaseResult } from "../types.js";
+import { commitStaged } from "../git/commit.js";
 
 type ExecFn = (
   cmd: string,
@@ -21,6 +22,8 @@ export interface ExecuteReleaseOptions {
   dryRun: boolean;
   /** Skip the package.json version write (version was already set locally). */
   skipBump?: boolean;
+  /** Skip creating the git tag (it already exists locally). */
+  skipTag?: boolean;
   /** Optional callback for step-by-step progress reporting. */
   onProgress?: ReleaseProgressFn;
 }
@@ -36,15 +39,19 @@ export interface ExecuteReleaseOptions {
  *   happen (all flags true) so callers can preview without side-effects.
  */
 export async function executeRelease(opts: ExecuteReleaseOptions): Promise<ReleaseResult> {
-  const { exec, cwd, version, changelog, channels, dryRun, skipBump, onProgress } = opts;
+  const { exec, cwd, version, changelog, channels, dryRun, skipBump, skipTag, onProgress } = opts;
   const progress = onProgress ?? (() => {});
 
   if (dryRun) {
     console.log(`[dry-run] Would build (if scripts.build exists)`);
     console.log(`[dry-run] Would bump version to ${version}`);
     console.log(`[dry-run] Would git add -A`);
-    console.log(`[dry-run] Would git commit -m "release: v${version}"`);
-    console.log(`[dry-run] Would git tag -a v${version}`);
+    console.log(`[dry-run] Would git commit -m "chore(release): v${version}"`);
+    if (skipTag) {
+      console.log(`[dry-run] Would skip git tag (already exists locally)`);
+    } else {
+      console.log(`[dry-run] Would git tag -a v${version}`);
+    }
     console.log(`[dry-run] Would git push origin HEAD --follow-tags`);
     for (const ch of channels) {
       console.log(`[dry-run] Would publish to channel: ${ch}`);
@@ -100,25 +107,29 @@ export async function executeRelease(opts: ExecuteReleaseOptions): Promise<Relea
     }
     progress("git-add", "done");
 
-    progress("git-commit", "active", `release: v${version}`);
-    const gitCommit = await exec("git", ["commit", "-m", `release: v${version}`], { cwd });
-    if (gitCommit.code !== 0) {
-      const detail = gitCommit.stderr || gitCommit.stdout || `exit code ${gitCommit.code}`;
-      progress("git-commit", "error", detail);
-      return { version, tagCreated: false, pushed: false, channels: [], error: `git commit: ${detail}` };
+    const commitMessage = `chore(release): v${version}`;
+    progress("git-commit", "active", commitMessage);
+    const commitResult = await commitStaged(exec, cwd, commitMessage);
+    if (!commitResult.success) {
+      progress("git-commit", "error", commitResult.error);
+      return { version, tagCreated: false, pushed: false, channels: [], error: commitResult.error! };
     }
     progress("git-commit", "done");
   }
 
-  progress("git-tag", "active", `v${version}`);
-  const tagMessage = `Release v${version}\n\n${changelog}`;
-  const gitTag = await exec("git", ["tag", "-a", `v${version}`, "-m", tagMessage], { cwd });
-  if (gitTag.code !== 0) {
-    const detail = gitTag.stderr || gitTag.stdout || `exit code ${gitTag.code}`;
-    progress("git-tag", "error", detail);
-    return { version, tagCreated: false, pushed: false, channels: [], error: `git tag: ${detail}` };
+  if (skipTag) {
+    progress("git-tag", "done", "Already exists");
+  } else {
+    progress("git-tag", "active", `v${version}`);
+    const tagMessage = `Release v${version}\n\n${changelog}`;
+    const gitTag = await exec("git", ["tag", "-a", `v${version}`, "-m", tagMessage], { cwd });
+    if (gitTag.code !== 0) {
+      const detail = gitTag.stderr || gitTag.stdout || `exit code ${gitTag.code}`;
+      progress("git-tag", "error", detail);
+      return { version, tagCreated: false, pushed: false, channels: [], error: `git tag: ${detail}` };
+    }
+    progress("git-tag", "done");
   }
-  progress("git-tag", "done");
 
   progress("git-push", "active", "Pushing to origin");
   const gitPush = await exec("git", ["push", "origin", "HEAD", "--follow-tags"], { cwd });

package/src/release/version.ts

@@ -78,4 +78,22 @@ export async function isVersionReleased(
   } catch {
     return false;
   }
-}
+}
+
+/**
+ * Check whether a tag for the given version exists on the remote (origin).
+ * Returns true when `v{version}` is found via `git ls-remote --tags origin`.
+ */
+export async function isTagOnRemote(
+  exec: ExecFn,
+  cwd: string,
+  version: string,
+): Promise<boolean> {
+  try {
+    const tag = version.startsWith("v") ? version : `v${version}`;
+    const result = await exec("git", ["ls-remote", "--tags", "origin", tag], { cwd });
+    return result.code === 0 && result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}

package/bin/.omp/SYSTEM.md

@@ -1,77 +0,0 @@
-# context-mode — MANDATORY routing rules
-
-You have context-mode MCP tools available. These rules are NOT optional — they protect your context window from flooding. A single unrouted command can dump 56 KB into context and waste the entire session.
-
-## BLOCKED commands — do NOT attempt these
-
-### curl / wget — BLOCKED
-Any Bash command containing `curl` or `wget` is intercepted and replaced with an error message. Do NOT retry.
-Instead use:
-- `ctx_fetch_and_index(url, source)` to fetch and index web pages
-- `ctx_execute(language: "javascript", code: "const r = await fetch(...)")` to run HTTP calls in sandbox
-
-### Inline HTTP — BLOCKED
-Any Bash command containing `fetch('http`, `requests.get(`, `requests.post(`, `http.get(`, or `http.request(` is intercepted and replaced with an error message. Do NOT retry with Bash.
-Instead use:
-- `ctx_execute(language, code)` to run HTTP calls in sandbox — only stdout enters context
-
-### WebFetch / Fetch — BLOCKED
-WebFetch and Fetch calls are denied entirely.
-Instead use:
-- `ctx_fetch_and_index(url, source)` then `ctx_search(queries)` to query the indexed content
-
-### Grep — BLOCKED
-Grep calls are intercepted and blocked. Do NOT retry with Grep.
-Instead use:
-- `ctx_search(queries: ["<pattern>"])` to search indexed content
-- `ctx_batch_execute(commands, queries)` to run searches and return compressed results
-- `ctx_execute(language: "shell", code: "grep ...")` to run searches in sandbox
-
-### Find / Glob — BLOCKED
-Find/Glob calls are intercepted and blocked. Do NOT retry with Find/Glob.
-Instead use:
-- `ctx_execute(language: "shell", code: "find ...")` to run in sandbox
-- `ctx_batch_execute(commands, queries)` for multiple searches
-
-### Read (full-file, no limit) — BLOCKED
-Reading an entire file without a `limit` parameter is blocked.
-- If you need to **Edit** the file → re-call Read with `limit` parameter (e.g., `limit: 200`)
-- If you need to **analyze or explore** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context.
-
-## REDIRECTED tools — use sandbox equivalents
-
-### Bash (>20 lines output)
-Bash is ONLY for: `git`, `mkdir`, `rm`, `mv`, `cd`, `ls`, `npm install`, `pip install`, and other short-output commands.
-For everything else, use:
-- `ctx_batch_execute(commands, queries)` — run multiple commands + search in ONE call
-- `ctx_execute(language: "shell", code: "...")` — run in sandbox, only stdout enters context
-
-### Read (for analysis)
-If you are reading a file to **Edit** it → Read with `limit` is correct (Edit needs content in context).
-If you are reading to **analyze, explore, or summarize** → use `ctx_execute_file(path, language, code)` instead. Only your printed summary enters context. The raw file content stays in the sandbox.
-
-## Tool selection hierarchy
-
-1. **GATHER**: `ctx_batch_execute(commands, queries)` — Primary tool. Runs all commands, auto-indexes output, returns search results. ONE call replaces 30+ individual calls.
-2. **FOLLOW-UP**: `ctx_search(queries: ["q1", "q2", ...])` — Query indexed content. Pass ALL questions as array in ONE call.
-3. **PROCESSING**: `ctx_execute(language, code)` | `ctx_execute_file(path, language, code)` — Sandbox execution. Only stdout enters context.
-4. **WEB**: `ctx_fetch_and_index(url, source)` then `ctx_search(queries)` — Fetch, chunk, index, query. Raw HTML never enters context.
-5. **INDEX**: `ctx_index(content, source)` — Store content in FTS5 knowledge base for later search.
-
-## Subagent routing
-
-When spawning subagents (Agent/Task tool), the routing block is automatically injected into their prompt. Bash-type subagents are upgraded to general-purpose so they have access to MCP tools. You do NOT need to manually instruct subagents about context-mode.
-
-## Output constraints
-
-- Keep responses under 500 words.
-- Write artifacts (code, configs, PRDs) to FILES — never return them as inline text. Return only: file path + 1-line description.
-- When indexing content, use descriptive source labels so others can `ctx_search(source: "label")` later.
-
-## ctx commands
-
-| Command | Action |
-|---------|--------|
-| `ctx stats` | Call the `ctx_stats` MCP tool and display the full output verbatim |
-| `ctx doctor` | Call the `ctx_doctor` MCP tool, run the returned shell command, display as checklist |
-| `ctx upgrade` | Call the `ctx_upgrade` MCP tool, run the returned shell command, display as checklist |