elanous 0.2.43 → 0.2.44

package/src/nexus/index.ts

@@ -1356,6 +1356,7 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
   // Wired below once the workflow daemon is constructed.
   let webPushDecisionTimer: ReturnType<typeof setInterval> | undefined;
   let workflowDiscordBot: NexusDiscordTriggerBotHandle | undefined;
+  let workflowGrokbotBot: { start(): void; stop(): Promise<void> } | undefined;
   // V2.2-4 (2026-05-12) — NEXUS-hosted Telegram workflow trigger bot.
   let workflowTelegramBot: NexusTelegramTriggerBotHandle | undefined;
   /** R1 — 토큰마다 뜬 Q&A 폴러 «전부»(재시작 때 함께 비운다 · `workflowTelegramBot` 은 주 토큰 하나뿐). */
@@ -2812,6 +2813,16 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
               for (const wired of handles) adopt(wired);
             }
           }
+          if (process.env.ELANOUS_GROKBOT_ENABLED === '1' && !isAutonomousRunContext()) {
+            const { createGrokbotMainSessionDispatcher, createNexusGrokbotTriggerBot, createSshGrokbotMailbox } = await import('./api/grokbot-trigger-bot.js');
+            const { makeElanousAgentRunTurn } = await import('../agent/monad-agent-turn.js');
+            workflowGrokbotBot = createNexusGrokbotTriggerBot({
+              mailbox: createSshGrokbotMailbox(),
+              dispatch: createGrokbotMainSessionDispatcher(cfg, makeElanousAgentRunTurn(cfg, 'telegram')),
+            });
+            workflowGrokbotBot.start();
+            debug.log('channel.grokbot', 'attached', { agent: 'COO', pollIntervalMs: 15_000 });
+          }
         } catch (err: unknown) {
           const msg = err instanceof Error ? err.message : String(err);
           console.warn(`[nexus] trigger bot boot skipped: ${msg}`);
@@ -3592,6 +3603,10 @@ export async function runNexus(opts: RunNexusOptions = {}): Promise<RunNexusHand
     await Promise.all([...handles].map(async (handle) => {
       try { await handle.stop(); } catch { /* 종료는 계속 */ }
     }));
+    if (workflowGrokbotBot) {
+      try { await workflowGrokbotBot.stop(); } catch { /* 종료는 계속 */ }
+      workflowGrokbotBot = undefined;
+    }
     await next();
   };
 

package/src/nexus/outbound/grokbot-adapter.ts

@@ -0,0 +1,71 @@
+import { debug } from '../../debug/log.js';
+import { registerOutboundAdapter } from './router.js';
+import type {
+  ChannelAdapter,
+  ChannelEnvelope,
+  ChannelResult,
+  OutboundChannelConfig,
+  RouterDeps,
+} from './router.js';
+import type { OutboundMsg } from './format.js';
+import type { UserConfig } from '../../user-config.js';
+
+export interface GrokbotAdapterOptions {
+  sendPrompt: (agent: string, prompt: string) => Promise<{ preview?: string }>;
+  now?: () => string;
+  log?: (event: string, data: Record<string, unknown>) => void;
+  agent?: string;
+}
+
+function safeError(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/Bearer\s+\S+/gi, 'Bearer [redacted]').slice(0, 240);
+}
+
+function inboundEnvelope(payload: unknown): Omit<ChannelEnvelope, 'text'> & { text: string } | null {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return null;
+  const event = payload as Record<string, unknown>;
+  if (typeof event.text !== 'string' || event.text.length === 0) return null;
+  if (typeof event.id !== 'string' && typeof event.id !== 'number') return null;
+  const kind = typeof event.kind === 'string' && event.kind.trim() ? event.kind : 'request';
+  return { text: event.text, kind, channel: 'COO', senderId: 'COO', messageId: event.id };
+}
+
+export function createGrokbotAdapter(options: GrokbotAdapterOptions): ChannelAdapter {
+  const agent = options.agent ?? 'COO';
+  const now = options.now ?? (() => new Date().toISOString());
+  const log = options.log ?? ((event, data) => debug.log('channel.grokbot', event, data));
+  return {
+    type: 'grokbot',
+    capabilities: {
+      send: true, receive: true, thread: false, topic: false, persona: false,
+      channelLifecycle: false, permissions: false, commands: false, attachments: false,
+      buttons: false, choices: true, deliveryConfirmation: false, rateLimit: false,
+    },
+    parseConfig: (raw): OutboundChannelConfig | undefined => raw.type === 'grokbot' ? { type: 'grokbot' } : undefined,
+    receive: (payload): ChannelEnvelope | null => {
+      const envelope = inboundEnvelope(payload);
+      if (!envelope) return null;
+      log('received', { id: envelope.messageId, text: envelope.text, receivedAt: now() });
+      return envelope;
+    },
+    send: async (_config: OutboundChannelConfig, message: OutboundMsg, _cfg: UserConfig, _deps: RouterDeps): Promise<ChannelResult> => {
+      const requestedAt = now();
+      log('request', { agent, text: message.text, requestedAt, kind: message.kind });
+      try {
+        const prompt = `[엘라누스 알림 — 아래를 대표님께 그대로 전해 주세요. 덧붙이지 마세요]\n\n${message.text}`;
+        const result = await options.sendPrompt(agent, prompt);
+        log('reply', { agent, repliedAt: now(), ...(result.preview ? { preview: result.preview } : {}) });
+        return { type: 'grokbot', ok: true };
+      } catch (error) {
+        const reason = safeError(error);
+        log('failure', { agent, failedAt: now(), reason });
+        return { type: 'grokbot', ok: false, error: reason };
+      }
+    },
+  };
+}
+
+export function registerGrokbotAdapter(options: GrokbotAdapterOptions): () => void {
+  return registerOutboundAdapter(createGrokbotAdapter(options));
+}

