gramatr 0.3.62 → 0.3.64

package/bin/gmtr-login.ts

@@ -365,10 +365,26 @@ async function loginBrowser(): Promise<void> {
       console.log('  Sign in with Google or GitHub, approve the device, then return here.\n');
       console.log('  Waiting for authorization...');
 
-      const accessToken = await Promise.race([
-        pollDeviceAuthorization(device.device_code),
-        new Promise<string>((_, reject) => setTimeout(() => reject(new Error('Device login timed out')), device.expires_in * 1000)),
-      ]);
+      // v0.3.63 hotfix: must clear the timeout after the race resolves,
+      // otherwise the orphan setTimeout keeps the Node event loop alive
+      // until expires_in elapses (typically 600s). Symptom: success path
+      // prints "Authenticated successfully" and then hangs until Ctrl+C.
+      let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+      const timeoutPromise = new Promise<string>((_, reject) => {
+        timeoutHandle = setTimeout(
+          () => reject(new Error('Device login timed out')),
+          device.expires_in * 1000,
+        );
+      });
+      let accessToken: string;
+      try {
+        accessToken = await Promise.race([
+          pollDeviceAuthorization(device.device_code),
+          timeoutPromise,
+        ]);
+      } finally {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+      }
 
       const config = readConfig();
       config.token = accessToken;

package/bin/gramatr.ts

@@ -8,7 +8,7 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { detectTargets, findTarget, summarizeDetectedLocalTargets, type IntegrationTargetId } from '../core/targets.ts';
 import { VERSION } from '../core/version.ts';
-import { findStaleArtifacts, runLegacyMigration } from '../core/migration.ts';
+import { findStaleArtifacts, runDeepClean, runLegacyMigration } from '../core/migration.ts';
 import {
   formatDetectionLines,
   formatDoctorLines,
@@ -203,7 +203,7 @@ function installTarget(targetId: IntegrationTargetId): void {
   }
 }
 
-function migrate(apply: boolean): void {
+function migrate(apply: boolean, deep: boolean = false): void {
   const homeDir = homedir();
   const clientDir = process.env.GMTR_DIR || join(homeDir, 'gmtr-client');
   runLegacyMigration({
@@ -213,6 +213,10 @@ function migrate(apply: boolean): void {
     apply,
     log,
   });
+  if (deep) {
+    log('');
+    runDeepClean({ homeDir, apply, log });
+  }
 }
 
 function doctor(): void {
@@ -321,9 +325,13 @@ function main(): void {
     case 'doctor':
       doctor();
       return;
-    case 'migrate':
-      migrate(targetArg === '--apply');
+    case 'migrate': {
+      const flags = positionals.slice(1);
+      const apply = flags.includes('--apply');
+      const deep = flags.includes('--deep');
+      migrate(apply, deep);
       return;
+    }
     case 'upgrade':
       upgrade();
       return;
@@ -341,7 +349,7 @@ function main(): void {
       log('  detect             Show detected CLI platforms');
       log('  doctor             Check installation health');
       log('  upgrade            Upgrade all installed targets');
-      log('  migrate [--apply]  Clean up legacy artifacts');
+      log('  migrate [--apply] [--deep]  Clean up legacy artifacts (--deep also removes PAI/Fabric/aios)');
       log('  help               Show this help');
       log('');
       log('Examples:');

package/bin/lib/config.ts

@@ -0,0 +1,54 @@
+/**
+ * gramatr client config resolver (statusline refactor, #495).
+ *
+ * Single-purpose helper that returns the server URL + auth token with
+ * NO reads of ~/.claude* or ~/gmtr-client/settings.json. This is the
+ * statusline-specific config path; the richer installer auth lives in
+ * core/auth.ts for a reason — this file must stay small and side-effect-free
+ * so it can be loaded in a 2s shim without touching disk more than once.
+ *
+ * Resolution:
+ *   URL   — GMTR_URL → ~/.gmtr.json.url → https://api.gramatr.com
+ *   Token — GMTR_TOKEN → AIOS_MCP_TOKEN → ~/.gmtr.json.token → null
+ */
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface GramatrConfig {
+  url: string;
+  token: string | null;
+}
+
+const DEFAULT_URL = 'https://api.gramatr.com';
+
+function getHome(): string {
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+
+function readGmtrJson(): Record<string, any> | null {
+  const path = join(getHome(), '.gmtr.json');
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function getGramatrConfig(): GramatrConfig {
+  const json = readGmtrJson();
+
+  const url =
+    process.env.GMTR_URL ||
+    (typeof json?.url === 'string' && json.url) ||
+    DEFAULT_URL;
+
+  const token =
+    process.env.GMTR_TOKEN ||
+    process.env.AIOS_MCP_TOKEN ||
+    (typeof json?.token === 'string' && json.token) ||
+    null;
+
+  return { url: url as string, token };
+}

package/bin/lib/git.ts

@@ -0,0 +1,111 @@
+/**
+ * Git state collection for the statusline client (#495).
+ *
+ * Three subprocess calls, not seven:
+ *   1. git rev-parse --show-toplevel   — is this even a repo?
+ *   2. git remote get-url origin       — project_id derivation
+ *   3. git status --porcelain=v2 --branch   — branch + file counts in one call
+ *
+ * A fourth call (git log -1 --format=%cr) runs only when the porcelain output
+ * indicates we have commits, keeping the empty-repo path clean.
+ *
+ * All functions are pure in terms of parseable input → output (parsePorcelain,
+ * parseProjectId) so they can be tested without spawning git.
+ */
+import { execSync } from 'child_process';
+
+export interface GitStateFields {
+  branch: string;
+  ahead: number;
+  behind: number;
+  modified: number;
+  untracked: number;
+  stash: number;
+  last_commit_age: string;
+}
+
+export interface GitInfo {
+  projectId: string;
+  state: GitStateFields;
+}
+
+export function parseProjectId(remoteUrl: string): string {
+  if (!remoteUrl) return '';
+  // Handle both https://github.com/org/repo(.git) and git@github.com:org/repo(.git)
+  const cleaned = remoteUrl.trim().replace(/\.git$/, '');
+  const sshMatch = cleaned.match(/[:/]([^:/]+\/[^:/]+)$/);
+  if (sshMatch) return sshMatch[1];
+  return cleaned;
+}
+
+/**
+ * Parse `git status --porcelain=v2 --branch` output.
+ *
+ * Header lines start with '#'. Entry lines start with '1', '2', 'u', or '?'.
+ * We count:
+ *   branch from `# branch.head <name>`
+ *   ahead/behind from `# branch.ab +N -M`
+ *   modified from '1 ', '2 ', 'u ' entries
+ *   untracked from '? ' entries
+ */
+export function parsePorcelain(out: string): GitStateFields {
+  const state: GitStateFields = {
+    branch: '',
+    ahead: 0,
+    behind: 0,
+    modified: 0,
+    untracked: 0,
+    stash: 0,
+    last_commit_age: '',
+  };
+
+  for (const line of out.split('\n')) {
+    if (!line) continue;
+    if (line.startsWith('# branch.head ')) {
+      state.branch = line.slice('# branch.head '.length).trim();
+    } else if (line.startsWith('# branch.ab ')) {
+      const parts = line.slice('# branch.ab '.length).trim().split(/\s+/);
+      for (const p of parts) {
+        if (p.startsWith('+')) state.ahead = parseInt(p.slice(1), 10) || 0;
+        else if (p.startsWith('-')) state.behind = parseInt(p.slice(1), 10) || 0;
+      }
+    } else if (line[0] === '1' || line[0] === '2' || line[0] === 'u') {
+      state.modified += 1;
+    } else if (line[0] === '?') {
+      state.untracked += 1;
+    }
+  }
+
+  return state;
+}
+
+function execOrNull(cmd: string, cwd: string): string | null {
+  try {
+    return execSync(cmd, { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+  } catch {
+    return null;
+  }
+}
+
+export function getGitState(cwd: string): GitInfo | null {
+  const root = execOrNull('git rev-parse --show-toplevel', cwd);
+  if (!root) return null;
+
+  const remote = execOrNull('git remote get-url origin', cwd) ?? '';
+  const porcelain = execOrNull('git status --porcelain=v2 --branch', cwd) ?? '';
+  const state = parsePorcelain(porcelain);
+
+  // Stash count — cheap single call; returns empty on no stashes
+  const stashRaw = execOrNull('git stash list', cwd) ?? '';
+  state.stash = stashRaw ? stashRaw.split('\n').filter(Boolean).length : 0;
+
+  // Last commit age — only meaningful if branch has commits
+  if (state.branch && state.branch !== '(detached)') {
+    const age = execOrNull('git log -1 --format=%cr', cwd);
+    if (age) state.last_commit_age = age.trim();
+  }
+
+  const projectId = parseProjectId(remote) || 'local';
+
+  return { projectId, state };
+}

package/bin/lib/stdin.ts

@@ -0,0 +1,53 @@
+/**
+ * Minimal stdin reader for the statusline shim (#495).
+ *
+ * Claude Code pipes a JSON blob to statusline commands. We read it with a
+ * hard cap + timeout so a broken pipe never hangs the render.
+ */
+
+export interface CCInput {
+  session_id?: string;
+  cwd?: string;
+  workspace?: { current_dir?: string };
+}
+
+const MAX_STDIN_BYTES = 64 * 1024;
+const STDIN_TIMEOUT_MS = 500;
+
+export async function readStdin(): Promise<CCInput> {
+  // If stdin is a TTY there's nothing to read — return empty immediately.
+  if (process.stdin.isTTY) return {};
+
+  return new Promise((resolve) => {
+    let data = '';
+    let settled = false;
+
+    const finish = (input: CCInput) => {
+      if (settled) return;
+      settled = true;
+      resolve(input);
+    };
+
+    const timer = setTimeout(() => finish({}), STDIN_TIMEOUT_MS);
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk: string) => {
+      data += chunk;
+      if (data.length > MAX_STDIN_BYTES) {
+        data = data.slice(0, MAX_STDIN_BYTES);
+      }
+    });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      try {
+        finish(data.trim() ? (JSON.parse(data) as CCInput) : {});
+      } catch {
+        finish({});
+      }
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      finish({});
+    });
+  });
+}

package/bin/statusline.ts

@@ -1,437 +1,81 @@
 #!/usr/bin/env node
 /**
- * gramatr Status Line — TypeScript rewrite of statusline.sh (#158)
+ * gramatr status line — thin client shim (#495).
  *
- * Single source of truth: gramatr API for server metrics, local for git/env.
- * Replaces 1,383-line bash script with type-safe, testable TypeScript.
+ * The server owns composition and rendering. This file is a pipe:
+ *   1. Read stdin (Claude Code JSON — session_id, cwd)
+ *   2. Collect git state (3 subprocess calls, see lib/git.ts)
+ *   3. POST /api/v1/statusline/render with render_as=native
+ *   4. Write the server's rendered string to stdout
  *
- * Data sources:
- *   API  → entity count, token savings, classifier stats, learning signals, skills, version
- *   Local → git status, context window, Anthropic usage, session label, location/weather (cached)
- *   Stdin → Claude Code JSON (context_window, session_id, model, workspace)
+ * Anti-criteria (enforced by regression grep in CI — see
+ * lib/__tests__/statusline-anti-criteria.test.ts for the tombstone list):
+ *   - No temp-file reads or writes
+ *   - No Claude config reads
+ *   - No legacy client settings reads
+ *   - No display of Claude-owned data (context window, model name)
+ *   - No local caches (statusline is a view, not a database)
+ *   - One and only one network call
+ *
+ * Failure modes are FIRST-CLASS:
+ *   - not a repo → silent (exit 0, nothing written)
+ *   - no token → authentication prompt
+ *   - offline/timeout/non-2xx → offline indicator
  */
 
-import { readFileSync, existsSync, writeFileSync, statSync } from 'fs';
-import { execSync } from 'child_process';
-import { join } from 'path';
-
-// ── Types ──────────────────────────────────────────────────────────────────
-
-interface CCInput {
-  workspace?: { current_dir?: string };
-  cwd?: string;
-  session_id?: string;
-  model?: { display_name?: string };
-  version?: string;
-  cost?: { total_duration_ms?: number };
-  context_window?: {
-    context_window_size?: number;
-    used_percentage?: number;
-    remaining_percentage?: number;
-    total_input_tokens?: number;
-    total_output_tokens?: number;
-  };
-}
+import { getGitState } from './lib/git.js';
+import { getGramatrConfig } from './lib/config.js';
+import { readStdin } from './lib/stdin.js';
 
-interface GramatrStats {
-  server_version: string;
-  entity_count: number;
-  observation_count: number;
-  search_count: number;
-  tokens_saved_total: number;
-  tokens_saved_7d: number;
-  classifications_total: number;
-  classifications_7d: number;
-  operations_1h: number;
-  operations_24h: number;
-  classifier: {
-    level: number;
-    model: string;
-    accuracy: number;
-    feedback_rate: number;
-    total_classifications: number;
-  };
-  learning: {
-    latest: number | null;
-    avg_1d: number | null;
-    avg_1w: number | null;
-    avg_1mo: number | null;
-    count: number;
-  };
-  skills_count: number;
-}
+const CLIENT_TIMEOUT_MS = 2000;
 
-interface GitInfo {
-  projectId: string;  // org/repo from remote, fallback to directory name
-  branch: string;
-  stashCount: number;
-  modified: number;
-  untracked: number;
-  ahead: number;
-  behind: number;
-  lastCommitAge: string;
-  lastCommitColor: string;
-}
+type Size = 'small' | 'medium' | 'large';
 
+async function main(): Promise<void> {
+  const input = await readStdin();
+  const cwd = input.workspace?.current_dir || input.cwd || process.cwd();
 
-
-// ── Config ─────────────────────────────────────────────────────────────────
-
-const HOME = process.env.HOME || '';
-const GMTR_DIR = process.env.GMTR_DIR || join(HOME, 'gmtr-client');
-const STATE_DIR = join(GMTR_DIR, '.state');
-const SETTINGS_PATH = join(HOME, '.claude', 'settings.json');
-
-function getGramatrUrl(): string {
-  try {
-    const claude = JSON.parse(readFileSync(join(HOME, '.claude.json'), 'utf8'));
-    return claude?.mcpServers?.gramatr?.url?.replace('/mcp', '') || 'https://api.gramatr.com';
-  } catch {
-    return 'https://api.gramatr.com';
+  const git = getGitState(cwd);
+  if (!git) {
+    // Not inside a git repo — render nothing, exit clean.
+    return;
   }
-}
-
-function getAuthToken(): string {
-  // Check settings.json first, then env var
-  try {
-    const settings = JSON.parse(readFileSync(join(GMTR_DIR, 'settings.json'), 'utf8'));
-    if (settings?.auth?.token) return settings.auth.token;
-  } catch { /* no settings file */ }
-  return process.env.GMTR_TOKEN || process.env.AIOS_MCP_TOKEN || '';
-}
 
-// ── Cache Helper ───────────────────────────────────────────────────────────
-
-function readCache<T>(path: string, ttlMs: number): T | null {
-  try {
-    if (!existsSync(path)) return null;
-    const stat = statSync(path);
-    if (Date.now() - stat.mtimeMs > ttlMs) return null;
-    return JSON.parse(readFileSync(path, 'utf8'));
-  } catch {
-    return null;
+  const { url, token } = getGramatrConfig();
+  if (!token) {
+    process.stdout.write('  ● grāmatr │ not authenticated — run npx gramatr login\n');
+    return;
   }
-}
-
-function writeCache(path: string, data: unknown): void {
-  try {
-    writeFileSync(path, JSON.stringify(data));
-  } catch { /* non-critical */ }
-}
-
-// ── Colors (24-bit ANSI) ───────────────────────────────────────────────────
-
-// Gray Matter palette — from design-tokens.json (locked 2026-03-28)
-const c = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  // Text hierarchy (warm neutrals)
-  text: '\x1b[38;2;236;236;236m',       // #ECECEC — primary text
-  textSec: '\x1b[38;2;136;136;136m',    // #888888 — secondary
-  textMuted: '\x1b[38;2;192;192;192m',  // #C0C0C0 — muted/labels (dimmer than primary, readable on light backgrounds)
-  // Brand
-  primary: '\x1b[38;2;59;130;246m',     // #3B82F6 — blue accent
-  accent: '\x1b[38;2;96;165;250m',      // #60A5FA — lighter blue
-  // Structural
-  border: '\x1b[38;2;51;51;51m',        // #333333 — separators
-  surface: '\x1b[38;2;26;26;26m',       // #1A1A1A — surface
-  // Semantic
-  success: '\x1b[38;2;74;222;128m',     // #4ADE80
-  warning: '\x1b[38;2;250;204;21m',     // #FACC15
-  error: '\x1b[38;2;248;113;113m',      // #F87171
-  // Bg
-  barBg: '\x1b[48;2;26;26;26m',         // #1A1A1A — context bar empty
-};
-
-function ageColor(age: string): string {
-  if (age.endsWith('m') && parseInt(age) < 30) return c.success;
-  if (age.endsWith('h') && parseInt(age) < 2) return c.accent;
-  if (age.endsWith('d') && parseInt(age) < 2) return c.warning;
-  return c.error;
-}
 
-// ── Data Fetchers ──────────────────────────────────────────────────────────
-
-async function fetchGramatrStats(): Promise<GramatrStats | null> {
-  const cached = readCache<GramatrStats>(join(STATE_DIR, 'api-stats-cache.json'), 60_000);
-  if (cached) return cached;
-
-  const url = getGramatrUrl();
-  const token = getAuthToken();
-  if (!token) return null;
+  const envSize = process.env.GMTR_STATUSLINE_SIZE;
+  const size: Size =
+    envSize === 'small' || envSize === 'medium' || envSize === 'large' ? envSize : 'medium';
 
   try {
-    const resp = await fetch(`${url}/api/v1/stats/statusline`, {
-      headers: { 'Authorization': `Bearer ${token}`, 'Accept': 'application/json' },
-      signal: AbortSignal.timeout(5000),
-    });
-    if (!resp.ok) {
-      // Fallback: read from local files if API not available yet
-      return readLocalStats();
-    }
-    const data = await resp.json() as GramatrStats;
-    writeCache(join(STATE_DIR, 'api-stats-cache.json'), data);
-    return data;
-  } catch {
-    // API unavailable — fall back to local files
-    return readLocalStats();
-  }
-}
-
-function readLocalStats(): GramatrStats | null {
-  // Backward-compatible: read from /tmp/ files (same as bash version)
-  try {
-    const stats = existsSync('/tmp/gmtr-stats.json')
-      ? JSON.parse(readFileSync('/tmp/gmtr-stats.json', 'utf8'))
-      : {};
-    const savings = existsSync('/tmp/gmtr-classification-savings.json')
-      ? JSON.parse(readFileSync('/tmp/gmtr-classification-savings.json', 'utf8'))
-      : {};
-
-    // Sum tokens from history
-    let totalTokensSaved = 0;
-    let ops1h = 0;
-    let ops24h = 0;
-    const now = Date.now();
-    if (existsSync('/tmp/gmtr-op-history.jsonl')) {
-      const lines = readFileSync('/tmp/gmtr-op-history.jsonl', 'utf8').trim().split('\n');
-      for (const line of lines) {
-        try {
-          const entry = JSON.parse(line);
-          totalTokensSaved += entry.tokens_saved || 0;
-          const age = now - (entry.timestamp || 0);
-          if (age < 3600_000) ops1h++;
-          if (age < 86400_000) ops24h++;
-        } catch { /* skip bad lines */ }
-      }
-    }
-
-    return {
-      server_version: savings.server_version || '',
-      entity_count: stats.entity_count || 0,
-      observation_count: stats.observation_count || 0,
-      search_count: stats.search_count || 0,
-      tokens_saved_total: 0,
-      tokens_saved_7d: 0,
-      classifications_total: 0,
-      classifications_7d: 0,
-      operations_1h: ops1h,
-      operations_24h: ops24h,
-      classifier: {
-        level: stats.classifier_level || 0,
-        model: stats.classifier_model || savings.classifier_model || '',  // previously: qwen_model
-        accuracy: stats.accuracy || 0,
-        feedback_rate: stats.feedback_rate || 0,
-        total_classifications: stats.total_classifications || 0,
+    const resp = await fetch(`${url}/api/v1/statusline/render`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
       },
-      learning: { latest: null, avg_1d: null, avg_1w: null, avg_1mo: null, count: 0 },
-      skills_count: 0,
-    };
-  } catch {
-    return null;
-  }
-}
-
-function getGitInfo(cwd: string): GitInfo | null {
-  try {
-    const run = (cmd: string) => execSync(cmd, { cwd, timeout: 3000, encoding: 'utf8' }).trim();
-
-    // Check if git repo
-    try { run('git rev-parse --git-dir'); } catch { return null; }
-
-    // Resolve project ID: git remote → org/repo, fallback to directory name
-    let projectId = run('git rev-parse --show-toplevel').split('/').pop() || '';
-    try {
-      const remote = run('git remote get-url origin');
-      const match = remote.match(/[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
-      if (match) projectId = `${match[1]}/${match[2]}`;
-    } catch { /* no remote — use directory name */ }
-    const branch = run('git branch --show-current') || 'detached';
-
-    let stashCount = 0;
-    try { stashCount = run('git stash list').split('\n').filter(Boolean).length; } catch {}
-
-    let modified = 0, untracked = 0;
-    try {
-      const status = run('git status --porcelain');
-      for (const line of status.split('\n').filter(Boolean)) {
-        if (line.startsWith('??')) untracked++;
-        else modified++;
-      }
-    } catch {}
-
-    let ahead = 0, behind = 0;
-    try {
-      const counts = run('git rev-list --left-right --count HEAD...@{u}');
-      const [a, b] = counts.split('\t').map(Number);
-      ahead = a || 0;
-      behind = b || 0;
-    } catch {}
-
-    let lastCommitAge = '?';
-    let lastCommitColor = c.slate400;
-    try {
-      const epoch = parseInt(run('git log -1 --format=%ct'));
-      const seconds = Math.floor(Date.now() / 1000) - epoch;
-      if (seconds < 3600) {
-        lastCommitAge = `${Math.floor(seconds / 60)}m`;
-      } else if (seconds < 86400) {
-        lastCommitAge = `${Math.floor(seconds / 3600)}h`;
-      } else {
-        lastCommitAge = `${Math.floor(seconds / 86400)}d`;
-      }
-      lastCommitColor = ageColor(lastCommitAge);
-    } catch {}
+      body: JSON.stringify({
+        project_id: git.projectId,
+        session_id: input.session_id || 'no-session',
+        size,
+        render_as: 'native',
+        git_state: git.state,
+      }),
+      signal: AbortSignal.timeout(CLIENT_TIMEOUT_MS),
+    });
 
-    return { projectId, branch, stashCount, modified, untracked, ahead, behind, lastCommitAge, lastCommitColor };
+    if (!resp.ok) throw new Error(`status ${resp.status}`);
+    const data = (await resp.json()) as { rendered?: string };
+    process.stdout.write(data.rendered ?? '  ● grāmatr │ offline\n');
   } catch {
-    return null;
+    process.stdout.write('  ● grāmatr │ offline\n');
   }
 }
 
-// ── Rendering ──────────────────────────────────────────────────────────────
-
-function formatNumber(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
-  return String(n);
-}
-
-function contextBar(pct: number, width: number): string {
-  const filled = Math.round((pct / 100) * width);
-  let bar = '';
-  for (let i = 0; i < width; i++) {
-    if (i < filled) {
-      const ratio = i / width;
-      if (ratio < 0.4) bar += `${c.success}⛁`;
-      else if (ratio < 0.6) bar += `${c.accent}⛁`;
-      else if (ratio < 0.8) bar += `${c.warning}⛁`;
-      else bar += `${c.error}⛁`;
-    } else {
-      bar += `${c.barBg} ${c.reset}`;
-    }
-  }
-  return bar + c.reset;
-}
-
-function separator(width: number): string {
-  return `  ${c.border}${'─'.repeat(Math.min(width - 4, 72))}${c.reset}`;
-}
-
-interface Heartbeat {
-  effort: string;
-  intent: string;
-  confidence: string;
-  totalMs: number;
-  memoryDelivered: number;
-  stale: boolean;
-}
-
-function getHeartbeat(): Heartbeat {
-  try {
-    const data = JSON.parse(readFileSync('/tmp/gmtr-classification-savings.json', 'utf8'));
-    const age = Date.now() - (data.timestamp || 0);
-    const stale = age > 300_000;
-    const st = data.stage_timing || {};
-    return {
-      effort: data.effort || '',
-      intent: data.intent || '',
-      confidence: data.confidence ? `${Math.round(data.confidence * 100)}%` : '',
-      totalMs: st.total_ms || data.classifier_time_ms || 0,  // previously: qwen_time_ms
-      memoryDelivered: data.memory_delivered || 0,
-      stale,
-    };
-  } catch {
-    return { effort: '', intent: '', confidence: '', totalMs: 0, memoryDelivered: 0, stale: true };
-  }
-}
-
-function render(input: CCInput, gmtr: GramatrStats | null, git: GitInfo | null): string {
-  const lines: string[] = [];
-  const termWidth = parseInt(process.env.COLUMNS || '80', 10);
-  const barWidth = Math.min(termWidth - 20, 55);
-  const version = gmtr?.server_version ? `v${gmtr.server_version}` : '';
-  const statusIcon = gmtr ? `${c.success}●${c.reset}` : `${c.error}○${c.reset}`;
-  const hb = getHeartbeat();
-
-  // ── LINE 1: BRAND + HEARTBEAT ──
-  let heartbeatText = '';
-  if (!hb.stale && hb.effort) {
-    heartbeatText = `${c.text}${hb.effort}/${hb.intent}${c.reset} ${c.accent}${hb.confidence}${c.reset} ${c.textMuted}${hb.totalMs}ms${c.reset}`;
-    if (hb.memoryDelivered > 0) {
-      heartbeatText += ` ${c.success}◇${hb.memoryDelivered} memories${c.reset}`;
-    }
-  }
-  const brandLine = `  ${c.border}──${c.reset} ${statusIcon} ` +
-    `${c.primary}grāmatr${c.reset} ` +
-    `${c.textMuted}${version}${c.reset}` +
-    (heartbeatText ? ` ${c.border}│${c.reset} ${heartbeatText}` : '') +
-    ` ${c.border}│${c.reset} ${c.textMuted}gramatr.com${c.reset}`;
-  lines.push(brandLine);
-
-  // ── LINE 2: CONTEXT ──
-  const ctxPct = input.context_window?.used_percentage || 0;
-  lines.push(separator(termWidth));
-  lines.push(`  ${c.accent}◉${c.reset} ${c.textMuted}CONTEXT:${c.reset} ${contextBar(ctxPct, barWidth)} ${c.text}${Math.round(ctxPct)}%${c.reset}`);
-
-  // ── LINE 3: PROJECT ──
-  if (git) {
-    lines.push(separator(termWidth));
-    lines.push(
-      `  ${c.primary}◈${c.reset} ${c.text}${git.projectId}${c.reset}` +
-      ` ${c.border}│${c.reset} ${c.accent}${git.branch}${c.reset}`
-    );
-  }
-
-  // ── LINE 5: GRAMATR INTELLIGENCE ──
-  if (gmtr) {
-    lines.push(separator(termWidth));
-    const cl = gmtr.classifier;
-    const level = cl.level > 0 ? `L${cl.level}` : '—';
-    const savedWeek = formatNumber(gmtr.tokens_saved_7d || 0);
-    const savedTotal = formatNumber(gmtr.tokens_saved_total || 0);
-    lines.push(
-      `  ${c.primary}◎${c.reset}` +
-      ` ${c.accent}⬢${formatNumber(gmtr.entity_count)}${c.reset}${c.textMuted} entities${c.reset}` +
-      ` ${c.border}│${c.reset} ${c.accent}◇${formatNumber(gmtr.observation_count)}${c.reset}${c.textMuted} obs${c.reset}` +
-      ` ${c.border}│${c.reset} ${c.primary}${level}${c.reset}` +
-      ` ${c.border}│${c.reset} ${c.textMuted}saved:${c.reset} ${c.success}${savedWeek}/wk${c.reset} ${c.text}${savedTotal}/all${c.reset}`
-    );
-  }
-
-  lines.push(separator(termWidth));
-  return lines.join('\n');
-}
-
-// ── Main ───────────────────────────────────────────────────────────────────
-
-async function main() {
-  // Read CC JSON from stdin
-  let input: CCInput = {};
-  try {
-    const chunks: Buffer[] = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(Buffer.from(chunk));
-    }
-    const raw = Buffer.concat(chunks).toString('utf8');
-    if (raw.trim()) input = JSON.parse(raw);
-  } catch { /* no stdin or bad JSON */ }
-
-  const cwd = input.workspace?.current_dir || input.cwd || process.cwd();
-
-  // Fetch gramatr stats
-  const gmtr = await fetchGramatrStats();
-
-  // Git is sync (fast, <100ms)
-  const git = getGitInfo(cwd);
-
-  // Render and output
-  const output = render(input, gmtr, git);
-  process.stdout.write(output + '\n');
-}
-
 main().catch(() => {
-  // Never crash — output minimal fallback
-  process.stdout.write(`  gramatr │ status unavailable\n`);
+  process.stdout.write('  ● grāmatr │ error\n');
 });

package/codex/hooks/user-prompt-submit.ts

@@ -34,6 +34,9 @@ async function main(): Promise<void> {
       projectId,
       sessionId: input.session_id,
       timeoutMs: 15000,
+      // #496 Phase 3: ask the server for a composed [GMTR Status] block.
+      includeStatusline: true,
+      statuslineSize: 'small',
     });
     const route = result.route as RouteResponse | null;
 

package/core/formatting.ts

@@ -40,7 +40,19 @@ function formatMemoryContext(route: RouteResponse): string[] {
 }
 
 export function buildUserPromptAdditionalContext(route: RouteResponse): string {
-  const lines = ['[GMTR Intelligence]'];
+  const lines: string[] = [];
+
+  // Cross-tool statusline injection (#496 Phase 3). When the server returns
+  // a composed markdown block, prepend it so Codex / Gemini surface gramatr
+  // status at the top of every turn. Claude Code's routing call leaves the
+  // include_statusline flag off (ISC-A1 of #496) because CC has a native
+  // terminal statusline and we must not double-inject.
+  if (typeof route.statusline_markdown === 'string' && route.statusline_markdown.trim()) {
+    lines.push(route.statusline_markdown.trim());
+    lines.push('');
+  }
+
+  lines.push('[GMTR Intelligence]');
   const classification = route.classification;
 
   if (classification) {

package/core/migration.ts

@@ -1,7 +1,242 @@
-import { cpSync, existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { buildClaudeHooksFile } from './install.ts';
 
+// ── Deep clean: PAI / Fabric / aios artifact removal ─────────────────────────
+//
+// `gramatr migrate --deep` detects and removes PAI, Fabric, and aios
+// leftovers from ~/.claude/{commands,skills} and from MCP server registries.
+// Always dry-run unless --apply. Always backs up to ~/.claude/backups/
+// before deleting. Conservative: deny-list only, never blanket-deletes.
+
+/**
+ * Slash command + skill name patterns that identify PAI/Fabric/aios artifacts.
+ * Match is case-insensitive against the basename (without .md extension).
+ */
+export const DEEP_CLEAN_DENY_PATTERNS: RegExp[] = [
+  /^pai[-_]/i,
+  /^pai$/i,
+  /^fabric[-_]/i,
+  /^fabric$/i,
+  /^aios[-_]/i,
+  /^aios$/i,
+  /^extract[-_]?wisdom/i,
+  /^extract[-_]/i,
+  /^analyze[-_]/i,
+  /^summarize[-_]/i,
+  /^create[-_]?prompt/i,
+  /^write[-_]?essay/i,
+  /^write[-_]?story/i,
+  /^get[-_]?wow/i,
+  /^improve[-_]?prompt/i,
+  /^official[-_]?pattern/i,
+  /^pattern[-_]/i,
+  /^council$/i,
+  /^prompting$/i,
+  /^becreative$/i,
+  /^beexpert$/i,
+];
+
+/**
+ * MCP server keys that are PAI/Fabric/aios remnants (case-insensitive).
+ * The legacy migration already strips `aios`. This adds the rest.
+ */
+export const DEEP_CLEAN_MCP_DENY_KEYS: RegExp[] = [
+  /^aios/i,
+  /^pai$/i,
+  /^pai[-_]/i,
+  /^fabric/i,
+];
+
+/**
+ * Slash commands gramatr itself ships. Always preserved by deep-clean.
+ * Both legacy `gmtr-*` / `GMTR-*` and the new lowercase `gramatr-*` per #500.
+ */
+export const GRAMATR_OWNED_COMMANDS: Set<string> = new Set([
+  'gramatr-algorithm.md',
+  'gramatr-init.md',
+  'gramatr-login.md',
+  'gramatr-query.md',
+  'gramatr-recall.md',
+  'gramatr-remember.md',
+  'GMTR-ALGORITHM.md',
+  'gmtr-init.md',
+  'gmtr-login.md',
+  'gmtr-query.md',
+  'gmtr-recall.md',
+  'gmtr-remember.md',
+]);
+
+export interface DeepCleanArtifact {
+  kind: 'command-file' | 'skill-dir' | 'mcp-server-entry';
+  path: string;
+  reason: string;
+  // For mcp-server-entry: which file the entry lives in + the key.
+  mcpFile?: string;
+  mcpKey?: string;
+}
+
+export interface DeepCleanResult {
+  artifacts: DeepCleanArtifact[];
+  backupDir?: string;
+}
+
+function matchesDenyPattern(name: string): boolean {
+  const stem = name.replace(/\.md$/i, '');
+  return DEEP_CLEAN_DENY_PATTERNS.some((rx) => rx.test(stem));
+}
+
+function matchesMcpDenyKey(key: string): boolean {
+  return DEEP_CLEAN_MCP_DENY_KEYS.some((rx) => rx.test(key));
+}
+
+/**
+ * Detect PAI/Fabric/aios cruft. Read-only — never modifies the filesystem.
+ */
+export function findDeepCleanArtifacts(homeDir: string): DeepCleanArtifact[] {
+  const out: DeepCleanArtifact[] = [];
+
+  // 1. ~/.claude/commands/*.md — flag any matching deny pattern OR (when not
+  //    in the gramatr allowlist AND matching a known PAI prefix). User's own
+  //    custom commands are NEVER touched unless they match a deny pattern.
+  const commandsDir = join(homeDir, '.claude', 'commands');
+  if (existsSync(commandsDir) && statSync(commandsDir).isDirectory()) {
+    for (const entry of readdirSync(commandsDir)) {
+      if (!entry.endsWith('.md')) continue;
+      if (GRAMATR_OWNED_COMMANDS.has(entry)) continue;
+      if (matchesDenyPattern(entry)) {
+        out.push({
+          kind: 'command-file',
+          path: join(commandsDir, entry),
+          reason: 'PAI/Fabric/aios slash command (matches deny pattern)',
+        });
+      }
+    }
+  }
+
+  // 2. ~/.claude/skills/*/ — flag any directory matching deny pattern.
+  //    gramatr ships zero skills today; anything matching the deny patterns
+  //    is definitely cruft. We do NOT blanket-delete the whole skills/ dir.
+  const skillsDir = join(homeDir, '.claude', 'skills');
+  if (existsSync(skillsDir) && statSync(skillsDir).isDirectory()) {
+    for (const entry of readdirSync(skillsDir)) {
+      const path = join(skillsDir, entry);
+      if (!statSync(path).isDirectory()) continue;
+      if (matchesDenyPattern(entry)) {
+        out.push({
+          kind: 'skill-dir',
+          path,
+          reason: 'PAI/Fabric skill directory (matches deny pattern)',
+        });
+      }
+    }
+  }
+
+  // 3. ~/.claude.json mcpServers + ~/.claude/mcp.json — flag deny-key entries.
+  for (const mcpFile of [join(homeDir, '.claude.json'), join(homeDir, '.claude', 'mcp.json')]) {
+    if (!existsSync(mcpFile)) continue;
+    let parsed: JsonObject;
+    try {
+      parsed = JSON.parse(readFileSync(mcpFile, 'utf8')) as JsonObject;
+    } catch {
+      continue;
+    }
+    const servers = isRecord(parsed.mcpServers) ? parsed.mcpServers : null;
+    if (!servers) continue;
+    for (const key of Object.keys(servers)) {
+      if (matchesMcpDenyKey(key)) {
+        out.push({
+          kind: 'mcp-server-entry',
+          path: `${mcpFile}#mcpServers.${key}`,
+          reason: `PAI/Fabric/aios MCP server entry "${key}"`,
+          mcpFile,
+          mcpKey: key,
+        });
+      }
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Run a deep-clean. Dry-run unless apply=true. When applying, backs up every
+ * removed artifact to ~/.claude/backups/gramatr-deep-clean-<timestamp>/ before
+ * deletion (full reversibility).
+ */
+export function runDeepClean(opts: {
+  homeDir: string;
+  apply: boolean;
+  log?: (message: string) => void;
+}): DeepCleanResult {
+  const { homeDir, apply, log } = opts;
+  const artifacts = findDeepCleanArtifacts(homeDir);
+
+  log?.('gramatr deep clean (PAI / Fabric / aios)');
+  log?.(`Mode: ${apply ? 'apply' : 'dry-run'}`);
+  log?.(`Found ${artifacts.length} artifact(s)`);
+
+  if (artifacts.length === 0) {
+    log?.('Nothing to clean. Already gramatr-only.');
+    return { artifacts };
+  }
+
+  // Group + display
+  const byKind = new Map<string, DeepCleanArtifact[]>();
+  for (const a of artifacts) {
+    const arr = byKind.get(a.kind) ?? [];
+    arr.push(a);
+    byKind.set(a.kind, arr);
+  }
+  for (const [kind, list] of byKind) {
+    log?.(`\n${kind} (${list.length}):`);
+    for (const a of list) log?.(`  ${a.path}  — ${a.reason}`);
+  }
+
+  if (!apply) {
+    log?.('\nDry-run only. Re-run with --apply to remove these (with backup).');
+    return { artifacts };
+  }
+
+  // ─── APPLY MODE ───
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupDir = join(homeDir, '.claude', 'backups', `gramatr-deep-clean-${ts}`);
+  mkdirSync(backupDir, { recursive: true });
+  log?.(`\nBacking up to ${backupDir}`);
+
+  for (const artifact of artifacts) {
+    if (artifact.kind === 'command-file') {
+      const dest = join(backupDir, 'commands', artifact.path.split('/').pop() ?? 'unknown');
+      mkdirSync(join(backupDir, 'commands'), { recursive: true });
+      cpSync(artifact.path, dest);
+      rmSync(artifact.path, { force: true });
+      log?.(`  removed ${artifact.path}`);
+    } else if (artifact.kind === 'skill-dir') {
+      const dest = join(backupDir, 'skills', artifact.path.split('/').pop() ?? 'unknown');
+      mkdirSync(join(backupDir, 'skills'), { recursive: true });
+      cpSync(artifact.path, dest, { recursive: true });
+      rmSync(artifact.path, { recursive: true, force: true });
+      log?.(`  removed ${artifact.path}`);
+    } else if (artifact.kind === 'mcp-server-entry') {
+      // Strip the entry from the JSON file. Backup the original file once.
+      if (!artifact.mcpFile || !artifact.mcpKey) continue;
+      const fileBackup = join(backupDir, artifact.mcpFile.split('/').pop() ?? 'mcp.json');
+      if (!existsSync(fileBackup)) cpSync(artifact.mcpFile, fileBackup);
+      const parsed = JSON.parse(readFileSync(artifact.mcpFile, 'utf8')) as JsonObject;
+      if (isRecord(parsed.mcpServers)) {
+        const next = { ...parsed.mcpServers };
+        delete next[artifact.mcpKey];
+        parsed.mcpServers = next;
+        writeFileSync(artifact.mcpFile, `${JSON.stringify(parsed, null, 2)}\n`);
+      }
+      log?.(`  stripped ${artifact.path}`);
+    }
+  }
+
+  log?.(`\nDone. ${artifacts.length} artifact(s) removed. Backup: ${backupDir}`);
+  return { artifacts, backupDir };
+}
+
 const MANAGED_EVENTS = [
   'PreToolUse',
   'PostToolUse',

package/core/routing.ts

@@ -20,6 +20,14 @@ export async function routePrompt(options: {
   projectId?: string;
   sessionId?: string;
   timeoutMs?: number;
+  /**
+   * Cross-tool statusline injection (#496). When true, the server attaches a
+   * composed [GMTR Status] markdown block to the route response. Hooks for
+   * Codex and Gemini set this; the Claude Code path leaves it false because
+   * Claude Code has its own native terminal statusline.
+   */
+  includeStatusline?: boolean;
+  statuslineSize?: 'small' | 'medium' | 'large';
 }): Promise<{ route: RouteResponse | null; error: MctToolCallError | null }> {
   const result = await callMcpToolDetailed<RouteResponse>(
     'gmtr_route_request',
@@ -27,6 +35,8 @@ export async function routePrompt(options: {
       prompt: options.prompt,
       ...(options.projectId ? { project_id: options.projectId } : {}),
       ...(options.sessionId ? { session_id: options.sessionId } : {}),
+      ...(options.includeStatusline ? { include_statusline: true } : {}),
+      ...(options.statuslineSize ? { statusline_size: options.statuslineSize } : {}),
     },
     options.timeoutMs ?? 15000,
   );

package/core/types.ts

@@ -64,6 +64,7 @@ export interface ContextPreLoadPlan {
 
 export interface RouteResponse {
   classification?: RouteClassification;
+  statusline_markdown?: string;
   capability_audit?: CapabilityAuditResult;
   phase_template?: PhaseTemplate;
   quality_gate_config?: QualityGateConfig;

package/gemini/hooks/user-prompt-submit.ts

@@ -34,6 +34,9 @@ async function main(): Promise<void> {
       projectId,
       sessionId: input.session_id,
       timeoutMs: 15000,
+      // #496 Phase 3: ask the server for a composed [GMTR Status] block.
+      includeStatusline: true,
+      statuslineSize: 'small',
     });
     const route = result.route as RouteResponse | null;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gramatr",
-  "version": "0.3.62",
+  "version": "0.3.64",
   "description": "grāmatr — context engineering layer for AI coding agents. Every prompt gets a pre-computed intelligence packet: decision routing, capability audit, behavioral directives, memory pre-load, and ISC scaffolds. Continuity across sessions for Claude Code, Codex, and Gemini CLI.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",