@jstn-sdk/rcs 0.1.0 → 0.1.1

package/dist/scripts/notify-fallback-watcher.js

@@ -18,7 +18,7 @@ import { isSessionStale, isSessionStateAuthoritativeForCwd, readSessionState } f
 import { DEFAULT_SUBAGENT_ACTIVE_WINDOW_MS, readSubagentSessionSummary, } from '../subagents/tracker.js';
 import { listNotifyCanonicalActiveTeams } from './notify-hook/active-team.js';
 import { sameFilePath } from '../utils/paths.js';
-import { validateSessionId } from '../mcp/state-paths.js';
+import { canonicalizeStateMode, validateSessionId } from '../mcp/state-paths.js';
 import { TEAM_NAME_SAFE_PATTERN } from '../team/contracts.js';
 import { shouldContinueRun } from '../runtime/run-loop.js';
 function argValue(name, fallback = '') {
@@ -118,14 +118,14 @@ const logRotatePath = `${logPath}.1`;
 const logLockPath = `${logPath}.lock`;
 const defaultMaxLogBytes = 10 * 1024 * 1024;
 const maxLogBytes = Math.max(0, asNumber(argValue('--log-max-bytes', process.env.RCS_NOTIFY_FALLBACK_LOG_MAX_BYTES || String(defaultMaxLogBytes)), defaultMaxLogBytes));
-const ralphSteerTimestampPath = join(stateDir, 'ralph-last-steer-at');
-const ralphSteerLockPath = join(stateDir, 'ralph-continue-steer.lock');
+const forgeSteerTimestampPath = join(stateDir, 'forge-last-steer-at');
+const forgeSteerLockPath = join(stateDir, 'forge-continue-steer.lock');
 const watcherOwnerToken = `${process.pid}-${startedAt}-${Math.random().toString(36).slice(2, 10)}`;
-const RALPH_CONTINUE_TEXT = 'Ralph loop active continue';
-const RALPH_CONTINUE_CADENCE_MS = 60_000;
-const RALPH_STEER_LOCK_STALE_MS = 30_000;
-const RALPH_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled']);
-const RALPH_STARTING_PHASE_TIMEOUT_MS = RALPH_CONTINUE_CADENCE_MS * 2;
+const FORGE_CONTINUE_TEXT = 'Forge loop active continue';
+const FORGE_CONTINUE_CADENCE_MS = 60_000;
+const FORGE_STEER_LOCK_STALE_MS = 30_000;
+const FORGE_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled']);
+const FORGE_STARTING_PHASE_TIMEOUT_MS = FORGE_CONTINUE_CADENCE_MS * 2;
 const QUIET_ONCE_EVENT_TYPES = new Set(['watcher_start', 'watcher_once_complete']);
 const fileState = new Map();
 const seenTurnKeys = new Set();
@@ -148,10 +148,10 @@ let lastLeaderNudge = {
     last_tick_at: null,
     last_error: null,
 };
-let lastRalphContinueSteer = {
+let lastForgeContinueSteer = {
     enabled: true,
-    cadence_ms: RALPH_CONTINUE_CADENCE_MS,
-    message: RALPH_CONTINUE_TEXT,
+    cadence_ms: FORGE_CONTINUE_CADENCE_MS,
+    message: FORGE_CONTINUE_TEXT,
     active: false,
     last_state_check_at: null,
     last_sent_at: '',
@@ -164,9 +164,9 @@ let lastRalphContinueSteer = {
     current_phase: '',
     subagent_session_id: '',
     active_subagent_thread_ids: [],
-    shared_timestamp_path: ralphSteerTimestampPath,
+    shared_timestamp_path: forgeSteerTimestampPath,
     shared_last_sent_at: '',
-    singleton_lock_path: ralphSteerLockPath,
+    singleton_lock_path: forgeSteerLockPath,
 };
 let lastParentGuard = {
     reason: '',
@@ -306,13 +306,13 @@ function shouldLogDispatchDrainTick(result) {
     const reason = safeString(record.reason).trim();
     return reason !== '' && reason !== 'worker_context';
 }
-function normalizeRalphContinueSteerState(raw) {
+function normalizeForgeContinueSteerState(raw) {
     if (!raw || typeof raw !== 'object')
-        return { ...lastRalphContinueSteer };
+        return { ...lastForgeContinueSteer };
     return {
         enabled: raw.enabled !== false,
-        cadence_ms: Number.isFinite(raw.cadence_ms) && raw.cadence_ms > 0 ? raw.cadence_ms : RALPH_CONTINUE_CADENCE_MS,
-        message: safeString(raw.message) || RALPH_CONTINUE_TEXT,
+        cadence_ms: Number.isFinite(raw.cadence_ms) && raw.cadence_ms > 0 ? raw.cadence_ms : FORGE_CONTINUE_CADENCE_MS,
+        message: safeString(raw.message) || FORGE_CONTINUE_TEXT,
         active: raw.active === true,
         last_state_check_at: safeString(raw.last_state_check_at) || null,
         last_sent_at: safeString(raw.last_sent_at),
@@ -327,12 +327,12 @@ function normalizeRalphContinueSteerState(raw) {
         active_subagent_thread_ids: Array.isArray(raw.active_subagent_thread_ids)
             ? raw.active_subagent_thread_ids.map((value) => safeString(value).trim()).filter(Boolean)
             : [],
-        shared_timestamp_path: safeString(raw.shared_timestamp_path) || ralphSteerTimestampPath,
+        shared_timestamp_path: safeString(raw.shared_timestamp_path) || forgeSteerTimestampPath,
         shared_last_sent_at: safeString(raw.shared_last_sent_at),
-        singleton_lock_path: safeString(raw.singleton_lock_path) || ralphSteerLockPath,
+        singleton_lock_path: safeString(raw.singleton_lock_path) || forgeSteerLockPath,
     };
 }
-function hasRalphTerminalState(raw) {
+function hasForgeTerminalState(raw) {
     if (!raw || typeof raw !== 'object')
         return true;
     if (raw.active !== true)
@@ -340,28 +340,28 @@ function hasRalphTerminalState(raw) {
     if (!shouldContinueRun(raw))
         return true;
     const phase = safeString(raw.current_phase).trim().toLowerCase();
-    if (phase && RALPH_TERMINAL_PHASES.has(phase))
+    if (phase && FORGE_TERMINAL_PHASES.has(phase))
         return true;
-    if (isStaleRalphStartingPhase(raw))
+    if (isStaleForgeStartingPhase(raw))
         return true;
     if (safeString(raw.completed_at).trim())
         return true;
     return false;
 }
-function isStaleRalphStartingPhase(raw) {
+function isStaleForgeStartingPhase(raw) {
     const phase = safeString(raw.current_phase).trim().toLowerCase();
     if (phase !== 'starting')
         return false;
     const reference = parseIsoMillis(safeString(raw.last_turn_at)) ?? parseIsoMillis(safeString(raw.started_at));
     if (reference === null)
         return false;
-    return Date.now() - reference > RALPH_STARTING_PHASE_TIMEOUT_MS;
+    return Date.now() - reference > FORGE_STARTING_PHASE_TIMEOUT_MS;
 }
 async function loadPersistedWatcherState() {
     const persisted = await readFile(statePath, 'utf-8')
         .then((content) => JSON.parse(content))
         .catch(() => null);
-    lastRalphContinueSteer = normalizeRalphContinueSteerState(persisted?.ralph_continue_steer);
+    lastForgeContinueSteer = normalizeForgeContinueSteerState(persisted?.forge_continue_steer);
     const persistedAutoNudge = persisted?.fallback_auto_nudge;
     if (persistedAutoNudge && typeof persistedAutoNudge === 'object') {
         lastFallbackAutoNudge = {
@@ -394,6 +394,7 @@ async function loadPersistedWatcherState() {
     }
 }
 async function resolveActiveModeState(mode) {
+    const stateMode = canonicalizeStateMode(mode);
     const candidateDirs = [];
     let currentSessionId = '';
     let currentSessionIsLive = false;
@@ -410,7 +411,7 @@ async function resolveActiveModeState(mode) {
     if (!candidateDirs.includes(stateDir))
         candidateDirs.push(stateDir);
     for (const dir of candidateDirs) {
-        if (mode === 'ralph' && dir === stateDir && currentSessionId) {
+        if (mode === 'forge' && dir === stateDir && currentSessionId) {
             return {
                 active: false,
                 reason: currentSessionIsLive ? 'blocked_by_current_session' : 'stale_current_session',
@@ -418,7 +419,7 @@ async function resolveActiveModeState(mode) {
                 state: null,
             };
         }
-        const path = join(dir, `${mode}-state.json`);
+        const path = join(dir, `${stateMode}-state.json`);
         if (!existsSync(path))
             continue;
         const parsed = await readFile(path, 'utf-8')
@@ -426,7 +427,7 @@ async function resolveActiveModeState(mode) {
             .catch(() => null);
         if (!parsed || typeof parsed !== 'object')
             continue;
-        if (mode === 'ralph' && dir !== stateDir && isStaleRalphStartingPhase(parsed)) {
+        if (mode === 'forge' && dir !== stateDir && isStaleForgeStartingPhase(parsed)) {
             return {
                 active: false,
                 reason: 'starting_stale',
@@ -434,7 +435,7 @@ async function resolveActiveModeState(mode) {
                 state: parsed,
             };
         }
-        if (hasRalphTerminalState(parsed)) {
+        if (hasForgeTerminalState(parsed)) {
             return {
                 active: false,
                 reason: 'terminal',
@@ -456,8 +457,8 @@ async function resolveActiveModeState(mode) {
         state: null,
     };
 }
-async function resolveActiveRalphState() {
-    return resolveActiveModeState('ralph');
+async function resolveActiveForgeState() {
+    return resolveActiveModeState('forge');
 }
 async function resolveActiveTeamState() {
     const candidateDirs = [];
@@ -581,7 +582,7 @@ async function resolveActiveTeamState() {
         pane_count: 0,
     };
 }
-async function emitRalphContinueSteer(paneId, message) {
+async function emitForgeContinueSteer(paneId, message) {
     const markedText = `${message} ${DEFAULT_MARKER}`;
     await new Promise((resolve) => {
         const { result: typed } = spawnPlatformCommandSync('tmux', ['send-keys', '-t', paneId, '-l', markedText], { encoding: 'utf-8' });
@@ -602,18 +603,18 @@ async function emitRalphContinueSteer(paneId, message) {
         throw new Error((submitB.stderr || submitB.stdout || submitB.error?.message || '').trim() || 'tmux send-keys C-m failed');
     }
 }
-async function readRalphSteerTimestamp() {
-    return readFile(ralphSteerTimestampPath, 'utf-8')
+async function readForgeSteerTimestamp() {
+    return readFile(forgeSteerTimestampPath, 'utf-8')
         .then((content) => safeString(content).trim())
         .catch(() => '');
 }
-async function writeRalphSteerTimestamp(nowIso) {
-    await mkdir(dirname(ralphSteerTimestampPath), { recursive: true }).catch(() => { });
-    const tempPath = `${ralphSteerTimestampPath}.${process.pid}.tmp`;
+async function writeForgeSteerTimestamp(nowIso) {
+    await mkdir(dirname(forgeSteerTimestampPath), { recursive: true }).catch(() => { });
+    const tempPath = `${forgeSteerTimestampPath}.${process.pid}.tmp`;
     await writeFile(tempPath, `${nowIso}\n`, 'utf-8');
-    await rename(tempPath, ralphSteerTimestampPath);
+    await rename(tempPath, forgeSteerTimestampPath);
 }
-async function readRalphSteerLock(path) {
+async function readForgeSteerLock(path) {
     const raw = await readFile(path, 'utf-8').catch(() => '');
     if (!raw.trim())
         return null;
@@ -629,14 +630,14 @@ async function readRalphSteerLock(path) {
         return null;
     }
 }
-const RALPH_STEER_LOCK_MAX_RETRIES = 5;
-async function withRalphSteerLock(task) {
-    await mkdir(dirname(ralphSteerLockPath), { recursive: true }).catch(() => { });
+const FORGE_STEER_LOCK_MAX_RETRIES = 5;
+async function withForgeSteerLock(task) {
+    await mkdir(dirname(forgeSteerLockPath), { recursive: true }).catch(() => { });
     let acquired = false;
-    for (let attempt = 0; attempt < RALPH_STEER_LOCK_MAX_RETRIES; attempt++) {
+    for (let attempt = 0; attempt < FORGE_STEER_LOCK_MAX_RETRIES; attempt++) {
         let handle;
         try {
-            handle = await open(ralphSteerLockPath, 'wx');
+            handle = await open(forgeSteerLockPath, 'wx');
             const payload = {
                 pid: process.pid,
                 acquired_at: new Date().toISOString(),
@@ -649,15 +650,15 @@ async function withRalphSteerLock(task) {
             const code = error !== null && typeof error === 'object' ? error.code : '';
             if (code !== 'EEXIST')
                 throw error;
-            const existing = await readRalphSteerLock(ralphSteerLockPath);
+            const existing = await readForgeSteerLock(forgeSteerLockPath);
             const lockAgeMs = parseIsoMillis(existing?.acquired_at) ?? 0;
             const stale = existing !== null
-                && (!isPidAlive(existing.pid) || (lockAgeMs > 0 && Date.now() - lockAgeMs > RALPH_STEER_LOCK_STALE_MS));
+                && (!isPidAlive(existing.pid) || (lockAgeMs > 0 && Date.now() - lockAgeMs > FORGE_STEER_LOCK_STALE_MS));
             if (stale) {
-                await unlink(ralphSteerLockPath).catch(() => { });
+                await unlink(forgeSteerLockPath).catch(() => { });
                 continue;
             }
-            lastRalphContinueSteer.last_reason = 'global_lock_busy';
+            lastForgeContinueSteer.last_reason = 'global_lock_busy';
             return null;
         }
         finally {
@@ -665,21 +666,21 @@ async function withRalphSteerLock(task) {
         }
     }
     if (!acquired) {
-        lastRalphContinueSteer.last_reason = 'global_lock_exhausted';
+        lastForgeContinueSteer.last_reason = 'global_lock_exhausted';
         return null;
     }
     try {
         return await task();
     }
     finally {
-        const existing = await readRalphSteerLock(ralphSteerLockPath);
+        const existing = await readForgeSteerLock(forgeSteerLockPath);
         if (existing?.pid === process.pid) {
-            await unlink(ralphSteerLockPath).catch(() => { });
+            await unlink(forgeSteerLockPath).catch(() => { });
         }
     }
 }
-async function readRalphProgressGate(activeRalphState, now) {
-    const subagentSessionId = safeString(activeRalphState?.owner_codex_session_id).trim();
+async function readForgeProgressGate(activeForgeState, now) {
+    const subagentSessionId = safeString(activeForgeState?.owner_codex_session_id).trim();
     if (subagentSessionId) {
         const summary = await readSubagentSessionSummary(cwd, subagentSessionId, {
             now: new Date(now),
@@ -707,23 +708,23 @@ async function readRalphProgressGate(activeRalphState, now) {
     if (progressMs === null) {
         return { allow: false, reason: 'progress_invalid', progress_at: progressAt, subagent_session_id: subagentSessionId };
     }
-    if (now - progressMs < RALPH_CONTINUE_CADENCE_MS) {
+    if (now - progressMs < FORGE_CONTINUE_CADENCE_MS) {
         return { allow: false, reason: 'progress_fresh', progress_at: progressAt, subagent_session_id: subagentSessionId };
     }
     return { allow: true, reason: 'progress_stale', progress_at: progressAt, subagent_session_id: subagentSessionId };
 }
-function shouldSkipRalphContinue(now, candidateIso) {
+function shouldSkipForgeContinue(now, candidateIso) {
     const sharedMs = parseIsoMillis(candidateIso);
-    const localMs = parseIsoMillis(lastRalphContinueSteer.last_sent_at);
-    const startupAnchorIso = lastRalphContinueSteer.cooldown_anchor_at;
+    const localMs = parseIsoMillis(lastForgeContinueSteer.last_sent_at);
+    const startupAnchorIso = lastForgeContinueSteer.cooldown_anchor_at;
     const startupAnchorMs = parseIsoMillis(startupAnchorIso);
     const startupCooldown = sharedMs === null && localMs === null && startupAnchorMs !== null;
     const anchorMs = sharedMs ?? localMs ?? startupAnchorMs ?? 0;
     const anchorIso = sharedMs !== null
         ? candidateIso
-        : (localMs !== null ? lastRalphContinueSteer.last_sent_at : startupAnchorIso);
+        : (localMs !== null ? lastForgeContinueSteer.last_sent_at : startupAnchorIso);
     return {
-        skip: anchorMs > 0 && now - anchorMs < RALPH_CONTINUE_CADENCE_MS,
+        skip: anchorMs > 0 && now - anchorMs < FORGE_CONTINUE_CADENCE_MS,
         reason: startupCooldown ? 'startup_cooldown' : (sharedMs !== null ? 'global_cooldown' : 'cooldown'),
         anchorMs,
         anchorIso,
@@ -771,7 +772,7 @@ function latestWatcherTickIso(state) {
         safeString(state.dispatch_drain?.last_tick_at),
         safeString(state.leader_nudge?.last_tick_at),
         safeString(state.fallback_auto_nudge?.last_tick_at),
-        safeString(state.ralph_continue_steer?.last_state_check_at),
+        safeString(state.forge_continue_steer?.last_state_check_at),
     ]
         .map((value) => value.trim())
         .filter(Boolean);
@@ -819,7 +820,7 @@ async function resolveAuthorityPrimaryWatcherHealth(now = Date.now()) {
     }
     const lastTickMs = parseIsoMillis(lastTickAt);
     const primaryPollMs = Math.max(50, asNumber(persistedState.poll_ms, 250));
-    const thresholdMs = Math.max(1_000, primaryPollMs * 4);
+    const thresholdMs = Math.max(2_000, primaryPollMs * 8);
     if (lastTickMs === null) {
         return createAuthorityBackoffState('tick_invalid', {
             primary_pid: existingRecord.pid,
@@ -865,7 +866,7 @@ async function buildWatcherManagedPayload() {
         return null;
     return { session_id: sessionId };
 }
-async function persistReboundRalphPaneState(statePath, state, paneId, nowIso) {
+async function persistReboundForgePaneState(statePath, state, paneId, nowIso) {
     const latestState = await readFile(statePath, 'utf-8')
         .then((content) => JSON.parse(content))
         .catch(() => null);
@@ -885,9 +886,9 @@ async function persistReboundRalphPaneState(statePath, state, paneId, nowIso) {
     }
     return nextState;
 }
-async function resolveRalphContinuePaneTarget(activeRalph, nowIso) {
-    const currentState = activeRalph.state && typeof activeRalph.state === 'object'
-        ? activeRalph.state
+async function resolveForgeContinuePaneTarget(activeForge, nowIso) {
+    const currentState = activeForge.state && typeof activeForge.state === 'object'
+        ? activeForge.state
         : null;
     const anchorPaneId = safeString(currentState?.tmux_pane_id).trim();
     if (!anchorPaneId) {
@@ -923,123 +924,123 @@ async function resolveRalphContinuePaneTarget(activeRalph, nowIso) {
             reboundFrom: '',
         };
     }
-    const updatedState = await persistReboundRalphPaneState(activeRalph.path, currentState, resolvedPaneId, nowIso);
+    const updatedState = await persistReboundForgePaneState(activeForge.path, currentState, resolvedPaneId, nowIso);
     return {
         paneId: resolvedPaneId,
         state: updatedState,
         reboundFrom: anchorPaneId,
     };
 }
-async function runRalphContinueSteerTick() {
+async function runForgeContinueSteerTick() {
     const now = Date.now();
     const nowIso = new Date(now).toISOString();
-    const activeRalph = await resolveActiveRalphState();
-    const activePaneId = safeString(activeRalph.state?.tmux_pane_id).trim();
-    lastRalphContinueSteer = {
-        ...lastRalphContinueSteer,
-        active: activeRalph.active,
-        current_phase: safeString(activeRalph.state?.current_phase),
+    const activeForge = await resolveActiveForgeState();
+    const activePaneId = safeString(activeForge.state?.tmux_pane_id).trim();
+    lastForgeContinueSteer = {
+        ...lastForgeContinueSteer,
+        active: activeForge.active,
+        current_phase: safeString(activeForge.state?.current_phase),
         last_state_check_at: nowIso,
-        last_reason: activeRalph.reason,
+        last_reason: activeForge.reason,
         last_error: null,
-        state_path: activeRalph.path,
+        state_path: activeForge.path,
         pane_id: activePaneId,
         pane_current_command: '',
-        subagent_session_id: safeString(activeRalph.state?.owner_codex_session_id).trim(),
+        subagent_session_id: safeString(activeForge.state?.owner_codex_session_id).trim(),
         active_subagent_thread_ids: [],
-        shared_timestamp_path: ralphSteerTimestampPath,
-        singleton_lock_path: ralphSteerLockPath,
+        shared_timestamp_path: forgeSteerTimestampPath,
+        singleton_lock_path: forgeSteerLockPath,
     };
-    if (!activeRalph.active) {
-        if (activeRalph.reason === 'starting_stale') {
-            lastRalphContinueSteer.last_reason = 'starting_stale';
+    if (!activeForge.active) {
+        if (activeForge.reason === 'starting_stale') {
+            lastForgeContinueSteer.last_reason = 'starting_stale';
         }
         return;
     }
-    const sharedBeforeLock = await readRalphSteerTimestamp();
-    lastRalphContinueSteer.shared_last_sent_at = sharedBeforeLock;
-    const initialCooldown = shouldSkipRalphContinue(now, sharedBeforeLock);
+    const sharedBeforeLock = await readForgeSteerTimestamp();
+    lastForgeContinueSteer.shared_last_sent_at = sharedBeforeLock;
+    const initialCooldown = shouldSkipForgeContinue(now, sharedBeforeLock);
     if (initialCooldown.skip) {
-        lastRalphContinueSteer.last_reason = initialCooldown.reason;
+        lastForgeContinueSteer.last_reason = initialCooldown.reason;
         if (!sharedBeforeLock && initialCooldown.reason === 'startup_cooldown') {
-            lastRalphContinueSteer.cooldown_anchor_at = initialCooldown.anchorIso;
+            lastForgeContinueSteer.cooldown_anchor_at = initialCooldown.anchorIso;
         }
         return;
     }
-    const outcome = await withRalphSteerLock(async () => {
-        const sharedLastSentAt = await readRalphSteerTimestamp();
-        lastRalphContinueSteer.shared_last_sent_at = sharedLastSentAt;
-        const cooldown = shouldSkipRalphContinue(Date.now(), sharedLastSentAt);
+    const outcome = await withForgeSteerLock(async () => {
+        const sharedLastSentAt = await readForgeSteerTimestamp();
+        lastForgeContinueSteer.shared_last_sent_at = sharedLastSentAt;
+        const cooldown = shouldSkipForgeContinue(Date.now(), sharedLastSentAt);
         if (cooldown.skip) {
-            lastRalphContinueSteer.last_reason = cooldown.reason;
+            lastForgeContinueSteer.last_reason = cooldown.reason;
             if (!sharedLastSentAt && cooldown.reason === 'startup_cooldown') {
-                lastRalphContinueSteer.cooldown_anchor_at = cooldown.anchorIso;
+                lastForgeContinueSteer.cooldown_anchor_at = cooldown.anchorIso;
             }
             return { sent: false, skipped: true };
         }
-        const progressGate = await readRalphProgressGate(activeRalph.state, Date.now());
+        const progressGate = await readForgeProgressGate(activeForge.state, Date.now());
         if (!progressGate.allow) {
-            lastRalphContinueSteer.last_reason = progressGate.reason;
-            lastRalphContinueSteer.subagent_session_id = progressGate.subagent_session_id ?? lastRalphContinueSteer.subagent_session_id;
-            lastRalphContinueSteer.active_subagent_thread_ids = progressGate.active_subagent_thread_ids ?? [];
+            lastForgeContinueSteer.last_reason = progressGate.reason;
+            lastForgeContinueSteer.subagent_session_id = progressGate.subagent_session_id ?? lastForgeContinueSteer.subagent_session_id;
+            lastForgeContinueSteer.active_subagent_thread_ids = progressGate.active_subagent_thread_ids ?? [];
             return { sent: false, skipped: true };
         }
-        const resolvedPane = await resolveRalphContinuePaneTarget(activeRalph, nowIso);
-        activeRalph.state = resolvedPane.state;
+        const resolvedPane = await resolveForgeContinuePaneTarget(activeForge, nowIso);
+        activeForge.state = resolvedPane.state;
         const paneId = resolvedPane.paneId;
         if (!paneId) {
-            lastRalphContinueSteer.last_reason = 'pane_missing';
-            lastRalphContinueSteer.pane_id = '';
+            lastForgeContinueSteer.last_reason = 'pane_missing';
+            lastForgeContinueSteer.pane_id = '';
             return { sent: false, skipped: true };
         }
         const paneGuard = await checkPaneReadyForTeamSendKeys(paneId);
-        lastRalphContinueSteer.pane_id = paneId;
-        lastRalphContinueSteer.pane_current_command = paneGuard.paneCurrentCommand || '';
+        lastForgeContinueSteer.pane_id = paneId;
+        lastForgeContinueSteer.pane_current_command = paneGuard.paneCurrentCommand || '';
         if (!paneGuard.ok) {
-            lastRalphContinueSteer.last_reason = paneGuard.reason || 'pane_guard_blocked';
+            lastForgeContinueSteer.last_reason = paneGuard.reason || 'pane_guard_blocked';
             return { sent: false, skipped: true };
         }
-        await emitRalphContinueSteer(paneId, RALPH_CONTINUE_TEXT);
-        await writeRalphSteerTimestamp(nowIso);
-        lastRalphContinueSteer.last_sent_at = nowIso;
-        lastRalphContinueSteer.shared_last_sent_at = nowIso;
-        lastRalphContinueSteer.cooldown_anchor_at = nowIso;
-        lastRalphContinueSteer.last_reason = 'sent';
+        await emitForgeContinueSteer(paneId, FORGE_CONTINUE_TEXT);
+        await writeForgeSteerTimestamp(nowIso);
+        lastForgeContinueSteer.last_sent_at = nowIso;
+        lastForgeContinueSteer.shared_last_sent_at = nowIso;
+        lastForgeContinueSteer.cooldown_anchor_at = nowIso;
+        lastForgeContinueSteer.last_reason = 'sent';
         await eventLog({
-            type: 'ralph_continue_steer',
+            type: 'forge_continue_steer',
             reason: 'sent',
             pane_id: paneId,
             rebound_from: resolvedPane.reboundFrom || null,
-            state_path: activeRalph.path,
-            current_phase: safeString(activeRalph.state?.current_phase) || null,
-            cadence_ms: RALPH_CONTINUE_CADENCE_MS,
-            message: RALPH_CONTINUE_TEXT,
-            shared_timestamp_path: ralphSteerTimestampPath,
+            state_path: activeForge.path,
+            current_phase: safeString(activeForge.state?.current_phase) || null,
+            cadence_ms: FORGE_CONTINUE_CADENCE_MS,
+            message: FORGE_CONTINUE_TEXT,
+            shared_timestamp_path: forgeSteerTimestampPath,
         });
         return { sent: true, skipped: false };
     });
     if (outcome === null) {
-        lastRalphContinueSteer.shared_last_sent_at = await readRalphSteerTimestamp();
+        lastForgeContinueSteer.shared_last_sent_at = await readForgeSteerTimestamp();
     }
 }
-async function runRalphWatcherBehaviorTick() {
+async function runForgeWatcherBehaviorTick() {
     try {
-        await runRalphContinueSteerTick();
+        await runForgeContinueSteerTick();
     }
     catch (error) {
         const message = error instanceof Error ? error.message : safeString(error);
-        lastRalphContinueSteer = {
-            ...lastRalphContinueSteer,
+        lastForgeContinueSteer = {
+            ...lastForgeContinueSteer,
             last_reason: 'send_failed',
             last_error: message || 'unknown_error',
         };
         await eventLog({
-            type: 'ralph_continue_steer',
+            type: 'forge_continue_steer',
             reason: 'send_failed',
-            pane_id: lastRalphContinueSteer.pane_id || null,
-            state_path: lastRalphContinueSteer.state_path || null,
-            current_phase: lastRalphContinueSteer.current_phase || null,
-            error: lastRalphContinueSteer.last_error,
+            pane_id: lastForgeContinueSteer.pane_id || null,
+            state_path: lastForgeContinueSteer.state_path || null,
+            current_phase: lastForgeContinueSteer.current_phase || null,
+            error: lastForgeContinueSteer.last_error,
         });
     }
 }
@@ -1121,11 +1122,11 @@ async function writeState(extra = {}) {
             enabled: true,
             run_count: leaderNudgeRuns,
         },
-        ralph_continue_steer: {
-            ...lastRalphContinueSteer,
+        forge_continue_steer: {
+            ...lastForgeContinueSteer,
             enabled: true,
-            cadence_ms: RALPH_CONTINUE_CADENCE_MS,
-            message: RALPH_CONTINUE_TEXT,
+            cadence_ms: FORGE_CONTINUE_CADENCE_MS,
+            message: FORGE_CONTINUE_TEXT,
         },
         fallback_auto_nudge: {
             ...lastFallbackAutoNudge,
@@ -1277,12 +1278,12 @@ async function enforceLifecycleGuards() {
     if (runOnce)
         return false;
     if (parentIsGone()) {
-        const activeRalph = await resolveActiveRalphState();
-        if (activeRalph.active) {
-            const currentPhase = safeString(activeRalph.state?.current_phase);
+        const activeForge = await resolveActiveForgeState();
+        if (activeForge.active) {
+            const currentPhase = safeString(activeForge.state?.current_phase);
             const nextParentGuard = {
-                reason: 'parent_gone_deferred_for_active_ralph',
-                state_path: activeRalph.path,
+                reason: 'parent_gone_deferred_for_active_forge',
+                state_path: activeForge.path,
                 current_phase: currentPhase,
             };
             if (lastParentGuard.reason !== nextParentGuard.reason
@@ -1676,16 +1677,16 @@ async function runWatcherCycle() {
     }
     const controlPlaneSummary = await pumpTeamControlPlaneTick();
     if (!authorityOnly && !(await shouldSuppressInteractiveFallbackTicks())) {
-        await runRalphWatcherBehaviorTick();
+        await runForgeWatcherBehaviorTick();
     }
-    const ralphActive = lastRalphContinueSteer.last_reason === 'sent';
+    const forgeActive = lastForgeContinueSteer.last_reason === 'sent';
     const summary = processedRolloutCount > 0
         ? { active: true, reason: 'rollout_event' }
         : controlPlaneSummary.active
             ? controlPlaneSummary
-            : ralphActive
-                ? { active: true, reason: 'ralph_continue_steer' }
-                : { active: false, reason: controlPlaneSummary.reason || lastRalphContinueSteer.last_reason || 'idle' };
+            : forgeActive
+                ? { active: true, reason: 'forge_continue_steer' }
+                : { active: false, reason: controlPlaneSummary.reason || lastForgeContinueSteer.last_reason || 'idle' };
     const nextDelayMs = updateAdaptivePollState(summary);
     await writeState({ last_cycle_activity: summary.reason });
     return nextDelayMs;