elanous 0.2.12 → 0.2.13

package/src/index.ts

@@ -41,6 +41,7 @@ import { registerRepoCommands } from './cli/repo-cli.js';
 import { registerAgentCommands, runChatTurnCli, emitDetachedProgress } from './cli/agent-cli.js';
 export { runChatTurnCli, buildCliAgentTools, setCliAgentDispatchForTesting, emitDetachedProgress, emitHarnessFeedbackProgress } from './cli/agent-cli.js';
 import { registerOpsCommands } from './cli/ops-cli.js';
+import { registerOutputsCommands } from './cli/outputs-cli.js';
 import { registerPublishCommands } from './cli/publish-cli.js';
 import { registerAutopilotCommands } from './cli/autopilot-cli.js';
 import { registerRoleCommands } from './cli/role-cli.js';
@@ -103,7 +104,7 @@ import type { AcpPermissionApprover } from './acp/client.js';
 import { runGitCommand } from './git-fs/runner.js';
 import { debug, redactSecretText, redactSecrets } from './debug/log.js';
 import { installHarnessCliCommand, type HarnessAskSayChildLlmOptions, type HarnessAskSayOptions, type HarnessPlanOptions } from './harness/harness-cli-command.js';
-import { formatCliUserError, isCliUserError } from './cli/cli-user-error.js';
+import { CliUserError, formatCliUserError, isCliUserError } from './cli/cli-user-error.js';
 import { dispatchSolveMission } from './skills/tools/solve-mission.js';
 import { performBrowserAction, type BrowserActionDeps, type BrowserActionResult } from './harness/browser-act.js';
 import { decideTypeAction, type TypeActionDecision, type TypeTarget } from './harness/browser-act-type.js';
@@ -868,7 +869,75 @@ registerUsageCommand(program);
 registerLiveCommands(program);
 registerResearchCommand(program);
 registerReleaseCommands(program);