package/src/nexus/outbound/router.ts

@@ -110,9 +110,35 @@ export interface ChannelAdapter {
   parseConfig?: (raw: Record<string, unknown>) => OutboundChannelConfig | undefined;
 }
 
-/** Existing bot receive paths can normalize an accepted event through the same
- * adapter contract before dispatching to their unchanged workflow/chat handlers. */
-export function receiveChannelEvent(type: string, payload: unknown): ChannelEnvelope | null | Promise<ChannelEnvelope | null> {
+/** Project adapter output onto the public envelope contract. Unknown keys and malformed optional fields are omitted; missing/non-string text or missing/empty/non-string kind rejects the event. Keep platform-specific data in the caller's raw tap instead. */
+function normalizeChannelEnvelope(envelope: ChannelEnvelope | null): ChannelEnvelope | null {
+  if (!envelope || typeof envelope !== 'object' || typeof envelope.text !== 'string'
+    || typeof envelope.kind !== 'string' || !envelope.kind) return null;
+  return {
+    text: envelope.text,
+    kind: envelope.kind,
+    ...(typeof envelope.channel === 'string' ? { channel: envelope.channel } : {}),
+    ...(typeof envelope.senderId === 'string' ? { senderId: envelope.senderId } : {}),
+    ...(typeof envelope.messageId === 'string' || typeof envelope.messageId === 'number' ? { messageId: envelope.messageId } : {}),
+    ...(typeof envelope.threadId === 'string' ? { threadId: envelope.threadId } : {}),
+    ...(typeof envelope.topicId === 'string' ? { topicId: envelope.topicId } : {}),
+    ...(envelope.persona && typeof envelope.persona.name === 'string'
+      ? { persona: { name: envelope.persona.name, ...(typeof envelope.persona.avatarUrl === 'string' ? { avatarUrl: envelope.persona.avatarUrl } : {}) } }
+      : {}),
+    ...(Array.isArray(envelope.attachments) ? { attachments: envelope.attachments
+      .filter(item => item && typeof item.url === 'string')
+      .map(item => ({ url: item.url, ...(typeof item.name === 'string' ? { name: item.name } : {}) })) } : {}),
+    ...(Array.isArray(envelope.buttons) ? { buttons: envelope.buttons
+      .filter(item => item && typeof item.label === 'string' && typeof item.value === 'string')
+      .map(item => ({ label: item.label, value: item.value })) } : {}),
+    ...(Array.isArray(envelope.choices) ? { choices: envelope.choices
+      .filter(item => item && typeof item.label === 'string' && typeof item.value === 'string')
+      .map(item => ({ label: item.label, value: item.value })) } : {}),
+  };
+}
+
+/** Existing bot receive paths normalize accepted events before their unchanged handlers. */
+export async function receiveChannelEvent(type: string, payload: unknown): Promise<ChannelEnvelope | null> {
   const adapter = outboundAdapters.get(type) ?? installedAdapters.get(type);
   if (!adapter?.capabilities.receive || !adapter.receive) return null;
   const recordOutcome = (outcome: 'accepted' | 'rejected' | 'error'): void => {
@@ -126,19 +152,13 @@ export function receiveChannelEvent(type: string, payload: unknown): ChannelEnve
     } catch { /* observation must not change channel receive behavior */ }
   };
   const recordResult = (envelope: ChannelEnvelope | null): ChannelEnvelope | null => {
-    recordOutcome(envelope ? 'accepted' : 'rejected');
-    return envelope;
+    const normalized = normalizeChannelEnvelope(envelope);
+    recordOutcome(normalized ? 'accepted' : 'rejected');
+    return normalized;
   };
 
   try {
-    const result = adapter.receive(payload);
-    if (result && typeof (result as Promise<ChannelEnvelope | null>).then === 'function') {
-      return Promise.resolve(result).then(recordResult, error => {
-        recordOutcome('error');
-        throw error;
-      });
-    }
-    return recordResult(result as ChannelEnvelope | null);
+    return recordResult(await adapter.receive(payload));
   } catch (error) {
     recordOutcome('error');
     throw error;

package/src/oauth/codex-owner-mirror.ts

@@ -1,14 +1,36 @@
 import { hostname } from 'node:os';
-import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
 import { loadTokens, type ProviderAuthState } from './store.js';
 
 export const CODEX_OWNER_MIRROR_RELATIVE_PATH = join('remote-parent-credentials', 'cli-mirror', 'auth.json');
-export const CODEX_OWNER_MIRROR_REQUIRED = 'Codex 주인 미러가 없거나 만료됐다 — 주인 호스트에서 `eln codex mirror push <host>` 를 실행해야 한다';
+export const CODEX_OWNER_MIRROR_REQUIRED = 'Codex owner access mirror rejected — inspect llm.codex/owner-mirror-rejected for the precise reason';
 
 export function codexOwnerMirrorAuthPath(): string {
-  return join(elanousStateRoot(), CODEX_OWNER_MIRROR_RELATIVE_PATH);
+  const stateRoot = elanousStateRoot();
+  const derivedPath = join(stateRoot, CODEX_OWNER_MIRROR_RELATIVE_PATH);
+  const configuredPath = process.env.ELANOUS_REMOTE_CODEX_ACCESS_ONLY === '1'
+    ? process.env.ELANOUS_REMOTE_CODEX_MIRROR_PATH?.trim()
+    : undefined;
+  const path = configuredPath && isAbsolute(configuredPath) ? configuredPath : derivedPath;
+  try {
+    debug.log('llm.codex', 'owner-mirror-path-compared', {
+      source: path === derivedPath ? 'state-root' : 'remote-explicit',
+      stateRootSha256: rootFingerprint(stateRoot),
+      derivedMirrorRootSha256: rootFingerprint(dirname(dirname(dirname(derivedPath)))),
+      resolvedMirrorRootSha256: rootFingerprint(dirname(dirname(dirname(path)))),
+      explicitPathAccepted: Boolean(configuredPath && path === configuredPath),
+    });
+  } catch { /* diagnostics must not block auth */ }
+  return path;
+}
+
+function rootFingerprint(root: string): string {
+  return createHash('sha256').update(root).digest('hex').slice(0, 16);
 }
 
 function normalizedHost(value: string): string {
@@ -30,15 +52,30 @@ export function readCodexOwnerAccessMirror(
   const path = opts.path ?? codexOwnerMirrorAuthPath();
   const now = opts.now ?? Date.now();
   let state: ProviderAuthState | null = null;
-  try { state = loadTokens(storeKey, path); } catch { /* fail closed below */ }
+  let readFailure: 'missing-file' | 'read-error' | 'invalid-json' | undefined;
+  try {
+    const raw = readFileSync(path, 'utf8');
+    try { JSON.parse(raw); } catch { readFailure = 'invalid-json'; }
+  } catch (error) {
+    readFailure = (error as NodeJS.ErrnoException).code === 'ENOENT' ? 'missing-file' : 'read-error';
+  }
+  if (!readFailure) {
+    try { state = loadTokens(storeKey, path); } catch { /* classify safely below */ }
+  }
   const tokenFields = state?.tokens as (ProviderAuthState['tokens'] & { refresh_token?: unknown }) | undefined;
   const expiresAt = state?.tokens.expiresAt;
-  if (!state || state.authMode !== 'chatgpt' || !state.tokens.accessToken
-    || tokenFields?.refreshToken !== '' || tokenFields?.refresh_token !== ''
-    || typeof expiresAt !== 'number'
-    || !Number.isFinite(expiresAt) || expiresAt <= now + 120_000) {
-    throw new Error(CODEX_OWNER_MIRROR_REQUIRED);
+  const reason = readFailure ?? (!state || !state.tokens ? 'no-access'
+      : state.authMode !== 'chatgpt' ? 'authMode'
+      : !state.tokens.accessToken ? 'no-access'
+      : typeof tokenFields?.refreshToken !== 'string' || typeof tokenFields?.refresh_token !== 'string' ? 'refresh-missing'
+      : tokenFields.refreshToken !== '' || tokenFields.refresh_token !== '' ? 'refresh-not-empty'
+      : typeof expiresAt !== 'number' || !Number.isFinite(expiresAt) || expiresAt <= now + 120_000 ? 'expiry'
+      : undefined);
+  if (reason) {
+    const root = dirname(dirname(dirname(path)));
+    try { debug.log('llm.codex', 'owner-mirror-rejected', { reason, storeKey, rootSha256: rootFingerprint(root) }, { level: 'warn' }); } catch { /* fail-soft */ }
+    throw new Error(`${CODEX_OWNER_MIRROR_REQUIRED} (reason=${reason}; storeKey=${storeKey}; rootSha256=${rootFingerprint(root)})`);
   }
-  return state;
+  return state!;
 }
 

package/src/onboarding/first-run.ts

@@ -3,7 +3,7 @@ import { detectProviders, type DetectedProvider } from '../llm/provider-detect.j
 import { debug } from '../debug/log.js';
 import { detectLocale, type Locale } from '../expression/locale.js';
 import { unattendedNextStepLine } from './entry-hints.js';
-import { resolveProviderCredential } from '../llm/provider-credentials.js';
+import { providerEnvKey, resolveProviderCredential, resolveProviderCredentialAsync } from '../llm/provider-credentials.js';
 import { zaiCodingPlanAvailable } from '../llm/zai-coding-plan.js';
 import { collectServiceKeys, printKeySetupReport } from './key-setup.js';
 import { getSecretAsync, setSecretAsync } from '../nexus/config/secrets/index.js';
@@ -121,8 +121,8 @@ export async function runFirstRun(deps: FirstRunDeps = {}): Promise<{
   // An incomplete onboarding marker does not mean the user's LLM is unconfigured.
   // Keep an already usable provider, key and model rather than replacing it with a detected subscription.
   const existing = cfg.llm.provider !== 'auto'
-    ? resolveProviderCredential({ provider: cfg.llm.provider, rotation: cfg.llm.rotation,
-        baseProvider: cfg.llm.provider, baseApiKey: cfg.llm.apiKey, env: deps.env })
+    ? await resolveProviderCredentialAsync({ provider: cfg.llm.provider, rotation: cfg.llm.rotation,
+        baseProvider: cfg.llm.provider, baseApiKey: cfg.llm.apiKey, env: deps.env }, deps.getSecretAsync)
     : undefined;
   const configured = existing && existing.source !== 'none'
     ? cfg.llm.provider
@@ -185,11 +185,11 @@ export async function runFirstRun(deps: FirstRunDeps = {}): Promise<{
     }
   }
   const credential = inputs === 1 || provider !== cfg.llm.provider
-    ? resolveProviderCredential({
+    ? await resolveProviderCredentialAsync({
         provider, rotation: cfg.llm.rotation,
         baseProvider: cfg.llm.provider, baseApiKey: cfg.llm.apiKey,
         env: deps.env,
-      })
+      }, deps.getSecretAsync)
     : undefined;
   if (inputs === 1 && credential?.source === 'none'
     && !(providerSetUpInPlace && provider === 'openai-codex')) {
@@ -206,7 +206,45 @@ export async function runFirstRun(deps: FirstRunDeps = {}): Promise<{
       });
       printKeySetupReport(results, print);
       if (results.length === 0 || results.some((result) => result.status !== 'success')) return needsLlm(inputs);
-      return needsLlm(inputs, [text.keyStoredNotReady]);
+      // Probe the same lookup the runtime will use before marking first-run ready.
+      const secretId = providerEnvKey(provider);
+      let storedValue: string | undefined;
+      try {
+        storedValue = secretId
+          ? await (deps.getSecretAsync ?? getSecretAsync)(secretId)
+          : undefined;
+      } catch { /* keep the first-run state unready without exposing backend errors */ }
+      const storedCredential = resolveProviderCredential({
+        provider,
+        rotation: cfg.llm.rotation,
+        baseProvider: provider,
+        env: deps.env,
+        secretStoreApiKey: storedValue,
+      });
+      if (!storedValue?.trim() || storedCredential.source === 'none') return needsLlm(inputs, [text.keyStoredNotReady]);
+      // Only remove any legacy config key after the runtime can read its replacement.
+      // A failed SecretStore write/readback must leave the prior working config intact.
+      (deps.saveConfig ?? saveUserConfig)({
+        ...cfg,
+        llm: {
+          ...cfg.llm,
+          provider,
+          apiKey: undefined,
+          ...(provider !== cfg.llm.provider ? { baseUrl: undefined, model: undefined } : {}),
+        },
+      }, path);
+      (deps.saveConfig ?? saveUserConfig)({
+        ...cfg,
+        llm: {
+          ...cfg.llm,
+          provider,
+          apiKey: undefined,
+          ...(provider !== cfg.llm.provider ? { baseUrl: undefined, model: undefined } : {}),
+        },
+        onboarding: { ...cfg.onboarding, ready: true },
+      }, path);
+      observe('ready', inputs);
+      return { outcome: 'ready', provider, inputs };
     } catch {
       return needsLlm(inputs, [text.keySetupFailed]);
     }

package/src/preview/terminal.ts

@@ -559,10 +559,25 @@ export class PreviewTerminal {
 
   /** 자식 stdin 으로 바이트 전송(응답 채널·public write·마우스 공유). registry 모드면 handle.write,
    *  아니면 dup-fd(기본 경로 무접촉). */
-  private writeToChild(data: string): void {
-    if (this.registryHandle) { try { this.registryHandle.write(data); } catch { /* pty closing */ } return; }
-    if (!this.alive || this.dupFd < 0) return;
-    try { fs.writeSync(this.dupFd, data); } catch { /* pty closing */ }
+  private writeToChild(data: string): boolean {
+    if (this.registryHandle) {
+      try {
+        if (!this.registryHandle.canWrite()) return false;
+        this.registryHandle.write(data);
+        return true;
+      } catch { return false; }
+    }
+    if (!this.alive || this.dupFd < 0) return false;
+    try {
+      const bytes = Buffer.from(data, 'utf8');
+      let offset = 0;
+      while (offset < bytes.length) {
+        const written = fs.writeSync(this.dupFd, bytes, offset, bytes.length - offset);
+        if (written <= 0) return false;
+        offset += written;
+      }
+      return true;
+    } catch { return false; }
   }
 
   private scheduleUpdate(): void {
@@ -606,9 +621,9 @@ export class PreviewTerminal {
     return () => { this.rawOscTaps.delete(cb); };
   }
 
-  /** Send raw bytes to the PTY (stdin from the child's perspective). */
-  write(bytes: string): void {
-    this.writeToChild(bytes);
+  /** Send raw bytes to the PTY and report whether its input handle accepted them. */
+  write(bytes: string): boolean {
+    return this.writeToChild(bytes);
   }
 
   /** Notify the PTY + emulator of new pane dimensions. Called on

package/src/prompt-enhance/enhance.ts

@@ -120,6 +120,8 @@ export interface EnhanceOpts {
   groundedFacts?: readonly string[];
   /** Relevant prior-failure lessons for goal-authoring prompts only; never part of the original ask. */
   authoringLessons?: string;
+  /** Canonical reusable mock-device and event-injection inventory; reference only, not a completion gate. */
+  mockScenarioCatalog?: string;
   /** Clock seam for the first-token observation (ms epoch); defaults to `Date.now`. */
   now?: () => number;
 }
@@ -439,6 +441,14 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
           ...(opts.authoringLessons?.trim()
             ? ['', '## 지난 실패에서 배운 것', opts.authoringLessons.trim(), '위 교훈은 현재 ask의 대상 경로와 범위에 맞을 때만 적용하고, 맞지 않으면 무시하라.']
             : []),
+          ...(opts.mockScenarioCatalog?.trim()
+            ? [
+              '',
+              '## 재사용 가능한 목장치·사건 주입 카탈로그 (참고 자료 · 완료 조건이 아님)',
+              opts.mockScenarioCatalog.trim(),
+              '골의 완료 경계가 실물 점검만 요구하면 먼저 제약을 의심하라: 그 제약은 저작 문면의 세계와 구현의 세계에서 같은가? 카탈로그의 목장치나 사건 주입으로 같은 동작을 관찰할 수 있는가? 실제 외부 시스템 확인이 사용자의 의도인 경우에만 실물 점검을 유지하고, 목장치가 맞으면 해당 장치·입력·관측 신호를 제안하라.',
+            ]
+            : []),
         ].join('\n'),
       },
     ];

package/src/pty-shell/pty-write-provenance.ts

@@ -24,14 +24,32 @@
  *  장수 owner(데몬)는 PTY 를 계속 만든다. 훅만 믿으면 «한 번 새면 영영» 샌다. */
 const MAX_TRACKED_PTYS = 512;
 
-const writes = new Map<string, { count: number; lastAt: number; lastActor: string }>();
+const writes = new Map<string, { count: number; lastAt: number; lastActor: string | null; accessMode?: 'read' | 'write' | 'auto' }>();
+
+export function notePtyAccessMode(ptyId: string, accessMode: 'read' | 'write' | 'auto'): void {
+  const prev = writes.get(ptyId);
+  writes.delete(ptyId);
+  writes.set(ptyId, { count: prev?.count ?? 0, lastAt: prev?.lastAt ?? 0, lastActor: prev?.lastActor ?? null, accessMode });
+  while (writes.size > MAX_TRACKED_PTYS) {
+    const oldest = writes.keys().next();
+    if (oldest.done) break;
+    writes.delete(oldest.value);
+  }
+}
+
+export function ptyWriteControlState(ptyId: string): { accessMode: 'read' | 'write' | 'auto'; lastWriter: 'agent' | 'human' | null } | undefined {
+  const rec = writes.get(ptyId);
+  if (!rec?.accessMode) return undefined;
+  const lastWriter = rec.lastActor === 'agent' || rec.lastActor === 'human' ? rec.lastActor : null;
+  return { accessMode: rec.accessMode, lastWriter };
+}
 
 /** 성공한 쓰기 1건을 기록한다. ⛔ 거부·실패는 세지 않는다(자식이 «본» 것만 세야 수가 뜻을 갖는다). */
 export function noteExternalWrite(ptyId: string, actor: string, now = Date.now()): void {
   const prev = writes.get(ptyId);
   // 재삽입으로 **삽입 순서를 갱신**한다 — 아래 축출이 「가장 오래 안 쓰인 것」을 버리게.
   writes.delete(ptyId);
-  writes.set(ptyId, { count: (prev?.count ?? 0) + 1, lastAt: now, lastActor: actor });
+  writes.set(ptyId, { count: (prev?.count ?? 0) + 1, lastAt: now, lastActor: actor, ...(prev?.accessMode ? { accessMode: prev.accessMode } : {}) });
   while (writes.size > MAX_TRACKED_PTYS) {
     const oldest = writes.keys().next();
     if (oldest.done) break;
@@ -49,7 +67,7 @@ export function noteExternalWrite(ptyId: string, actor: string, now = Date.now()
  */
 export function externalWriteProvenance(ptyId: string, now = Date.now()): { externalWrites: number; externalWriteAgoMs: number; externalWriteActor: string } | undefined {
   const rec = writes.get(ptyId);
-  if (!rec) return undefined;
+  if (!rec || rec.lastActor === null) return undefined;
   return { externalWrites: rec.count, externalWriteAgoMs: Math.max(0, now - rec.lastAt), externalWriteActor: rec.lastActor };
 }
 

package/src/pty-shell/registry.ts

@@ -30,7 +30,7 @@ import { resolveWriteDecision, resolveTakeover, type PtyWriteActor } from './pty
 import { addPtyManifestOutputBytes, upsertPtyManifest, updatePtyManifestSnapshot, updatePtyManifestNickname, markPtyManifestClosed, removePtyManifest, touchLivePtyManifest } from './pty-manifest.js';
 import { processPtyControlRequests } from './pty-control-ipc.js';
 import { tapPtyOutput, autoStopPtyRecording } from './pty-recording.js';
-import { forgetExternalWriteProvenance, noteExternalWrite } from './pty-write-provenance.js';
+import { forgetExternalWriteProvenance, noteExternalWrite, notePtyAccessMode } from './pty-write-provenance.js';
 import { resolveRunIdentity } from '../harness/harness-space.js';
 import { addSelfDevRunParticipant, selfDevRunsDir } from '../self-dev/run-store.js';
 import { debug } from '../debug/log.js';
@@ -192,6 +192,8 @@ export interface PtyControlTarget {
 export interface PtyHandle extends PtyControlTarget {
   /** 고유 id — `<kind>_<hex>`. 같은 PTY 객체를 부르는 캐논 이름. */
   readonly id: string;
+  /** Actor of the last successful PTY write in this process; denied or failed writes do not update it. */
+  readonly lastWriteActor: PtyWriteActor | null;
   /**
    * 접근 모드(관찰 read / 인터랙션 write / 자율 auto). ⭐정책 매트릭스(§ 입력 중재):
    *  - auto+locked = 보호된 자율(brain 소유·사람 write 불가). 위험 미션 무간섭.
@@ -508,10 +510,13 @@ export function startPty(opts: StartOpts): PtyHandle {
   } catch { term = null; }
 
   let nickname = opts.nickname;
+  let lastWriteActor: PtyWriteActor | null = null;
   let accessMode: PtyAccessMode = opts.accessMode ?? 'write';
   let transitionPolicy: PtyTransitionPolicy = opts.transitionPolicy ?? 'open';
+  notePtyAccessMode(id, accessMode);
   const handle: PtyHandle = {
     id,
+    get lastWriteActor() { return lastWriteActor; },
     kind: ptyKindOf(id),
     get nickname() { return nickname; },
     set nickname(v: string | undefined) { nickname = v; },
@@ -520,13 +525,14 @@ export function startPty(opts: StartOpts): PtyHandle {
       if (ptyManifestEnabled()) updatePtyManifestNickname(id, nickname, Date.now());
     },
     get accessMode() { return accessMode; },
-    set accessMode(v: PtyAccessMode) { accessMode = v; },
+    set accessMode(v: PtyAccessMode) { accessMode = v; notePtyAccessMode(id, v); },
     get transitionPolicy() { return transitionPolicy; },
     set transitionPolicy(v: PtyTransitionPolicy) { transitionPolicy = v; },
     setAccessMode(mode: PtyAccessMode): boolean {
       // 정책 SSOT(canTransitionAccessMode): locked 면 다른 모드로 못 감(read+locked→write = write 불가).
       if (!canTransitionAccessMode(accessMode, mode, transitionPolicy)) return false;
       accessMode = mode;
+      notePtyAccessMode(id, mode);
       return true;
     },
     setTransitionPolicy(policy: PtyTransitionPolicy): void { transitionPolicy = policy; },
@@ -598,6 +604,7 @@ export function startPty(opts: StartOpts): PtyHandle {
         return;
       }
       adapter.write(chars);
+      lastWriteActor = actor;
       debug.log('pty.control', 'write', { ptyId: id, actor, mode: accessMode, bytes: chars.length });
       // ⭐⭐ 여기가 진짜 초크포인트다 — 허용 판정 뒤·바이트가 «실제로» 들어간 뒤. 모든 쓰기가
       //   이 자리로 모인다(크로스-프로세스 IPC · 같은 프로세스 감독 autoAssist · PtyShellSend).

package/src/release-loop/proposal-auto-place.ts

@@ -0,0 +1,83 @@
+import { runRequirementFunnel, type FunnelCandidate, type FunnelOptions, type RequirementDecision } from '../intake-plane/requirement-funnel.js';
+import type { ConsensusEngine, ConsensusRepresentative } from '../loops/consensus.js';
+import { placeCell, type PlacementDeps, type PlacementDecision } from './placement.js';
+import { parseRubric, rubricGrade, rubricScore } from './rubric.js';
+
+export interface ProposalPlacementInput {
+  /** The current funnel inputs; ledger capture and adoption hooks are intentionally not accepted here. */
+  funnel: Omit<FunnelOptions, 'ledger' | 'adopt' | 'mode' | 'placement'>;
+  rubricCandidate: FunnelCandidate;
+  consensus: Pick<ConsensusEngine, 'show'>;
+  consensusProposalId: string;
+  placement: PlacementDeps;
+}
+
+export type ProposalPlacementPlan =
+  | { status: 'not-eligible'; reason: string; decision?: RequirementDecision }
+  | { status: 'awaiting-consensus'; consensusProposalId: string; decision: RequirementDecision }
+  | { status: 'planned'; consensus: { id: string; status: 'agreed'; proposedBy: ConsensusRepresentative; agreedBy: ConsensusRepresentative };
+      decision: RequirementDecision; rubric: { score: number; grade: NonNullable<FunnelCandidate['grade']> }; placement: PlacementDecision };
+
+/**
+ * Safe first slice for the proposal→placement path. It accepts a pre-collected rubric candidate and an existing
+ * dual-root card; the requirement funnel and both placement calculations run in shadow/dry-run only. There is no
+ * ledger writer, live adopter, proposal creator, or operational scheduler in this seam.
+ */
+export function planAgreedProposalPlacement(input: ProposalPlacementInput): ProposalPlacementPlan {
+  const rubric = input.rubricCandidate;
+  if (rubric.score === null || rubric.grade === null) return { status: 'not-eligible', reason: 'candidate has no explicit rubric' };
+  const funnel = runRequirementFunnel({
+    ...input.funnel,
+    mode: 'shadow',
+    placement: { ...input.placement, dryRun: true },
+  });
+  const decision = funnel.decisions.find(({ candidate }) => candidate.id === rubric.id);
+  if (!decision) return { status: 'not-eligible', reason: `funnel candidate not found: ${rubric.id}` };
+  if (decision.status !== 'would-adopt') return { status: 'not-eligible', reason: decision.reason ?? `funnel status: ${decision.status}`, decision };
+  const sourceRubric = parseRubric(decision.candidate.text);
+  const sourceTitle = decision.candidate.text.split(/\s+루브릭:/, 1)[0]!.trim().slice(0, 80);
+  if (sourceTitle !== rubric.title) return { status: 'not-eligible', reason: 'rubric candidate title does not match funnel source', decision };
+  if (!sourceRubric || rubric.score !== rubricScore(sourceRubric) || rubric.grade !== rubricGrade(rubricScore(sourceRubric)))
+    return { status: 'not-eligible', reason: 'rubric score or grade does not match funnel source', decision };
+
+  let proposal;
+  try { proposal = input.consensus.show(input.consensusProposalId); }
+  catch (error) {
+    if (error instanceof Error && error.message === `consensus proposal not found: ${input.consensusProposalId}`)
+      return { status: 'awaiting-consensus', consensusProposalId: input.consensusProposalId, decision };
+    throw error;
+  }
+  if (proposal.category !== 'period-budget' || proposal.factId !== decision.candidate.id
+    || proposal.title !== rubric.title || proposal.thresholds.length > 0 || proposal.status !== 'agreed')
+    return { status: 'awaiting-consensus', consensusProposalId: input.consensusProposalId, decision };
+  const agreement = proposal.reviews.find((review) => review.verdict === 'agree' && review.by !== proposal.proposedBy);
+  if (!agreement) return { status: 'awaiting-consensus', consensusProposalId: input.consensusProposalId, decision };
+
+  const candidate = decision.candidate;
+  if (candidate.priority !== 'P1' && candidate.priority !== 'P2')
+    return { status: 'not-eligible', reason: 'funnel candidate priority is missing or unsupported', decision };
+  if (!candidate.owner) return { status: 'not-eligible', reason: 'funnel candidate owner is missing', decision };
+  let placement: PlacementDecision;
+  try {
+    // The funnel checks urgency/capacity eligibility; this second dry run applies the rubric's deferral grade.
+    placement = placeCell({
+      id: candidate.id,
+      title: candidate.text,
+      owner: candidate.owner,
+      priority: candidate.priority,
+      predecessors: [],
+      grade: rubric.grade,
+      ...(candidate.deadlineVersion ? { deadlineVersion: candidate.deadlineVersion } : {}),
+    }, { ...input.placement, dryRun: true });
+  } catch (error) {
+    return { status: 'not-eligible', reason: error instanceof Error ? error.message : String(error), decision };
+  }
+
+  return {
+    status: 'planned',
+    consensus: { id: proposal.id, status: 'agreed', proposedBy: proposal.proposedBy, agreedBy: agreement.by },
+    decision,
+    rubric: { score: rubric.score, grade: rubric.grade },
+    placement,
+  };
+}