@jstn-sdk/rcs 0.1.0 → 0.1.1

package/src/scripts/surface-taxonomy.ts

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const SURFACE_CLASSES = ['canonical', 'operator', 'internal', 'historical'] as const;
+export const SURFACE_DOMAINS = ['roblox-studio', 'creator-runtime', 'archive'] as const;
+export const SURFACE_AUDIENCES = ['creator', 'operator', 'internal', 'archive'] as const;
+export const ARTIFACT_TYPES = ['prompt', 'skill', 'mission', 'sandbox'] as const;
+
+export type SurfaceClass = (typeof SURFACE_CLASSES)[number];
+export type SurfaceDomain = (typeof SURFACE_DOMAINS)[number];
+export type SurfaceAudience = (typeof SURFACE_AUDIENCES)[number];
+export type ArtifactType = (typeof ARTIFACT_TYPES)[number];
+
+export interface SurfaceTaxonomyRecord {
+  path: string;
+  title: string;
+  description: string;
+  surfaceClass: SurfaceClass;
+  domain: SurfaceDomain;
+  audience: SurfaceAudience;
+  artifactType: ArtifactType;
+}
+
+const SURFACE_MAP_PATH = 'docs/reference/surface-map.md';
+
+const REMOVED_GENERIC_LABEL_PATTERNS: RegExp[] = [
+  /\bfrontend-ui-ux\b/i,
+  /\bproduct-manager\b/i,
+  /\bproduct-analyst\b/i,
+  /\bux-researcher\b/i,
+  /\binformation-architect\b/i,
+  /\bqa-tester\b/i,
+  /\bquality-strategist\b/i,
+  /\bquality-reviewer\b/i,
+  /\bapi-reviewer\b/i,
+  /\bperformance-reviewer\b/i,
+];
+
+const GUARDED_ENTERPRISE_PATTERNS: RegExp[] = [
+  /\bDTO\b/i,
+  /\bmicroservice\b/i,
+  /\btenant\b/i,
+  /\bSaaS user\b/i,
+  /\bCRUD app\b/i,
+  /\bweb-app\b/i,
+  /\bdashboard\b/i,
+];
+
+const ENTERPRISE_GUARD_ALLOWLIST = new Set([
+  'skills/blueprint/SKILL.md',
+  'skills/forge/SKILL.md',
+]);
+
+function listSurfacePaths(root: string): string[] {
+  const promptPaths = readdirSync(join(root, 'prompts'))
+    .filter((file) => file.endsWith('.md'))
+    .map((file) => join('prompts', file));
+
+  const skillPaths = readdirSync(join(root, 'skills'))
+    .map((dir) => join('skills', dir, 'SKILL.md'))
+    .filter((path) => existsSync(join(root, path)));
+
+  const missionPaths = readdirSync(join(root, 'missions'))
+    .flatMap((dir) => [join('missions', dir, 'mission.md'), join('missions', dir, 'sandbox.md')])
+    .filter((path) => existsSync(join(root, path)));
+
+  return [...promptPaths, ...skillPaths, ...missionPaths].sort();
+}
+
+function parseFrontmatter(raw: string): { frontmatter: Record<string, string>; content: string } | null {
+  const normalized = raw.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return null;
+  const frontmatter: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const index = line.indexOf(':');
+    if (index === -1) continue;
+    const key = line.slice(0, index).trim();
+    let value = line.slice(index + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key) frontmatter[key] = value;
+  }
+  return { frontmatter, content: match[2] };
+}
+
+function deriveExpectedArtifactType(path: string): ArtifactType {
+  if (path.startsWith('prompts/')) return 'prompt';
+  if (path.startsWith('skills/')) return 'skill';
+  if (path.endsWith('/mission.md')) return 'mission';
+  return 'sandbox';
+}
+
+function deriveFallbackTitle(path: string, content: string): string {
+  const heading = content.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  if (heading) return heading;
+  if (path.endsWith('/SKILL.md')) return path.split('/').slice(-2, -1)[0];
+  if (path.endsWith('/sandbox.md')) return `${path.split('/').slice(-2, -1)[0]} sandbox`;
+  const leaf = path.split('/').pop() ?? path;
+  return leaf.replace(/\.md$/i, '');
+}
+
+export function collectSurfaceTaxonomy(root = process.cwd()): SurfaceTaxonomyRecord[] {
+  return listSurfacePaths(root).map((path) => {
+    const raw = readFileSync(join(root, path), 'utf8');
+    const parsed = parseFrontmatter(raw);
+    if (!parsed) {
+      throw new Error(`surface_taxonomy_missing_frontmatter:${path}`);
+    }
+
+    const surfaceClass = parsed.frontmatter['surface-class'] as SurfaceClass;
+    const domain = parsed.frontmatter.domain as SurfaceDomain;
+    const audience = parsed.frontmatter.audience as SurfaceAudience;
+    const artifactType = parsed.frontmatter['artifact-type'] as ArtifactType;
+
+    return {
+      path,
+      title: parsed.frontmatter.name || deriveFallbackTitle(path, parsed.content),
+      description: parsed.frontmatter.description || '',
+      surfaceClass,
+      domain,
+      audience,
+      artifactType,
+    };
+  });
+}
+
+export function validateSurfaceTaxonomy(records: SurfaceTaxonomyRecord[]): string[] {
+  const errors: string[] = [];
+
+  for (const record of records) {
+    if (!SURFACE_CLASSES.includes(record.surfaceClass)) {
+      errors.push(`invalid_surface_class:${record.path}:${record.surfaceClass}`);
+    }
+    if (!SURFACE_DOMAINS.includes(record.domain)) {
+      errors.push(`invalid_domain:${record.path}:${record.domain}`);
+    }
+    if (!SURFACE_AUDIENCES.includes(record.audience)) {
+      errors.push(`invalid_audience:${record.path}:${record.audience}`);
+    }
+    if (!ARTIFACT_TYPES.includes(record.artifactType)) {
+      errors.push(`invalid_artifact_type:${record.path}:${record.artifactType}`);
+    }
+
+    const expectedArtifactType = deriveExpectedArtifactType(record.path);
+    if (record.artifactType !== expectedArtifactType) {
+      errors.push(`artifact_type_path_mismatch:${record.path}:${record.artifactType}:${expectedArtifactType}`);
+    }
+
+    if (record.surfaceClass === 'canonical') {
+      if (record.domain !== 'roblox-studio') {
+        errors.push(`canonical_domain_mismatch:${record.path}:${record.domain}`);
+      }
+      if (record.audience !== 'creator') {
+        errors.push(`canonical_audience_mismatch:${record.path}:${record.audience}`);
+      }
+    }
+
+    if (record.surfaceClass === 'historical') {
+      if (record.domain !== 'archive') {
+        errors.push(`historical_domain_mismatch:${record.path}:${record.domain}`);
+      }
+      if (record.audience !== 'archive') {
+        errors.push(`historical_audience_mismatch:${record.path}:${record.audience}`);
+      }
+    }
+
+    if (record.path.startsWith('prompts/') && record.surfaceClass !== 'internal') {
+      errors.push(`prompt_surface_class_mismatch:${record.path}:${record.surfaceClass}`);
+    }
+
+    if (record.path.startsWith('prompts/') && record.domain !== 'creator-runtime') {
+      errors.push(`prompt_domain_mismatch:${record.path}:${record.domain}`);
+    }
+
+    if (record.path.startsWith('prompts/') && record.audience !== 'internal') {
+      errors.push(`prompt_audience_mismatch:${record.path}:${record.audience}`);
+    }
+  }
+
+  return errors;
+}
+
+export function validateVocabularyDiscipline(records: SurfaceTaxonomyRecord[], root = process.cwd()): string[] {
+  const errors: string[] = [];
+
+  for (const record of records) {
+    if (record.surfaceClass === 'historical') continue;
+    const content = readFileSync(join(root, record.path), 'utf8');
+
+    for (const pattern of REMOVED_GENERIC_LABEL_PATTERNS) {
+      if (pattern.test(content)) {
+        errors.push(`removed_generic_label:${record.path}:${pattern}`);
+      }
+    }
+
+    if (ENTERPRISE_GUARD_ALLOWLIST.has(record.path)) continue;
+    for (const pattern of GUARDED_ENTERPRISE_PATTERNS) {
+      if (pattern.test(content)) {
+        errors.push(`unguarded_enterprise_term:${record.path}:${pattern}`);
+      }
+    }
+  }
+
+  return errors;
+}
+
+function groupRecords(records: SurfaceTaxonomyRecord[], surfaceClass: SurfaceClass): SurfaceTaxonomyRecord[] {
+  return records
+    .filter((record) => record.surfaceClass === surfaceClass)
+    .sort((left, right) => left.path.localeCompare(right.path));
+}
+
+function renderTable(records: SurfaceTaxonomyRecord[]): string[] {
+  if (records.length === 0) return ['_None._'];
+  return [
+    '| Path | Type | Domain | Audience | Surface |',
+    '| --- | --- | --- | --- | --- |',
+    ...records.map(
+      (record) =>
+        `| \`${record.path}\` | \`${record.artifactType}\` | \`${record.domain}\` | \`${record.audience}\` | ${record.title} |`,
+    ),
+  ];
+}
+
+export function buildSurfaceMapMarkdown(records: SurfaceTaxonomyRecord[]): string {
+  const canonical = groupRecords(records, 'canonical');
+  const operator = groupRecords(records, 'operator');
+  const internal = groupRecords(records, 'internal');
+  const historical = groupRecords(records, 'historical');
+
+  return [
+    '# Surface Map',
+    '',
+    'Status: generated map of active taxonomy-classified prompt, skill, and mission surfaces.',
+    '',
+    'Sources:',
+    '- [`docs/reference/canonical-vocabulary.md`](./canonical-vocabulary.md)',
+    '- [`docs/reference/semantic-design-system.md`](./semantic-design-system.md)',
+    '',
+    '## Counts',
+    '',
+    `- canonical: ${canonical.length}`,
+    `- operator: ${operator.length}`,
+    `- internal: ${internal.length}`,
+    `- historical: ${historical.length}`,
+    `- total tracked surfaces: ${records.length}`,
+    '',
+    '## Canonical Surfaces',
+    '',
+    ...renderTable(canonical),
+    '',
+    '## Operator Surfaces',
+    '',
+    ...renderTable(operator),
+    '',
+    '## Internal Surfaces',
+    '',
+    ...renderTable(internal),
+    '',
+    '## Historical Surfaces',
+    '',
+    ...renderTable(historical),
+    '',
+    '## Additional Repo Lanes',
+    '',
+    '- `AGENTS.md` and `templates/AGENTS.md` remain the orchestration brain and guidance authority.',
+    '- `docs/archive/` is the historical lane; archive content may describe removed surfaces but must not act as active onboarding.',
+    '- `src/catalog/manifest.json`, `templates/catalog-manifest.json`, and `src/catalog/generated/public-catalog.json` are the catalog source/generated contract lane.',
+    '- `dist/` is generated runtime output and should reflect the taxonomy, not redefine it.',
+    '',
+  ].join('\n');
+}
+
+function writeSurfaceMap(root: string): string {
+  const content = buildSurfaceMapMarkdown(collectSurfaceTaxonomy(root));
+  const destination = join(root, SURFACE_MAP_PATH);
+  writeFileSync(destination, `${content}\n`);
+  return destination;
+}
+
+function checkSurfaceMap(root: string): void {
+  const destination = join(root, SURFACE_MAP_PATH);
+  const expected = `${buildSurfaceMapMarkdown(collectSurfaceTaxonomy(root))}\n`;
+  const actual = readFileSync(destination, 'utf8');
+  if (actual !== expected) {
+    throw new Error('surface_map_drift');
+  }
+}
+
+function main(): void {
+  const root = process.cwd();
+  const records = collectSurfaceTaxonomy(root);
+  const taxonomyErrors = validateSurfaceTaxonomy(records);
+  const vocabularyErrors = validateVocabularyDiscipline(records, root);
+  const errors = [...taxonomyErrors, ...vocabularyErrors];
+
+  if (errors.length > 0) {
+    throw new Error(errors.join('\n'));
+  }
+
+  if (process.argv.includes('--check')) {
+    checkSurfaceMap(root);
+    console.log('surface taxonomy check ok');
+    return;
+  }
+
+  const destination = writeSurfaceMap(root);
+  console.log(`wrote ${destination}`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}

package/src/scripts/sync-plugin-mirror.ts

@@ -127,8 +127,11 @@ async function assertRootSkillCatalogConsistency(
 	}
 
 	const rootEntries = await readdir(rootSkillsDir, { withFileTypes: true });
+	const canonicalRootSkillDirs = rootEntries
+		.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+		.map((entry) => entry.name);
 	const unlistedSkillDirs = rootEntries
-		.filter((entry) => entry.isDirectory())
+		.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
 		.map((entry) => entry.name)
 		.filter(
 			(skillName) =>
@@ -145,9 +148,7 @@ async function assertRootSkillCatalogConsistency(
 		);
 	}
 
-	const nonInstallableRootSkillDirs = rootEntries
-		.filter((entry) => entry.isDirectory())
-		.map((entry) => entry.name)
+	const nonInstallableRootSkillDirs = canonicalRootSkillDirs
 		.filter((skillName) => {
 			if (expectedSkillNames.has(skillName)) return false;
 			const status = manifestByName.get(skillName)?.status;

package/src/scripts/tmux-hook-engine.ts

@@ -1,8 +1,8 @@
 import { createHash } from 'crypto';
-import { execFileSync } from 'child_process';
-import { resolveTmuxBinaryForPlatform } from '../utils/platform-command.js';
+import { resolveTmuxBinaryForPlatform, spawnPlatformCommandSync } from '../utils/platform-command.js';
+import { canonicalizeStateMode } from '../mcp/state-paths.js';
 
-export const DEFAULT_ALLOWED_MODES = ['ralph', 'ultrawork', 'team'];
+export const DEFAULT_ALLOWED_MODES = ['forge', 'ultrawork', 'team'];
 export const DEFAULT_MARKER = '[RCS_TMUX_INJECT]';
 const PLACEHOLDER_TARGET_VALUES = new Set([
   'replace-with-tmux-pane-id',
@@ -34,7 +34,9 @@ export function normalizeTmuxHookConfig(raw: any): any {
   }
 
   const allowedModes = Array.isArray(raw.allowed_modes)
-    ? raw.allowed_modes.filter((mode: any) => typeof mode === 'string' && mode.trim() !== '')
+    ? raw.allowed_modes
+      .filter((mode: any) => typeof mode === 'string' && mode.trim() !== '')
+      .map((mode: string) => canonicalizeStateMode(mode))
     : [];
 
   const targetValue = raw.target && typeof raw.target === 'object' && typeof raw.target.value === 'string'
@@ -86,9 +88,14 @@ export function tmuxHookExplicitlyDisablesInjection(raw: any): boolean {
 }
 
 export function pickActiveMode(activeModes: any, allowedModes: any): string | null {
-  const activeSet = new Set((activeModes || []).filter((mode: any) => typeof mode === 'string'));
+  const activeSet = new Set(
+    (activeModes || [])
+      .filter((mode: any) => typeof mode === 'string')
+      .map((mode: string) => canonicalizeStateMode(mode))
+  );
   for (const mode of allowedModes || []) {
-    if (activeSet.has(mode)) return mode;
+    const canonicalMode = typeof mode === 'string' ? canonicalizeStateMode(mode) : mode;
+    if (typeof canonicalMode === 'string' && activeSet.has(canonicalMode)) return canonicalMode;
   }
   return null;
 }
@@ -199,7 +206,7 @@ function isHudStartCommand(startCommand: string): boolean {
  * 2. Scan all panes in the same tmux session for one started with codex
  * 3. Fail closed instead of guessing a shell or HUD pane
  *
- * All callers (auto-nudge, ralph steer, team dispatch, tmux injection) should
+ * All callers (auto-nudge, forge steer, team dispatch, tmux injection) should
  * use this instead of raw `process.env.TMUX_PANE`.
  */
 export function resolveCodexPane(): string {
@@ -207,13 +214,21 @@ export function resolveCodexPane(): string {
   const tmuxCommand = resolveTmuxBinaryForPlatform() || 'tmux';
   if (!envPane) return '';
 
+  const readTmuxOutput = (args: string[]): string => {
+    const { result } = spawnPlatformCommandSync(tmuxCommand, args, {
+      encoding: 'utf-8',
+      timeout: 2000,
+      windowsHide: process.platform === 'win32',
+    });
+    if (result.status !== 0) {
+      throw result.error ?? new Error(String(result.stderr || 'tmux command failed'));
+    }
+    return String(result.stdout ?? '').trim();
+  };
+
   try {
-    const cmd = execFileSync(tmuxCommand, ['display-message', '-t', envPane, '-p', '#{pane_current_command}'], {
-      encoding: 'utf-8', timeout: 2000, windowsHide: process.platform === 'win32',
-    }).trim().toLowerCase();
-    const startCmd = execFileSync(tmuxCommand, ['display-message', '-t', envPane, '-p', '#{pane_start_command}'], {
-      encoding: 'utf-8', timeout: 2000, windowsHide: process.platform === 'win32',
-    }).trim().toLowerCase();
+    const cmd = readTmuxOutput(['display-message', '-t', envPane, '-p', '#{pane_current_command}']).toLowerCase();
+    const startCmd = readTmuxOutput(['display-message', '-t', envPane, '-p', '#{pane_start_command}']).toLowerCase();
     const base = cmd.split('/').pop()?.replace(/^-/, '') || '';
     if (AGENT_COMMANDS.has(base) && !isHudStartCommand(startCmd)) {
       return envPane;
@@ -227,16 +242,13 @@ export function resolveCodexPane(): string {
   }
 
   try {
-    const sessionName = execFileSync(tmuxCommand, ['display-message', '-t', envPane, '-p', '#S'], {
-      encoding: 'utf-8', timeout: 2000,
-      windowsHide: true,
-    }).trim();
+    const sessionName = readTmuxOutput(['display-message', '-t', envPane, '-p', '#S']);
     if (!sessionName) return '';
 
-    const panes = execFileSync(tmuxCommand, [
+    const panes = readTmuxOutput([
       'list-panes', '-s', '-t', sessionName,
       '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}',
-    ], { encoding: 'utf-8', timeout: 2000, windowsHide: process.platform === 'win32' }).trim().split('\n');
+    ]).split('\n');
 
     for (const line of panes) {
       const parts = line.split('\t');

package/templates/AGENTS.md

@@ -14,6 +14,9 @@ When RCS is installed, load the installed prompt/skill/agent surfaces from `~/.c
 
 <guidance_schema_contract>
 Canonical guidance schema for this template is defined in `docs/guidance-schema.md`.
+Canonical vocabulary and semantic system are defined in:
+- `docs/reference/canonical-vocabulary.md`
+- `docs/reference/semantic-design-system.md`
 
 Required schema sections and this template's mapping:
 - **Role & Intent**: title + opening paragraphs.
@@ -28,6 +31,12 @@ Keep runtime marker contracts stable and non-destructive when overlays are appli
 - `<!-- RCS:TEAM:WORKER:START --> ... <!-- RCS:TEAM:WORKER:END -->`
 </guidance_schema_contract>
 
+<semantic_vocabulary_contract>
+- Default to the canonical Roblox-native vocabulary from `docs/reference/canonical-vocabulary.md`.
+- Use creator/player/experience/Studio/Luau/RemoteEvent/DataStore/HUD/plugin language before generic app/API/backend language.
+- Treat removed compatibility labels and generic enterprise abstractions as historical/internal only, not as active onboarding language.
+</semantic_vocabulary_contract>
+
 <operating_principles>
 - Solve the task directly when you can do so safely and well.
 - Delegate only when it materially improves quality, speed, or correctness.
@@ -99,9 +108,9 @@ Default posture: work directly.
 
 Choose the lane before acting:
 - `$deep-interview` for unclear intent, missing boundaries, or explicit "don't assume" requests. This mode clarifies and hands off; it does not implement.
-- `$ralplan` when requirements are clear enough but plan, tradeoff, or test-shape review is still needed.
+- `$blueprint` when requirements are clear enough but plan, tradeoff, or test-shape review is still needed.
 - `$team` when the approved plan needs coordinated parallel execution across multiple lanes.
-- `$ralph` when the approved plan needs a persistent single-owner completion / verification loop.
+- `$forge` when the approved plan needs a persistent single-owner completion / verification loop.
 - **Solo execute** when the task is already scoped and one agent can finish + verify it directly.
 
 Delegate only when it materially improves quality, speed, or safety. Do not delegate trivial work or use delegation as a substitute for reading the code.
@@ -141,7 +150,7 @@ Rules:
 
 <model_routing>
 Match role to task shape:
-- Low complexity: `explore`, `style-reviewer`, `writer`
+- Low complexity: `explore`, `writer`
 - Research/discovery: `explore` for repo lookup, `researcher` for official docs/reference gathering, `dependency-expert` for SDK/API/package evaluation
 - Standard: `executor`, `debugger`, `test-engineer`
 - High complexity: `architect`, `executor`, `critic`
@@ -181,13 +190,13 @@ Keyword routing is implemented primarily by native `UserPromptSubmit` hooks and
 
 Fallback behavior when hook context is unavailable:
 - Explicit `$name` invocations run left-to-right and override implicit keywords.
-- Bare skill names do not activate skills by themselves; skill-name activation requires explicit `$skill` invocation. Natural-language routing phrases may still map to a workflow when they are not just the bare skill name. Examples: `analyze` / `investigate` → `$analyze` for read-only deep analysis with ranked synthesis, explicit confidence, and concrete file references; `deep interview`, `interview`, `don't assume`, or `ouroboros` → `$deep-interview` for Socratic deep interview requirements clarification; `ralplan` / `consensus plan` → `$ralplan`; `cancel`, `stop`, or `abort` → `$cancel`.
+- Bare skill names do not activate skills by themselves; skill-name activation requires explicit `$skill` invocation. Natural-language routing phrases may still map to a workflow when they are not just the bare skill name. Examples: `analyze` / `investigate` → `$analyze` for read-only deep analysis with ranked synthesis, explicit confidence, and concrete file references; `deep interview`, `interview`, `don't assume`, or `ouroboros` → `$deep-interview` for Socratic deep interview requirements clarification; `blueprint` / `consensus plan` → `$blueprint`; `cancel`, `stop`, or `abort` → `$cancel`.
 - Keep the detailed keyword list in `src/hooks/keyword-registry.ts`; do not duplicate that table here.
 
 Runtime availability gate:
-- Treat `autopilot`, `ralph`, `ultrawork`, `ultraqa`, `team`/`swarm`, and `ecomode` as **RCS runtime workflows**, not generic prompt aliases.
+- Treat `autopilot`, `forge`, `ultrawork`, `ultraqa`, `team`/`swarm`, and `ecomode` as **RCS runtime workflows**, not generic prompt aliases.
 - Auto-activate runtime workflows only when the current session is actually running under RCS CLI/runtime (for example, launched via `rcs`, with RCS session overlay/runtime state available, or when the user explicitly asks to run `rcs ...` in the shell).
-- In Codex App or plain Codex sessions without RCS runtime, do **not** treat those keywords alone as activation. Explain that they require RCS CLI runtime support and are not directly available there, and continue with the nearest App-safe surface (`deep-interview`, `ralplan`, `plan`, or native subagents) unless the user explicitly wants you to launch RCS CLI from shell first.
+- In Codex App or plain Codex sessions without RCS runtime, do **not** treat those keywords alone as activation. Explain that they require RCS CLI runtime support and are not directly available there, and continue with the nearest App-safe surface (`deep-interview`, `blueprint`, `plan`, or native subagents) unless the user explicitly wants you to launch RCS CLI from shell first.
 - When deep-interview is active in attached-tmux RCS CLI/runtime, ask each interview round via `rcs question` as a temporary popup-style renderer over the leader pane; after launching `rcs question` in a background terminal, wait for that terminal to finish and read the JSON answer before continuing; preserve the leader pane with `RCS_QUESTION_RETURN_PANE=$TMUX_PANE` (or an explicit `%pane` value) when invoking it through Bash/tool paths, prefer `answers[0].answer` / `answers[]` from the response and use legacy `answer` only as fallback, and respect Stop-hook blocking while a deep-interview question obligation is pending. Deep-interview remains one question per round; do not batch multiple interview rounds into one `questions[]` form. Outside tmux or native surfaces that cannot render `rcs question` should use the native structured question path when available, otherwise ask exactly one concise plain-text question and wait for the answer.
 
 <triage_routing>
@@ -204,8 +213,8 @@ Explicit keywords remain the deterministic control surface when you want explici
 To opt out per prompt with phrases such as `no workflow`, `just chat`, or `plain answer` — the triage layer will suppress context injection for that prompt.
 </triage_routing>
 
-Ralph / Ralplan execution gate:
-- Enforce **ralplan-first** when ralph is active and planning is not complete.
+Forge / Blueprint execution gate:
+- Enforce **blueprint-first** when forge is active and planning is not complete.
 - Planning is complete only after both `.rcs/plans/prd-*.md` and `.rcs/plans/test-spec-*.md` exist.
 - Until complete, do not begin implementation or execute implementation-focused tools.
 </keyword_detection>
@@ -213,7 +222,7 @@ Ralph / Ralplan execution gate:
 ---
 
 <skills>
-Skills are workflow commands. Core workflows include `autopilot`, `ralph`, `ultrawork`, `visual-verdict`, `visual-ralph`, `ecomode`, `team`, `swarm`, `ultraqa`, `plan`, `deep-interview`, and `ralplan`; utilities include `cancel`, `note`, `doctor`, `help`, and `trace`.
+Skills are workflow commands. Core workflows include `autopilot`, `forge`, `ultrawork`, `visual-verdict`, `visual-forge`, `ecomode`, `team`, `swarm`, `ultraqa`, `plan`, `deep-interview`, and `blueprint`; utilities include `cancel`, `note`, `doctor`, `help`, and `trace`.
 </skills>
 
 ---
@@ -271,7 +280,7 @@ Verification loop: define the claim and success criteria, run the smallest valid
 </verification>
 
 <execution_protocols>
-Mode selection: use `$deep-interview` for unclear intent/boundaries; `$ralplan` for consensus on architecture, tradeoffs, or tests; `$team` for approved multi-lane work; `$ralph` for persistent single-owner completion/verification loops; otherwise execute directly in solo mode. Switch modes only when evidence shows the current lane is mismatched or blocked.
+Mode selection: use `$deep-interview` for unclear intent/boundaries; `$blueprint` for consensus on architecture, tradeoffs, or tests; `$team` for approved multi-lane work; `$forge` for persistent single-owner completion/verification loops; otherwise execute directly in solo mode. Switch modes only when evidence shows the current lane is mismatched or blocked.
 
 Command routing:
 - When `USE_RCS_EXPLORE_CMD` enables advisory routing, strongly prefer `rcs explore` as the default surface for simple read-only repository lookup tasks (files, symbols, patterns, relationships).
@@ -288,7 +297,7 @@ Stop / escalate:
 - Stop when the task is verified complete, the user says stop/cancel, or no meaningful recovery path remains.
 - Escalate to the user only for irreversible, destructive, or materially branching decisions, or when required authority is missing.
 - Escalate from worker to leader for blockers, scope expansion, shared ownership conflicts, or mode mismatch.
-- `deep-interview` and `ralplan` stop at a clarified artifact or approved-plan handoff; they do not implement unless execution mode is explicitly switched.
+- `deep-interview` and `blueprint` stop at a clarified artifact or approved-plan handoff; they do not implement unless execution mode is explicitly switched.
 
 Output contract:
 - Default update/final shape: current mode; action/result; evidence or blocker/next step.
@@ -298,7 +307,7 @@ Output contract:
 Parallelization: run independent tasks in parallel, dependent tasks sequentially, and long builds/tests in the background when helpful. Prefer Team mode only when coordination value outweighs overhead. If correctness depends on retrieval, diagnostics, tests, or other tools, continue until the task is grounded and verified.
 
 Anti-slop workflow:
-- Cleanup/refactor/deslop work still follows the same `$deep-interview` -> `$ralplan` -> `$team`/`$ralph` path; use `$ai-slop-cleaner` as a bounded helper inside the chosen execution lane, not as a competing top-level workflow.
+- Cleanup/refactor/deslop work still follows the same `$deep-interview` -> `$blueprint` -> `$team`/`$forge` path; use `$ai-slop-cleaner` as a bounded helper inside the chosen execution lane, not as a competing top-level workflow.
 - Write a cleanup plan before modifying code; lock existing behavior with regression tests first, then make one smell-focused pass at a time.
 - Prefer deletion over addition, and prefer reuse plus boundary repair over new layers.
 - No new dependencies without explicit request.
@@ -307,13 +316,13 @@ Anti-slop workflow:
 
 Visual iteration gate:
 - For visual tasks, run `$visual-verdict` every iteration before the next edit.
-- Persist verdict JSON in `.rcs/state/{scope}/ralph-progress.json`.
+- Persist verdict JSON in `.rcs/state/{scope}/forge-progress.json`.
 
 Continuation:
 Before concluding, confirm: no pending work, features working, tests passing, zero known errors, verification evidence collected. If not, continue.
 
-Ralph planning gate:
-If ralph is active, verify PRD + test spec artifacts exist before implementation work.
+Forge planning gate:
+If forge is active, verify PRD + test spec artifacts exist before implementation work.
 </execution_protocols>
 
 <cancellation>