+// HQ-HB · HQ-FENCE (10-04): one writer across mbp · node-b · cloud-vm — lease on the arbiter, 2-of-3 quorum, generation fencing.
+const hqCmd = program.command('hq').description('본부 임대 — 하트비트·중재·단일 작성자 래퍼');
+async function hqSink(): Promise<void> {
+  try { await (await import('./domains/standalone-log-sink.js')).registerStandaloneLogSink('hq'); } catch { /* observation is fail-soft */ }
+}
+hqCmd.command('host').description('이 머신의 HQ 호스트 이름 설정')
+  .command('set <name>').description('호스트 로컬 ~/.elanous-hq/host 에 한 줄로 기록')
+  .action(async (name: string) => {
+    try {
+      const { hqHostSet } = await import('./hq/hq.js');
+      const path = hqHostSet(name);
+      console.log(`hq host set: ${name} (${path})`);
+    } catch (error) { console.error(`hq host set: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
+hqCmd.command('lease').argument('<action>', 'acquire|renew|status|release')
+  .option('--host <name>', '이 호스트 이름(기본 ~/.elanous-hq/host · hq.hostName · os.hostname)')
+  .option('--json', 'JSON 출력')
+  .action(async (action: string, opts: { host?: string; json?: boolean }) => {
+    try {
+      if (!['acquire', 'renew', 'status', 'release'].includes(action)) throw new CliUserError(`hq lease: unknown action ${action}`, 'acquire|renew|status|release');
+      await hqSink();
+      const { hqLease } = await import('./hq/hq.js');
+      const result = hqLease(action as 'acquire', {}, opts.host ? { host: opts.host } : {});
+      if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`);
+      else console.log(result.ok ? `hq lease ${action}: ok${'record' in result && result.record ? ` · holder ${result.record.holder} · generation ${result.record.generation}` : ''}` : `hq lease ${action}: refused — ${'reason' in result ? result.reason : ''}`);
+      if (!result.ok) process.exitCode = 2;
+    } catch (error) { if (error instanceof CliUserError) throw error; console.error(`hq lease: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
+hqCmd.command('heartbeat').description('보유자는 갱신 · 아니면 대기(보유자에 닿는지 중재자에 보고)').option('--json', 'JSON 출력')
+  .action(async (opts: { json?: boolean }) => {
+    try {
+      await hqSink();
+      const result = (await import('./hq/hq.js')).hqHeartbeat();
+      if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`); else console.log(`hq heartbeat: ${result.outcome}`);
+    } catch (error) { console.error(`hq heartbeat: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
+hqCmd.command('arbiter-check').description('중재자(cloud-vm)에서: 보유자 탐침 · 연속 2회 이중 불통이면 대기 호스트 승격').option('--json', 'JSON 출력')
+  .action(async (opts: { json?: boolean }) => {
+    try {
+      await hqSink();
+      const result = (await import('./hq/hq.js')).hqArbiterCheck();
+      if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`); else console.log(`hq arbiter-check: ${result.promoted ? `promoted ${result.holder} gen ${result.generation}` : `streak ${result.streak}`}`);
+    } catch (error) { console.error(`hq arbiter-check: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
+hqCmd.command('seen').description('이 호스트가 본 가장 높은 임대 세대(한 번도 못 봤으면 exit 3 — 드릴 전 기본 원천 판단용)').option('--json', 'JSON 출력')
+  .action(async (opts: { json?: boolean }) => {
+    const result = (await import('./hq/hq.js')).hqSeen();
+    if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`);
+    else console.log(result.seen ? `hq seen: generation ${result.generation}` : 'hq seen: never');
+    process.exitCode = result.seen ? 0 : 3;
+  });
+hqCmd.command('fence').description('이 호스트가 임대를 쥐었을 때만 명령 실행(아니면 건너뜀 · exit 0)')
+  .requiredOption('--role <role>', 'telegram-poller|cron|seat-loop|release-run|conatus|git-push')
+  .argument('<command...>', '-- 뒤의 명령')
+  .action(async (command: string[], opts: { role: string }) => {
+    const { FENCE_ROLES, hqFenceRun } = await import('./hq/hq.js');
+    if (!(FENCE_ROLES as readonly string[]).includes(opts.role)) throw new CliUserError(`hq fence: unknown role ${opts.role}`, FENCE_ROLES.join('|'));
+    await hqSink();
+    process.exitCode = hqFenceRun(opts.role as 'cron', command);
+  });
 const seatCmd = program.command('seat').description('분배된 자리의 하루 루프와 보고');
+seatCmd.command('answer <askId> <answer>').description('자리 질문에 답을 남기고 원래 표면으로 회신 예약')
+  .action(async (askId: string, answer: string) => {
+    try {
+      const { answerSeatAsk } = await import('./seat-dispatch/seat-ask.js');
+      answerSeatAsk(askId, answer);
+      console.log(`자리 답변 기록: ${askId}`);
+    } catch (error) { console.error(`seat answer: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
 seatCmd.command('loop').requiredOption('--seat <SEAT>', 'MK|OP|TC|UX')
   .requiredOption('--once', '한 번 실행')
   .option('--json', 'JSON 출력')
@@ -893,6 +962,20 @@ seatCmd.command('report').requiredOption('--seat <SEAT>', 'MK|OP|TC|UX')
       else console.log(result.body);
     } catch (error) { console.error(`seat report: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
   });
+seatCmd.command('pack').description('자리 묶음').command('export')
+  .requiredOption('--seat <SEAT>', '내보낼 자리')
+  .requiredOption('--out <dir>', '비어 있는 산출 폴더')
+  .action(async (opts: { seat: string; out: string }) => {
+    try {
+      const { exportSeatPack } = await import('./seat-loop/seat-pack.js');
+      const result = exportSeatPack(opts.seat, opts.out);
+      console.log(`seat pack ${result.name} ${result.version}: ${result.files.length} files → ${opts.out}`);
+    } catch (error) {
+      const { SeatPackLeakError } = await import('./seat-loop/seat-pack.js');
+      console.error(`seat pack export: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = error instanceof SeatPackLeakError ? 2 : 1;
+    }
+  });
 registerModelWatchCommand(program);
 registerDoctorCommand(program);
 // runCli() → main() → program.parseAsync() dispatches control serve and resources where|list.
@@ -974,6 +1057,19 @@ marketCmd.command('keygen').description('Generate a local test index signing key
     console.log(`Generated local index key ${pair.keyId}`);
   });
 
+const stewardCmd = program.command('steward').description('Steward loop controls');
+stewardCmd.command('readiness').description('Read-only shadow evidence for a live decision')
+  .option('--since <duration>', 'Lookback duration, e.g. 24h', '24h')
+  .option('--json', 'JSON output')
+  .action(async (opts: { since: string; json?: boolean }) => {
+    process.exitCode = (await import('./steward/readiness.js')).runStewardReadinessCli(opts);
+  });
+stewardCmd.command('mode [mode]').description('Show or set the steward mode: off|shadow|live|rescue (rescue = HQ move: launch·harvest·alert·decision cards only)')
+  .option('--json', 'JSON output')
+  .action(async (mode: string | undefined, opts: { json?: boolean }) => {
+    process.exitCode = await (await import('./steward/rescue.js')).runStewardModeCli(mode, opts);
+  });
+
 program.command('directive').description('Turn instructions into Linear issues')
   .command('add <text>').option('--source <source>', 'telegram|pwa|tui|cli', 'cli')
   .option('--dry-run', 'Preview the normalized directive without contacting Linear')
@@ -3029,6 +3125,39 @@ const harnessOrchestrateCmd = registerHarnessOrchestrateCapabilityOptions(
   });
 
 const contextCmd = program.command('context').description('외부 에이전트 맥락 이벤트');
+contextCmd.command('day')
+  .description('자리 넷과 외부 세션의 최근 맥락 이벤트 수·마지막 시각 (읽기 전용)')
+  .option('--since <hours>', '최근 시간 창 (예: 24h)', '24h')
+  .option('--json', '구조화된 JSON 출력')
+  .action(async (opts: { since: string; json?: boolean }) => {
+    try {
+      const { contextDay, renderContextDay } = await import('./context-bus/context-day.js');
+      const report = contextDay(opts.since);
+      await writeStdoutJson(`${opts.json ? JSON.stringify(report) : renderContextDay(report)}\n`);
+    } catch (error) {
+      console.error(`context day: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 2;
+    }
+  });
+contextCmd.command('condense')
+  .description('최근 맥락 이벤트·결정·조율 요약을 프로젝트/자리별 장기 기억 후보 JSON ⊕ Markdown 으로 응축')
+  .option('--since <hours>', '최근 시간 창 (예: 24h)', '24h')
+  .option('--dry-run', '읽고 stdout 에만 출력 (기본 동작)')
+  .option('--apply', '충돌은 OP 결정 원장으로 올리고 비충돌 후보를 기존 프로젝트 기억에 저장 · 이전 버전 은퇴')
+  .option('--json', '구조화된 JSON 출력')
+  .action(async (opts: { since: string; dryRun?: boolean; apply?: boolean; json?: boolean }) => {
+    try {
+      if (opts.apply && opts.dryRun) throw new Error('--apply and --dry-run cannot be combined');
+      if (!/^[1-9]\d*h$/.test(opts.since)) throw new Error('--since requires positive hours, e.g. 24h');
+      const { runContextCondense } = await import('./context-bus/condense.js');
+      const report = await runContextCondense({ hours: Number(opts.since.slice(0, -1)), apply: opts.apply === true });
+      await writeStdoutJson(JSON.stringify({ since: report.since, until: report.until, cards: report.cards, conflicts: report.conflicts, skipped: report.skipped, folded: report.folded, ...(report.applied ? { applied: report.applied } : {}) }) + '\n');
+      if (!opts.json) await writeStdoutFully(report.markdown);
+    } catch (error) {
+      console.error(`context condense: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 2;
+    }
+  });
 contextCmd.command('hooks').description('Claude Code 맥락 훅 설정').command('install')
   .requiredOption('--print', '설정 조각만 출력하고 설정 파일은 수정하지 않음')
   .action(async () => {
@@ -5616,6 +5745,7 @@ registerFleetCommands(program);
 
 // ── ops (운영 관측 — 지금 뭐 도나·이상 없나·상태 전이) ──
 registerOpsCommands(program);
+registerOutputsCommands(program);
 
 registerPublishCommands(program);
 
@@ -5794,6 +5924,33 @@ agentCmd
     process.exit(outcome.exitCode);
   });
 
+agentCmd.command('duo [text...]')
+  .description('Run Codex and Claude Code concurrently on the same mission in separate worktrees; summarize both PTY decisions and evidence.')
+  .requiredOption('--left <backend>', 'codex or claude')
+  .requiredOption('--right <backend>', 'codex or claude')
+  .requiredOption('--branch <name>', 'base name for two distinct worktree branches')
+  .option('--base <ref>', 'common branch base (default HEAD)')
+  .option('--mission-file <path>', 'read the same verbatim mission from a file')
+  .option('--evidence <mode>', 'doc|tsc|test (default tsc)', 'tsc')
+  .option('--doc-dir <rel>', 'doc evidence directory')
+  .option('--doc-glob <re>', 'doc evidence filename pattern')
+  .option('--test-path <p>', 'test evidence test path')
+  .option('--file <rel>', 'test evidence output file')
+  .option('--max-rounds <n>', 'maximum PTY control rounds', '16')
+  .option('--no-commit', 'do not commit completed worktrees')
+  .action(async (textParts: string[], opts: import('./agent-mission/duo.js').DuoOptions) => {
+    try {
+      delete process.env.OPENAI_API_KEY;
+      const { runAgentMissionDuo } = await import('./agent-mission/duo.js');
+      const result = await runAgentMissionDuo(textParts, opts);
+      console.log(`[duo] missionId=${result.missionId}\n${result.lines.join('\n')}`);
+      process.exitCode = result.exitCode;
+    } catch (error) {
+      console.error(`duo: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+    }
+  });
+
 // ★ 리뷰 반응 완결 루프 (L1) — PR 리뷰(OK/보강/거절)를 트리거로 codex 가 자율 rework→재제출.
 // ⭐ 옵션 정의·opts 조립은 `agent-mission/review-loop-cli.ts`(테스트 가능 seam) — 액션은 I/O 만 한다.
 registerReviewLoopOptions(
@@ -6515,6 +6672,12 @@ const selfDevCmd = program
     let devRunId = '';
     let devRunIdSource: import('./harness/harness-space.js').RunIdSource | undefined;
     let preparedWorktree: import('./harness/harness-worktree-auto.js').PreparedDevWorktree | undefined;
+    let authoringLease: import('./pod-lease/host-lease.js').HostLeaseHandle | undefined;
+    const releaseAuthoringLease = () => {
+      if (!authoringLease) return;
+      authoringLease(); authoringLease = undefined;
+      process.off('exit', releaseAuthoringLease);
+    };
     try {
       // ⛔ raw 입력 배타성 검증은 try 안의 selectDevAuthorInput 하나가 소유한다 — 실패도 아래 catch가 관측한다.
       const { buildDevCommandInput, selectDevAuthorInput } = await import('./self-dev/dev-cli.js');
@@ -6607,6 +6770,23 @@ const selfDevCmd = program
           priorBlockSamples: () => askIo.priorBlockSamplesFrom(askLogRows),
           recentAuthoringSamples: () => askIo.recentAuthoringSamplesFrom(askLogRows),
           authorGoal: (args, options) => runGoalAuthorCli([...args], options as never),
+          ...(devAskSubstrate?.substrate === 'pod' ? { beforeAuthoring: async () => {
+            const { parsePodPool, podPoolHostLease } = await import('./task-orchestrator/surfaces/pod-pool.js');
+            const { measurePoolLease, recommendConcurrency } = await import('./task-orchestrator/surfaces/pod-lease.js');
+            const members = parsePodPool(devAskSubstrate.pool!);
+            const host = podPoolHostLease(members);
+            while (!authoringLease) {
+              const status = recommendConcurrency(measurePoolLease(members), { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
+              if (status.recommended !== null && status.recommended > 0) {
+                const { leaseHasPendingPod } = await import('./pod-lease/host-lease.js');
+                const pendingJobs = status.pendingJobs ?? [];
+                authoringLease = host.tryReserve((others) =>
+                  others - host.live().filter((r) => leaseHasPendingPod(r, pendingJobs)).length < status.recommended!, true) ?? undefined;
+                if (authoringLease) process.once('exit', releaseAuthoringLease);
+              }
+              if (!authoringLease) await new Promise((resolve) => setTimeout(resolve, 15_000));
+            }
+          } } : {}),
           relativeToCwd: (file) => relativeToCwdPath(process.cwd(), file),
         });
         // ⛔ 종료는 «표면»이 한다 — 흐름은 세 값만 낸다.
@@ -6616,6 +6796,7 @@ const selfDevCmd = program
         }
         askAuthoredFile = flowResult.goalFile;
         if (flowResult.kind === 'stopped-by-preflight') {
+          releaseAuthoringLease();
           completionGuard.conclude();
           process.exit(1);
         }
@@ -6633,12 +6814,21 @@ const selfDevCmd = program
         warnRecentIncidentBurst();
         let podOutput = '';
         let podRunId: string | undefined;
-        const status = await dispatchHarnessOnPod(devAskPodDispatchInput(opts, askAuthoredFile!, devAskSubstrate.pool!), {
-          onOutput: (text) => {
-            podRunId ??= harnessPodRunId(podOutput + text);
-            podOutput = (podOutput + text).slice(-16_000);
-          },
-        });
+        const previousLeaseId = process.env.ELANOUS_POD_RESERVED_LEASE;
+        if (authoringLease) process.env.ELANOUS_POD_RESERVED_LEASE = authoringLease.id;
+        let status: number;
+        try {
+          status = await dispatchHarnessOnPod(devAskPodDispatchInput(opts, askAuthoredFile!, devAskSubstrate.pool!), {
+            onOutput: (text) => {
+              podRunId ??= harnessPodRunId(podOutput + text);
+              podOutput = (podOutput + text).slice(-16_000);
+            },
+          });
+        } finally {
+          releaseAuthoringLease();
+          if (previousLeaseId === undefined) delete process.env.ELANOUS_POD_RESERVED_LEASE;
+          else process.env.ELANOUS_POD_RESERVED_LEASE = previousLeaseId;
+        }
         if (status !== 0) {
           const classified = classifyHarnessPodExit({ status }, podOutput, { ...(podRunId ? { runId: podRunId } : {}) });
           recordClassifiedHarnessPodExit(podRunId ?? harnessPodRunId(podOutput), classified.reason, status);
@@ -6940,9 +7130,11 @@ const selfDevCmd = program
         completionGuard.conclude();
         process.exit(r.result.exitCode);
       }
+      releaseAuthoringLease();
       completionGuard.conclude();
       process.exit(ok ? 0 : 2);
     } catch (e) {
+      releaseAuthoringLease();
       const msg = e instanceof Error ? e.message : String(e);
       // ⚠️ 관측은 결론을 막지 않는다(리뷰 should-fix 5R) — 여기서 로거가 던지면 아래 `console.error` 와
       //    의도한 `exit(1)` 까지 통째로 우회해, 사용자는 이유도 모른 채 다른 종료코드를 받는다.

package/src/intake-plane/discord-seat-work.ts

@@ -9,7 +9,7 @@ import { askSeat, parseSeatAsk, type SeatAskDeps } from '../seat-dispatch/seat-a
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
 import { answerAsSeat } from './seat-answer.js';
-import { answerAsPersona, resolvePersonaAddress, type PersonaAnswerDeps } from './persona-answer.js';
+import { answerAsPersona, resolvePersonaAddress, seatOfPersona, type PersonaAnswerDeps } from './persona-answer.js';
 import {
   submitIntakeWork,
   type SubmitIntakeWorkDeps,
@@ -72,14 +72,21 @@ export async function handleDiscordSeatWork(
     return ['OP', 'TC', 'MK', 'UX'].includes(id) ? sendTask(id, text, auth!.cfg, auth!.id) : null;
   }
 
-  const seats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
-  const hasUnresolved = seats.some(({ seat }) => !seat);
+  const initialSeats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
+  const hasUnresolved = initialSeats.some(({ seat }) => !seat);
   const auth = hasUnresolved ? owner() : null;
   if (hasUnresolved && auth && !deps.personaSource) await awaitGlobalPersonaLoad();
   const source = hasUnresolved && auth ? (deps.personaSource ?? getGlobalPersonaRegistry()) : null;
-  const addressed = seats.map(({ name, seat }) => ({
-    name, seat, persona: !seat && source ? resolvePersonaAddress(name, source) : null,
-  }));
+  const addressed = initialSeats.map(({ name, seat }) => {
+    const persona = !seat && source ? resolvePersonaAddress(name, source) : null;
+    const personaSeat = persona ? seatOfPersona(persona) : null;
+    if (persona && personaSeat) {
+      debug.log('persona.address', 'seat-alias', { name, personaId: persona.personaId, seat: personaSeat.id, via: 'discord' });
+      return { name: personaSeat.id, seat: personaSeat, persona: null };
+    }
+    return { name, seat, persona };
+  });
+  const seats = addressed;
   const unknown = addressed.filter(({ seat, persona }) => !seat && (!persona || !auth)).map(({ name }) => `@${name}`);
   if (unknown.length) return `어느 좌석을 말씀하시나요? ${unknown.join(', ')}은(는) 등록된 좌석이 아닙니다. 좌석을 확인해 다시 보내 주세요.`;
   const personas = addressed.filter(({ persona }) => persona);

package/src/intake-plane/linear-wish.ts

@@ -0,0 +1,44 @@
+import { fetchLinearIssues } from '../connectors/linear.js';
+import { debug } from '../debug/log.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { CardStore } from '../task-cards/card-store.js';
+import { createWishCard } from './wish-card.js';
+
+export const LINEAR_WISH_KEY_MISSING = 'Linear 키가 없습니다 — elanous connector linear 로 먼저 등록하세요';
+
+export async function scanLinearWishes({ teamKey, label = 'wish', store, deps = {} }: {
+  teamKey: string;
+  label?: string;
+  store: CardStore;
+  deps?: {
+    getApiKey?: () => Promise<string | undefined>;
+    fetchIssues?: typeof fetchLinearIssues;
+  };
+}): Promise<{ added: number; duplicate: number; failed: number }> {
+  const apiKey = await (deps.getApiKey ?? (() => getSecretAsync('connector.linear.apiKey')))();
+  if (!apiKey?.trim()) throw new Error(LINEAR_WISH_KEY_MISSING);
+  let issues: Awaited<ReturnType<typeof fetchLinearIssues>>;
+  try {
+    issues = await (deps.fetchIssues ?? fetchLinearIssues)({ apiKey, teamKey, labelOrPrefix: label });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(message.replaceAll(apiKey, '[redacted]'));
+  }
+  let added = 0;
+  let duplicate = 0;
+  let failed = 0;
+  for (const issue of issues) {
+    try {
+      const result = createWishCard({
+        text: `${issue.title}\n\n${issue.body}\n\n${issue.url}`,
+        source: 'linear', ref: issue.identifier ?? '',
+      }, store);
+      if (result.created) added++;
+      else duplicate++;
+    } catch {
+      failed++;
+    }
+  }
+  debug.log('intake.linear-wish', 'scanned', { teamKey, label, added, duplicate, failed });
+  return { added, duplicate, failed };
+}

package/src/intake-plane/persona-answer.ts

@@ -1,11 +1,16 @@
 import { debug } from '../debug/log.js';
 import { resolveMention, type PersonaSource } from '../persona/mention-parser.js';
 import type { PersonaProfile } from '../persona/types.js';
+import { resolveSeat, type SeatEntry } from '../seat-address/seat-address.js';
 
 export interface PersonaAnswerDeps {
   complete?: (prompt: string) => Promise<string>;
 }
 
+export function seatOfPersona(persona: PersonaProfile, resolve = resolveSeat): SeatEntry | null {
+  return persona.seat ? resolve(persona.seat) ?? null : null;
+}
+
 /** Resolve the registry mention first, then an exact display name. */
 export function resolvePersonaAddress(name: string, source: PersonaSource): PersonaProfile | null {
   const mention = resolveMention(name, source);

package/src/intake-plane/telegram-seat-work.ts

@@ -9,7 +9,7 @@ import { askSeat, parseSeatAsk, type SeatAskDeps } from '../seat-dispatch/seat-a
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
 import { answerAsSeat } from './seat-answer.js';
-import { answerAsPersona, resolvePersonaAddress, type PersonaAnswerDeps } from './persona-answer.js';
+import { answerAsPersona, resolvePersonaAddress, seatOfPersona, type PersonaAnswerDeps } from './persona-answer.js';
 import {
   submitIntakeWork,
   type SubmitIntakeWorkDeps,
@@ -66,16 +66,23 @@ export async function handleTelegramSeatWork(
   const address = parseSeatAddress(text.replace(/^(@[A-Za-z][A-Za-z0-9_-]*(?:,@?[A-Za-z][A-Za-z0-9_-]*)*)/, (prefix) => prefix.replaceAll(',@', ',')));
   if (!address) return null;
 
-  const seats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
+  const initialSeats = address.seats.map((name) => ({ name, seat: resolveSeat(name) }));
   const names = address.seats;
   debug.log('seat-address.telegram', 'parsed', { seats: names });
-  const hasUnresolved = seats.some(({ seat }) => !seat);
+  const hasUnresolved = initialSeats.some(({ seat }) => !seat);
   const auth = hasUnresolved ? owner() : null;
   if (hasUnresolved && auth && !deps.personaSource) await awaitGlobalPersonaLoad();
   const source = hasUnresolved && auth ? (deps.personaSource ?? getGlobalPersonaRegistry()) : null;
-  const addressed = seats.map(({ name, seat }) => ({
-    name, seat, persona: !seat && source ? resolvePersonaAddress(name, source) : null,
-  }));
+  const addressed = initialSeats.map(({ name, seat }) => {
+    const persona = !seat && source ? resolvePersonaAddress(name, source) : null;
+    const personaSeat = persona ? seatOfPersona(persona) : null;
+    if (persona && personaSeat) {
+      debug.log('persona.address', 'seat-alias', { name, personaId: persona.personaId, seat: personaSeat.id, via: 'telegram' });
+      return { name: personaSeat.id, seat: personaSeat, persona: null };
+    }
+    return { name, seat, persona };
+  });
+  const seats = addressed;
   const unknown = addressed.filter(({ seat, persona }) => !seat && (!persona || !auth)).map(({ name }) => `@${name}`);
   if (unknown.length) {
     debug.log('seat-address.telegram', 'rejected', { seats: names, reason: 'unknown-seat' });

package/src/intake-plane/wish-card.ts

@@ -2,7 +2,7 @@ import { debug } from '../debug/log.js';
 import { CardStore } from '../task-cards/card-store.js';
 
 export function createWishCard(
-  { text, source, ref }: { text: string; source: 'telegram' | 'pwa' | 'tui'; ref: string },
+  { text, source, ref }: { text: string; source: 'telegram' | 'pwa' | 'tui' | 'linear'; ref: string },
   store: CardStore = new CardStore(),
 ): { cardId: string; title: string; created: boolean } {
   const title = text.trim().split(/\r?\n/, 1)[0]!.trim().slice(0, 80);

package/src/loops/checker.ts

@@ -0,0 +1,178 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { Database } from 'bun:sqlite';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import * as registry from './registry.js';
+import { cronMatches } from '../domains/cron-match.js';
+import { resolveTimeZone } from '../time/format.js';
+import type { LoopEntry, LoopRun } from './registry.js';
+
+type LoopState = 'off' | 'unregistered' | 'failing' | 'late' | 'unknown' | 'alive';
+export type LoopScope = 'graph-only' | 'registry';
+export interface CheckEntry {
+  id: string;
+  owner?: string;
+  mode?: string;
+  expectEveryMinutes?: number;
+  /** The scheduled fire before the latest one (cron loops). A run older than this missed two scheduled fires. */
+  dueAt?: string;
+  lastRunAt?: string;
+  lastStatus?: string;
+  recentStatuses?: string[];
+  enabled: boolean;
+  registered: boolean;
+}
+export interface CheckResult extends CheckEntry {
+  state: LoopState;
+  reason: string;
+}
+export const LOOP_STATES = ['alive', 'late', 'failing', 'off', 'unregistered', 'unknown'] as const;
+export type LoopCounts = Record<LoopState, number>;
+
+export function checkLoops(entries: CheckEntry[], now: Date, opts: { failureStatuses?: readonly string[] } = {}): CheckResult[] {
+  const failures = opts.failureStatuses ?? ['failed'];
+  return entries.map(entry => {
+    let state: LoopState;
+    let reason: string;
+    const age = entry.lastRunAt ? now.getTime() - Date.parse(entry.lastRunAt) : NaN;
+    if (!entry.enabled) { state = 'off'; reason = 'disabled'; }
+    else if (!entry.registered) { state = 'unregistered'; reason = 'not registered'; }
+    else if (entry.recentStatuses?.length && entry.recentStatuses.length >= 3
+      && entry.recentStatuses.slice(0, 3).every(status => failures.includes(status))) {
+      state = 'failing'; reason = 'last 3 runs failed';
+    } else if (Number.isFinite(age) && entry.dueAt && Number.isFinite(Date.parse(entry.dueAt))) {
+      // Judge against the real schedule, not a fixed interval: overnight or weekend gaps are not lateness.
+      if (Date.parse(entry.lastRunAt!) < Date.parse(entry.dueAt)) { state = 'late'; reason = `missed the scheduled runs since ${entry.dueAt}`; }
+      else { state = 'alive'; reason = 'ran at or after the previous scheduled fire'; }
+    } else if (Number.isFinite(age) && entry.expectEveryMinutes !== undefined
+      && entry.expectEveryMinutes > 0 && age > entry.expectEveryMinutes * 2 * 60_000) {
+      state = 'late'; reason = `last run exceeds twice the expected ${entry.expectEveryMinutes}m interval`;
+    } else if (!entry.lastRunAt || !Number.isFinite(age)) { state = 'unknown'; reason = 'no valid run recorded'; }
+    else if (entry.expectEveryMinutes === undefined || !Number.isFinite(entry.expectEveryMinutes) || entry.expectEveryMinutes <= 0) {
+      state = 'unknown'; reason = 'expected interval unknown';
+    } else { state = 'alive'; reason = 'within expected interval'; }
+    return { ...entry, state, reason };
+  });
+}
+
+export function countLoopStates(results: CheckResult[]): LoopCounts {
+  const counts: LoopCounts = { alive: 0, late: 0, failing: 0, off: 0, unregistered: 0, unknown: 0 };
+  for (const result of results) counts[result.state]++;
+  return counts;
+}
+
+/** Latest cron fire at or before `at` (minute resolution, scans back up to one year). */
+export function previousLoopFire(cron: string, at: Date, timeZone: string = resolveTimeZone().timeZone): string | null {
+  if (cron.trim().split(/\s+/).length !== 5) return null;
+  let minute = Math.floor(at.getTime() / 60000) * 60000;
+  for (let i = 0; i < 527040; i++, minute -= 60000) {
+    if (cronMatches(cron, new Date(minute), { timeZone })) return new Date(minute).toISOString();
+  }
+  return null;
+}
+
+/** The fire before the latest scheduled fire — a run older than this has missed two scheduled fires. */
+export function dueBefore(cron: string, now: Date, timeZone?: string): string | null {
+  const latest = previousLoopFire(cron, now, timeZone);
+  return latest ? previousLoopFire(cron, new Date(Date.parse(latest) - 60000), timeZone) : null;
+}
+
+export interface RegistryAdapterDeps {
+  listLoops?: () => LoopEntry[];
+  listAllLoops?: () => CheckEntry[];
+  statusForLoop?: (id: string) => { recentRuns: Pick<LoopRun, 'status'>[] };
+  now?: Date;
+  timeZone?: string;
+}
+
+export function entriesFromRegistry(deps: RegistryAdapterDeps = {}): { entries: CheckEntry[]; scope: LoopScope } {
+  // The registry integration is optional until LOOP-REG1 lands. Do not import a missing named export.
+  const all = deps.listAllLoops ?? (registry as typeof registry & { listAllLoops?: () => CheckEntry[] }).listAllLoops;
+  if (typeof all === 'function') return { entries: all(), scope: 'registry' };
+  const now = deps.now ?? new Date();
+  return { scope: 'graph-only', entries: (deps.listLoops ?? registry.listLoops)().map(loop => {
+    const first = loop.trigger.cron ? registry.nextLoopFire(loop.trigger.cron, now) : null;
+    const second = first && loop.trigger.cron ? registry.nextLoopFire(loop.trigger.cron, new Date(first)) : null;
+    const interval = first && second ? (Date.parse(second) - Date.parse(first)) / 60_000 : undefined;
+    const statuses = loop.lastRun
+      ? deps.statusForLoop ? deps.statusForLoop(loop.id).recentRuns.map(run => run.status)
+        : deps.listLoops ? [loop.lastRun.status]
+          : registry.loopStatus(loop.id).recentRuns.map(run => run.status)
+      : [];
+    const dueAt = loop.trigger.cron ? dueBefore(loop.trigger.cron, now, deps.timeZone) : null;
+    return { id: loop.id, enabled: loop.enabled, registered: true,
+      ...(interval !== undefined ? { expectEveryMinutes: interval } : {}),
+      ...(dueAt ? { dueAt } : {}),
+      ...(loop.lastRun ? { lastRunAt: loop.lastRun.at, lastStatus: loop.lastRun.status } : {}),
+      recentStatuses: statuses };
+  }) };
+}
+
+export interface CheckerDeps {
+  root?: string;
+  now?: Date;
+}
+
+/** Appends only new daily keys to the seat request journal; never rewrites existing lines. */
+export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}): number {
+  const eligible = results.filter(result => result.owner && (result.state === 'late' || result.state === 'failing'));
+  if (!eligible.length) return 0;
+  const now = deps.now ?? new Date();
+  const path = join(deps.root ?? effectiveInstanceRoot(), 'seat-requests', 'requests.jsonl');
+  mkdirSync(dirname(path), { recursive: true });
+  // SQLite's OS locks are released when a process dies, including after SIGKILL.
+  // The journal itself remains append-only; this database only serializes check + append.
+  const lock = new Database(`${path}.loop-checker.lock.sqlite`);
+  try {
+    lock.exec('PRAGMA busy_timeout = 10000');
+    lock.exec('BEGIN EXCLUSIVE');
+    try {
+      const existing = new Set<string>();
+      if (existsSync(path)) {
+        for (const line of readFileSync(path, 'utf8').split('\n')) {
+          if (line.trim()) {
+            const row = JSON.parse(line) as { key?: string };
+            if (row.key) existing.add(row.key);
+          }
+        }
+      }
+      let added = 0;
+      for (const result of eligible) {
+        const key = `loopcheck:${result.id}:${now.toISOString().slice(0, 10)}:${result.state}`;
+        if (existing.has(key)) continue;
+        const row = { key, receiptId: key, seat: result.owner, text: `${result.id} ${result.state} — 마지막 ${result.lastRunAt ?? '없음'} · ${result.reason}`,
+          status: 'queued', queuedAt: now.toISOString(), source: 'loop-checker' };
+        appendFileSync(path, JSON.stringify(row) + '\n');
+        existing.add(key);
+        added++;
+      }
+      lock.exec('COMMIT');
+      return added;
+    } catch (error) {
+      lock.exec('ROLLBACK');
+      throw error;
+    }
+  } finally { lock.close(); }
+}
+
+/** Persist the previous comparison only for explicit all-status checks. Notification is separate. */
+export function observeLoopCheck(results: CheckResult[], scope: LoopScope, deps: CheckerDeps = {}): LoopCounts {
+  const path = join(deps.root ?? effectiveInstanceRoot(), 'loop', 'checker', 'last.json');
+  let previous: Record<string, LoopState> = {};
+  try { previous = JSON.parse(readFileSync(path, 'utf8')) as Record<string, LoopState>; }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+  const current: Record<string, LoopState> = {};
+  for (const { id, state } of results) {
+    current[id] = state;
+    if (previous[id] && previous[id] !== state) debug.log('loop.checker', 'state-change', { id, from: previous[id], to: state });
+  }
+  const counts = countLoopStates(results);
+  debug.log('loop.checker', 'checked', { counts, scope });
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  try { writeFileSync(tmp, JSON.stringify(current)); renameSync(tmp, path); }
+  catch (error) { if (existsSync(tmp)) unlinkSync(tmp); throw error; }
+  return counts;
+}