elanous 0.2.41 → 0.2.43

package/src/agent-mission/mission-cli.ts

@@ -6,6 +6,8 @@
 
 import { readFileSync } from 'node:fs';
 import type { AgentBackend, AgentMissionResult, EvidenceMode } from './driver.js';
+import { runAgentMissionDuo, type DuoDeps, type DuoResult } from './duo.js';
+import type { AgentCli, AgentCliDetection, AgentCliPreparation } from './tool-install.js';
 import { buildAgentMissionDevSpec, executeAgentMissionReroute, type runDevPipeline } from '../self-dev/dev-pipeline.js';
 import { parsePositiveInt } from '../self-dev/dev-cli.js';
 import { parsePluginRef } from './in-agent-plugin.js';
@@ -16,7 +18,9 @@ export interface MissionCliOpts {
   base?: string;
   backend?: string;
   chain?: string;
+  duo?: boolean;
   headless?: boolean;
+  followUp?: string;
   plugin?: string;
   resources?: 'on' | 'off';
   evidence?: string; // 'doc' | 'tsc' | 'test'
@@ -33,14 +37,18 @@ export interface MissionCliOpts {
 
 export interface MissionCliDeps {
   resolveBackend: (name?: string) => AgentBackend;
+  detectAgentCli?: (agent: 'claude' | 'codex') => AgentCliDetection;
+  prepareAgentCli?: (agent: AgentCli) => Promise<AgentCliPreparation>;
+  onStatus?: (line: string) => void;
   signal?: AbortSignal;
   readFile?: (path: string) => string;
   runDevPipeline?: typeof runDevPipeline;
+  duoDeps?: DuoDeps;
 }
 
 export type MissionCliOutcome =
   | { ok: false; message: string; exitCode: number }
-  | { ok: true; result: AgentMissionResult; exitCode: number };
+  | { ok: true; result: AgentMissionResult; duo?: DuoResult; exitCode: number };
 
 /** mission CLI 글루 — 검증/구성/실행. process.exit·console 없음(호출부가 I/O). */
 export async function runAgentMissionCliCommand(
@@ -50,8 +58,11 @@ export async function runAgentMissionCliCommand(
 ): Promise<MissionCliOutcome> {
   // ── backend 검증(fail-fast·단일 resolve) ──
   const chain = opts.chain?.split(',').map((item) => item.trim());
-  if (chain && (opts.commit === false || !['codex,claude,elanous', 'codex,claude,codex,elanous'].includes(chain.join(',')) || (opts.backend && opts.backend !== 'codex') || opts.headless)) {
-    return { ok: false, message: '--chain 은 codex,claude[,codex],elanous 형식이며 --backend 는 첫 backend 와 같아야 하고 --headless/--no-commit 은 함께 쓸 수 없습니다', exitCode: 1 };
+  if (chain && (opts.commit === false || !['codex,claude,elanous', 'codex,claude,codex,elanous'].includes(chain.join(',')) || (opts.backend && opts.backend !== 'codex') || opts.headless || opts.followUp !== undefined)) {
+    return { ok: false, message: '--chain 은 codex,claude[,codex],elanous 형식이며 --backend 는 첫 backend 와 같아야 하고 --headless/--follow-up/--no-commit 은 함께 쓸 수 없습니다', exitCode: 1 };
+  }
+  if (opts.duo && (chain || opts.backend || opts.headless || opts.followUp !== undefined || opts.plugin || opts.enhance === false)) {
+    return { ok: false, message: '--duo 는 Codex·Claude 병렬 기본값만 지원하며 --chain/--backend/--headless/--follow-up/--plugin/--no-enhance 와 함께 쓸 수 없습니다', exitCode: 1 };
   }
   let agentBackend: AgentBackend;
   try { agentBackend = deps.resolveBackend(chain?.[0] ?? opts.backend); }
@@ -59,8 +70,14 @@ export async function runAgentMissionCliCommand(
   if (opts.headless && agentBackend.name !== 'claude') {
     return { ok: false, message: '--headless 는 --backend claude 전용입니다', exitCode: 1 };
   }
+  if (opts.followUp !== undefined && !opts.followUp.trim()) {
+    return { ok: false, message: '--follow-up 은 비어 있지 않은 후속 프롬프트가 필요합니다', exitCode: 1 };
+  }
+  if (opts.followUp !== undefined && !['claude', 'codex'].includes(agentBackend.name)) {
+    return { ok: false, message: '--follow-up 은 Claude 또는 Codex backend 전용입니다', exitCode: 1 };
+  }
   const plugin = opts.plugin ? parsePluginRef(opts.plugin) : null;
-  if (opts.plugin !== undefined && (!plugin || !['codex', 'claude'].includes(agentBackend.name) || opts.headless)) {
+  if (opts.plugin !== undefined && (!plugin || !['codex', 'claude'].includes(agentBackend.name) || opts.headless || opts.followUp !== undefined)) {
     return { ok: false, message: '--plugin 은 codex/claude 대화형 backend 에서 <name>@<market> 형식이어야 합니다', exitCode: 1 };
   }
   if (opts.resources !== undefined && opts.resources !== 'on' && opts.resources !== 'off') {
@@ -105,6 +122,7 @@ export async function runAgentMissionCliCommand(
     resources: opts.resources ?? 'on',
     ...(opts.backend ? { backendExplicit: opts.backend } : {}),
     ...(opts.headless ? { headless: true } : {}),
+    ...(opts.followUp !== undefined ? { followUp: opts.followUp } : {}),
     branch: opts.branch,
     ...(opts.base ? { base: opts.base } : {}),
     ...(opts.enhance === false ? { enhanceOff: true } : {}),
@@ -114,6 +132,47 @@ export async function runAgentMissionCliCommand(
     ...(opts.deliverable ? { deliverableHint: opts.deliverable } : {}),
     ...(opts.screens ? { screensDir: opts.screens } : {}),
   });
+  // The production CLI injects the host probe; injected tests can assert this preflight
+  // without spawning an agent CLI. For a chain, inspect each external CLI before any launch.
+  const externalAgents: Array<'claude' | 'codex'> = opts.duo ? ['codex', 'claude'] : [...new Set((chain ?? [agentBackend.name]).filter(
+    (name): name is 'claude' | 'codex' => name === 'claude' || name === 'codex',
+  ))];
+  if (deps.prepareAgentCli) {
+    for (const agent of externalAgents) {
+      const prepared = await deps.prepareAgentCli(agent);
+      if (!prepared.ready) return { ok: false, message: prepared.message, exitCode: 1 };
+    }
+  } else {
+    const detections = deps.detectAgentCli ? externalAgents.map((agent) => deps.detectAgentCli!(agent)) : [];
+    const statusLine = detections.map(({ message }) => message).join(' · ');
+    if (statusLine) deps.onStatus?.(statusLine);
+    const notReady = detections.find(({ installed, login }) => installed !== true || login !== 'ready');
+    if (notReady) {
+      const message = notReady.installed === false
+        ? `${notReady.message}; 공식 설치 후 다시 실행`
+        : notReady.installed === null
+          ? `${notReady.message}; 설치 상태를 확인한 뒤 다시 실행`
+          : notReady.login === 'api-key'
+            ? `${notReady.message}; API 키 요금 고지와 동의 화면이 아직 없어 미션을 시작하지 않습니다 — Codex 구독 로그인(codex login) 후 다시 실행`
+            : notReady.login === 'needed'
+              ? `${notReady.message}; ${notReady.agent} login 후 다시 실행`
+              : `${notReady.message}; 로그인 상태를 확인한 뒤 다시 실행`;
+      return { ok: false, message, exitCode: 1 };
+    }
+  }
+  if (opts.duo) {
+    const duo = await runAgentMissionDuo([mission], {
+      left: 'codex', right: 'claude', branch: opts.branch, ...(opts.base ? { base: opts.base } : {}),
+      evidence: opts.evidence, ...(opts.docDir ? { docDir: opts.docDir } : {}), ...(opts.docGlob ? { docGlob: opts.docGlob } : {}),
+      ...(opts.testPath ? { testPath: opts.testPath } : {}), ...(opts.file ? { file: opts.file } : {}),
+      maxRounds: opts.maxRounds, commit: opts.commit,
+    }, { ...deps.duoDeps, resolveBackend: deps.duoDeps?.resolveBackend ?? deps.resolveBackend });
+    const result = duo.sides.find((side) => side.result)?.result ?? {
+      ok: false, worktree: '', branch: null, rounds: 0, evidencePath: null, committed: false,
+      usedOmniCrawl: false, detail: duo.lines.join('\n'),
+    };
+    return { ok: true, result, duo, exitCode: duo.exitCode };
+  }
   const { result, exitCode } = await executeAgentMissionReroute(
     spec, agentBackend,
     { ...(deps.runDevPipeline ? { runDevPipeline: deps.runDevPipeline } : {}), ...(deps.signal ? { signal: deps.signal } : {}) },

package/src/agent-mission/mission-hand-reply.ts

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+import { createMissionOutStore, type MissionReplyMessageFields } from './mission-out.js';
+import { postMissionLineEvent } from './mission-line.js';
+import { sanitizeForPtyInput } from './provision.js';
+import { requestRemotePtyControl } from '../pty-shell/pty-control-ipc.js';
+
+export interface MissionHandReplyTarget {
+  missionId: string;
+  attemptId: string;
+  agent: 'codex' | 'claude';
+  token: string;
+  nexusUrl: string;
+  ptyId?: string;
+  runId?: string;
+}
+
+export type MissionHandReplyResult =
+  | { ok: true; recorded: true; delivered: true; delivery: 'pty-arbiter'; lineId: string }
+  | { ok: true; recorded: true; delivered: false; delivery: 'ask-ledger' | 'record-only'; lineId: string }
+  | { ok: false; recorded: boolean; delivered: false; reason: string; lineId?: string };
+
+/** Persist headless answers/corrections for the waiting mission worker; never write to a PTY. */
+export async function recordHeadlessMissionHandReply(input: {
+  missionId: string;
+  kind: 'answer' | 'correct';
+  text: string;
+  replyTo: number;
+  scope?: string;
+  stop?: boolean;
+  priority?: string;
+}, store: ReturnType<typeof createMissionOutStore>): Promise<MissionHandReplyResult> {
+  const record = store.read(input.missionId);
+  if (!record) return { ok: false, recorded: false, delivered: false, reason: 'mission not found' };
+  if (record.status !== 'running') return { ok: false, recorded: false, delivered: false, reason: `mission is ${record.status}` };
+  const lineId = randomUUID();
+  const fields: MissionReplyMessageFields = {
+    lineId, kind: input.kind, replyTo: input.replyTo, source: 'parent-hand-reply',
+    ...(input.kind === 'correct' ? {
+      state: 'correct 미적용(headless record-only)',
+      ...(input.scope ? { scope: input.scope } : {}),
+      ...(input.stop !== undefined ? { stop: input.stop } : {}),
+      ...(input.priority ? { priority: input.priority } : {}),
+    } : {}),
+  };
+  try {
+    await store.reply(input.missionId, input.text, false, fields);
+    return { ok: true, recorded: true, delivered: false, delivery: 'record-only', lineId };
+  } catch (error) {
+    return { ok: false, recorded: false, delivered: false, reason: error instanceof Error ? error.message : String(error), lineId };
+  }
+}
+
+/** Record a parent answer/correction on the scoped mission line before routing it through the PTY arbiter. */
+export async function recordAndDeliverMissionHandReply(input: {
+  target: MissionHandReplyTarget;
+  kind: 'answer' | 'correct';
+  text: string;
+  actor: 'agent' | 'human';
+  replyTo: number;
+  runId?: string;
+  scope?: string;
+  stop?: boolean;
+  priority?: string;
+}, deps: {
+  postLine?: typeof postMissionLineEvent;
+  control?: typeof requestRemotePtyControl;
+} = {}): Promise<MissionHandReplyResult> {
+  const { target } = input;
+  const lineId = randomUUID();
+  const postLine = deps.postLine ?? postMissionLineEvent;
+  const control = deps.control ?? requestRemotePtyControl;
+  const correctIdentityMissing = input.kind === 'correct'
+    && (!input.runId || !target.runId || !target.ptyId || input.actor !== 'agent');
+  const runMismatch = input.kind === 'correct' && !correctIdentityMissing && input.runId !== target.runId;
+  const state = correctIdentityMissing ? 'correct 미적용(ptyId/runId 없음 또는 actor!=agent)'
+    : runMismatch ? 'correct 미적용(child runId 불일치)' : undefined;
+  let ingressState: string | undefined;
+  try {
+    const recorded = await postLine({
+      lineId, missionId: target.missionId, attemptId: target.attemptId, agent: target.agent,
+      ...(input.runId ? { runId: input.runId } : {}), ...(target.ptyId ? { ptyId: target.ptyId } : {}),
+      replyTo: input.replyTo,
+      type: input.kind, source: 'parent-hand-reply', text: input.text,
+      ...(state ? { state } : {}),
+      ...(input.kind === 'correct' ? {
+        ...(input.scope ? { scope: input.scope } : {}),
+        ...(input.stop !== undefined ? { stop: input.stop } : {}),
+        ...(input.priority ? { priority: input.priority } : {}),
+      } : {}),
+    }, { env: {
+      ELANOUS_HAND_TOKEN: target.token,
+      ELANOUS_HAND_ATTEMPT_ID: target.attemptId,
+      ELANOUS_NEXUS_URL: target.nexusUrl,
+    } });
+    ingressState = recorded.state;
+  } catch (error) {
+    return { ok: false, recorded: false, delivered: false, reason: error instanceof Error ? error.message : String(error), lineId };
+  }
+  if (input.kind === 'correct' && ingressState?.startsWith('correct 미적용')) {
+    return { ok: false, recorded: true, delivered: false, reason: ingressState, lineId };
+  }
+  if (state) return { ok: false, recorded: true, delivered: false, reason: state, lineId };
+  // Answers are delivered asynchronously through the mission ledger: the
+  // matching ask waiter consumes kind=answer + replyTo. They do not need PTY
+  // identity and this call cannot claim that a waiter has already consumed it.
+  if (input.kind === 'answer') return { ok: true, recorded: true, delivered: false, delivery: 'ask-ledger', lineId };
+  if (!target.ptyId || !target.runId || input.runId !== target.runId || input.actor !== 'agent') {
+    return { ok: false, recorded: true, delivered: false, reason: 'ptyId/runId 없음 또는 불일치', lineId };
+  }
+  const label = '[Elanous correction]';
+  const safeText = sanitizeForPtyInput(input.text, 4_000);
+  if (!safeText) return { ok: false, recorded: true, delivered: false, reason: 'reply text empty after PTY sanitization', lineId };
+  const result = await control(target.ptyId, 'input-text', { chars: `${label} ${safeText}\r` }, {
+    actor: 'agent', requesterRunId: target.runId, timeoutMs: 2_000,
+  });
+  if (result.status !== 'success') return { ok: false, recorded: true, delivered: false, reason: `PTY arbiter ${result.status}`, lineId };
+  return { ok: true, recorded: true, delivered: true, delivery: 'pty-arbiter', lineId };
+}

package/src/agent-mission/mission-line.ts

@@ -0,0 +1,180 @@
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { acquireLockSync } from '../storage/file-lock.js';
+import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
+import { debug } from '../debug/log.js';
+
+export type MissionLineType = 'progress' | 'final' | 'ask' | 'answer' | 'correct';
+export class MissionLineHttpError extends Error {
+  constructor(readonly status: number) {
+    super(`mission line rejected (${status})`);
+    this.name = 'MissionLineHttpError';
+  }
+}
+export interface MissionLineInput {
+  lineId: string;
+  missionId: string;
+  attemptId: string;
+  /** Bound PTY/run identity for parent-to-child answer/correction routing. */
+  runId?: string;
+  ptyId?: string;
+  replyTo?: number;
+  agent: 'codex' | 'claude';
+  type: MissionLineType;
+  source: string;
+  text: string;
+  state?: string;
+  kind?: string;
+  defaults?: string;
+  deadline?: string;
+  scope?: string;
+  stop?: boolean;
+  priority?: string;
+}
+export interface MissionLineEvent extends MissionLineInput {
+  sequence: number;
+  createdAt: string;
+  done: boolean;
+  graphEvents?: Array<{
+    seq: number; ts: string; type: 'node-added'; node: string; kind: 'hand';
+    decider: 'mission-line'; reason: string; who: string; what: string; missionId: string;
+  }>;
+}
+
+interface MissionLineAuthority { missionId: string; attemptId: string; finalLineId: string; tokenHash: string; agent: 'codex' | 'claude'; who: string; what: string; runId?: string; ptyId?: string; revoked?: boolean }
+const validId = (value: string): boolean => /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(value);
+const authPath = (root: string, id: string): string => join(root, 'agent-missions', `${id}.line-auth.json`);
+const lockPath = (root: string, id: string): string => join(root, 'agent-missions', `${id}.line.lock`);
+const hashToken = (token: string): string => createHash('sha256').update(token).digest('hex');
+const equalHash = (a: string, b: string): boolean => {
+  const left = Buffer.from(a, 'hex'); const right = Buffer.from(b, 'hex');
+  return left.length === right.length && timingSafeEqual(left, right);
+};
+
+function safeMissionId(value: string): string {
+  if (!validId(value)) throw new Error('missionId 형식이 올바르지 않습니다');
+  return value.toLowerCase();
+}
+function readAuthority(root: string, missionId: string): MissionLineAuthority | null {
+  try {
+    const value: unknown = JSON.parse(readFileSync(authPath(root, safeMissionId(missionId)), 'utf8'));
+    if (!value || typeof value !== 'object') return null;
+    const authority = value as MissionLineAuthority;
+    return authority.missionId === missionId && typeof authority.attemptId === 'string'
+      && typeof authority.tokenHash === 'string' && /^[0-9a-f]{64}$/i.test(authority.tokenHash)
+      && validId(authority.finalLineId)
+      && (authority.agent === 'codex' || authority.agent === 'claude')
+      && typeof authority.who === 'string' && typeof authority.what === 'string' ? authority : null;
+  } catch { return null; }
+}
+
+export function createMissionLineStore(root: string) {
+  const issue = (input: { missionId: string; attemptId: string; agent: 'codex' | 'claude'; who: string; what: string; runId?: string; ptyId?: string }): { token: string; attemptId: string; finalLineId: string } => {
+    const missionId = safeMissionId(input.missionId);
+    if (!input.attemptId.trim() || !input.who.trim() || !input.what.trim()) throw new Error('attemptId, who, what 은 비어 있을 수 없습니다');
+    const dir = join(root, 'agent-missions'); mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const token = randomBytes(32).toString('base64url');
+    const finalLineId = randomUUID();
+    const authority: MissionLineAuthority = { missionId, attemptId: input.attemptId, finalLineId, tokenHash: hashToken(token), agent: input.agent, who: input.who.trim(), what: input.what.trim(), ...(input.runId ? { runId: input.runId } : {}), ...(input.ptyId ? { ptyId: input.ptyId } : {}) };
+    const release = acquireLockSync(lockPath(root, missionId));
+    try { writeFileSync(authPath(root, missionId), `${JSON.stringify(authority)}\n`, { mode: 0o600 }); }
+    finally { release(); }
+    return { token, attemptId: input.attemptId, finalLineId };
+  };
+
+  const authorize = (input: MissionLineInput, token: string): MissionLineAuthority => {
+    const missionId = safeMissionId(input.missionId);
+    const authority = readAuthority(root, missionId);
+    if (!authority || authority.revoked || authority.attemptId !== input.attemptId || authority.agent !== input.agent || !equalHash(authority.tokenHash, hashToken(token))) {
+      throw new Error('mission line unauthorized');
+    }
+    if (!/^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(input.lineId)
+      || !['progress', 'final', 'ask', 'answer', 'correct'].includes(input.type)
+      || typeof input.text !== 'string' || !input.text.trim() || typeof input.source !== 'string' || !input.source.trim()
+      || (input.replyTo !== undefined && (!Number.isInteger(input.replyTo) || input.replyTo < 1))) throw new Error('mission line payload invalid');
+    if (input.type === 'ask' && !input.defaults?.trim()) throw new Error('mission line ask requires defaults');
+    if (input.type === 'correct' && (!input.scope || input.stop === undefined || !input.priority)) throw new Error('mission line correct requires scope, stop, and priority');
+    return authority;
+  };
+  const revoke = (missionId: string): void => {
+    const id = safeMissionId(missionId); const authority = readAuthority(root, id); if (!authority || authority.revoked) return;
+    const release = acquireLockSync(lockPath(root, id));
+    try { writeFileSync(authPath(root, id), `${JSON.stringify({ ...authority, revoked: true })}\n`, { mode: 0o600 }); }
+    finally { release(); }
+  };
+  return { issue, authorize, revoke };
+}
+
+/** Child/hook client: credentials are read only from the per-mission child environment. */
+export async function postMissionLineEvent(input: MissionLineInput, deps: { fetch?: typeof fetch; env?: NodeJS.ProcessEnv; resolveUrl?: () => string | null } = {}): Promise<MissionLineEvent> {
+  const env = deps.env ?? process.env;
+  const token = env.ELANOUS_HAND_TOKEN?.trim();
+  const base = env.ELANOUS_NEXUS_URL?.trim() || deps.resolveUrl?.() || resolveDaemonEndpoint()?.baseUrl;
+  if (!token || !input.attemptId.trim() || !base) throw new Error('mission line credentials or NEXUS endpoint unavailable');
+  const response = await (deps.fetch ?? fetch)(`${base.replace(/\/$/, '')}/v1/missions/${encodeURIComponent(input.missionId)}/line`, {
+    method: 'POST', headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+    body: JSON.stringify(input),
+  });
+  if (!response.ok) throw new MissionLineHttpError(response.status);
+  return await response.json() as MissionLineEvent;
+}
+
+/** Single NEXUS ingress; eventBus feeds the existing /v1/events SSE subscribers. */
+export async function handleMissionLineRequest(
+  req: Request,
+  root: string,
+  append: (input: MissionLineInput, authority: { who: string; what: string }) => Promise<MissionLineEvent>,
+  publish: (event: MissionLineEvent) => void,
+): Promise<Response | undefined> {
+  const url = new URL(req.url);
+  const match = /^\/v1\/missions\/([^/]+)\/line$/.exec(url.pathname);
+  if (!match) return undefined;
+  if (req.method !== 'POST') return new Response(JSON.stringify({ error: 'method_not_allowed' }), { status: 405, headers: { allow: 'POST', 'content-type': 'application/json' } });
+  let missionId: string;
+  try { missionId = safeMissionId(decodeURIComponent(match[1]!)); }
+  catch { return new Response(JSON.stringify({ error: 'invalid_payload' }), { status: 400, headers: { 'content-type': 'application/json' } }); }
+  const token = /^Bearer (.+)$/.exec(req.headers.get('authorization') ?? '')?.[1];
+  if (!token) return new Response(JSON.stringify({ error: 'unauthorized' }), { status: 401, headers: { 'content-type': 'application/json' } });
+  let authorized = false;
+  try {
+    const body: unknown = await req.json();
+    if (!body || typeof body !== 'object' || Array.isArray(body)) return new Response(JSON.stringify({ error: 'invalid_payload' }), { status: 400, headers: { 'content-type': 'application/json' } });
+    const record = body as Record<string, unknown>;
+    if (Object.keys(record).some((key) => !['lineId', 'missionId', 'attemptId', 'runId', 'ptyId', 'replyTo', 'agent', 'type', 'source', 'text', 'state', 'kind', 'defaults', 'deadline', 'scope', 'stop', 'priority'].includes(key))) return new Response(JSON.stringify({ error: 'invalid_payload' }), { status: 400, headers: { 'content-type': 'application/json' } });
+    const input = record as unknown as MissionLineInput;
+    if (typeof input.lineId !== 'string' || typeof input.missionId !== 'string' || safeMissionId(input.missionId) !== missionId || typeof input.attemptId !== 'string' || !['codex', 'claude'].includes(input.agent)
+      || typeof input.type !== 'string' || typeof input.source !== 'string' || typeof input.text !== 'string'
+      || (input.runId !== undefined && typeof input.runId !== 'string') || (input.ptyId !== undefined && typeof input.ptyId !== 'string')
+      || (input.replyTo !== undefined && (typeof input.replyTo !== 'number' || !Number.isInteger(input.replyTo) || input.replyTo < 1))
+      || input.text.length > 20_000 || (input.state !== undefined && typeof input.state !== 'string')
+      || (input.kind !== undefined && typeof input.kind !== 'string')
+      || (input.defaults !== undefined && typeof input.defaults !== 'string')
+      || (input.deadline !== undefined && typeof input.deadline !== 'string')
+      || (input.scope !== undefined && typeof input.scope !== 'string')
+      || (input.stop !== undefined && typeof input.stop !== 'boolean')
+      || (input.priority !== undefined && typeof input.priority !== 'string')) return new Response(JSON.stringify({ error: 'invalid_payload' }), { status: 400, headers: { 'content-type': 'application/json' } });
+    const authority = createMissionLineStore(root).authorize(input, token);
+    authorized = true;
+    const correctIdentityMissing = input.type === 'correct' && (!authority.ptyId || !authority.runId || !input.ptyId || !input.runId);
+    const correctIdentityMismatch = input.type === 'correct' && !correctIdentityMissing
+      && (input.ptyId !== authority.ptyId || input.runId !== authority.runId || input.agent !== authority.agent);
+    const event = await append(correctIdentityMissing || correctIdentityMismatch
+      ? { ...input, state: correctIdentityMissing ? 'correct 미적용(ptyId/runId 없음)' : 'correct 미적용(PTY/runId 불일치)' }
+      : input, { who: authority.who, what: authority.what });
+    if (input.type === 'final') createMissionLineStore(root).revoke(missionId);
+    try { publish(event); }
+    catch (error) { debug.log('agent-mission', 'line-ingress-publish-failed', { missionId, error: String(error) }, { level: 'error' }); }
+    return new Response(JSON.stringify(event), { status: 202, headers: { 'content-type': 'application/json' } });
+  } catch (error) {
+    const unauthorized = error instanceof Error && error.message === 'mission line unauthorized';
+    if (authorized) {
+      if (error instanceof MissionLineHttpError && (error.status === 404 || error.status === 409)) {
+        return new Response(JSON.stringify({ error: error.status === 404 ? 'mission_not_found' : 'mission_state_conflict' }), { status: error.status, headers: { 'content-type': 'application/json' } });
+      }
+      debug.log('agent-mission', 'line-ingress-append-failed', { missionId, error: String(error) }, { level: 'error' });
+      return new Response(JSON.stringify({ error: 'mission_line_store_failed' }), { status: 500, headers: { 'content-type': 'application/json' } });
+    }
+    return new Response(JSON.stringify({ error: unauthorized ? 'unauthorized' : 'invalid_payload' }), { status: unauthorized ? 401 : 400, headers: { 'content-type': 'application/json' } });
+  }
+}