elanous 0.2.36 → 0.2.38

package/src/loops/consensus.ts

@@ -45,6 +45,8 @@ export const CROWN_MARK = String.fromCodePoint(0x1F451);
 export interface ProposalCard {
   id: string;
   category: ConsensusCategory;
+  /** Stable orchestrator work key (orch:<card>:<cell>) for a cross-branch split cell. */
+  workKey?: string;
   title: string;
   /** 사실 id — 제안의 근거 관측. */
   factId: string;
@@ -152,8 +154,14 @@ export class ConsensusEngine {
 
   propose(input: {
     by: ConsensusRepresentative; category: ConsensusCategory; title: string; factId: string; cost: string; undo: string;
-    thresholds?: DecisionCategory[]; provider?: string;
+    thresholds?: DecisionCategory[]; provider?: string; workKey?: string;
   }): ProposalCard {
+    if (input.workKey !== undefined) {
+      if (input.category !== 'cross-branch-change' || !/^orch:[a-zA-Z0-9_-]+:[a-zA-Z0-9_-]+$/.test(input.workKey))
+        throw new Error('invalid cross-branch work key');
+      const existing = this.list().find(proposal => proposal.workKey === input.workKey);
+      if (existing) throw new Error(`cross-branch work already proposed: ${existing.id}`);
+    }
     if (!CONSENSUS_REPRESENTATIVES.includes(input.by)) throw new Error(`invalid representative: ${input.by} (coordinator|guardian)`);
     if (!CONSENSUS_CATEGORIES.includes(input.category)) throw new Error(`invalid consensus category: ${input.category} (${CONSENSUS_CATEGORIES.join('|')})`);
     const thresholds = [...new Set(input.thresholds ?? [])];
@@ -164,6 +172,7 @@ export class ConsensusEngine {
     const proposal: ProposalCard = {
       id: this.nextId('C', at),
       category: input.category,
+      ...(input.workKey ? { workKey: input.workKey } : {}),
       title: oneLine(input.title, 'title'),
       factId: oneLine(input.factId, 'fact id'),
       cost: oneLine(input.cost, 'cost'),
@@ -210,11 +219,24 @@ export class ConsensusEngine {
     return proposal;
   }
 
+  proposalForWork(workKey: string): ProposalCard | undefined {
+    return this.list().find(entry => entry.workKey === workKey);
+  }
+
   crownCards(): CrownCard[] {
     return [...this.state().cards]
       .sort((a, b) => b.raisedAt.localeCompare(a.raisedAt) || a.id.localeCompare(b.id));
   }
 
+  /** The same durable execution gate is used by CLI replies, hooks and loop consumers. */
+  canExecute(id: string): boolean {
+    const proposal = this.show(id);
+    return proposal.status === 'agreed' && proposal.thresholds.length === 0
+      && proposal.roundTrips >= 1 && proposal.roundTrips <= MAX_REVIEW_ROUND_TRIPS
+      && proposal.reviews.at(-1)?.verdict === 'agree'
+      && proposal.reviews.at(-1)?.by !== proposal.proposedBy;
+  }
+
   /** 판정선 — 합의 원장의 agreed 이벤트를 ISO 주 단위로 센다 (한 주 N건의 기전). */
   weeklyAgreementCounts(): Array<{ week: string; count: number }> {
     const counts = new Map<string, number>();
@@ -230,7 +252,9 @@ export class ConsensusEngine {
   private conclude(id: string, verdict: ReviewRecord['verdict'], input: { by: ConsensusRepresentative; claim?: string; provider?: string }): { proposal: ProposalCard; crownCard?: CrownCard } {
     const proposal = this.show(id);
     if (proposal.status !== 'open') throw new Error(`합의가 이미 결론났다: ${id} (${proposal.status === 'agreed' ? '합의' : '불합의'})`);
+    if (!CONSENSUS_REPRESENTATIVES.includes(input.by)) throw new Error(`invalid representative: ${input.by}`);
     if (input.by === proposal.proposedBy) throw new Error('메아리 방지 — 제안한 대표는 자기 제안을 검토하지 않는다');
+    if (proposal.roundTrips >= MAX_REVIEW_ROUND_TRIPS) throw new Error(`상대 검토는 최대 ${MAX_REVIEW_ROUND_TRIPS}왕복이다`);
     if (verdict === 'revise' && proposal.roundTrips + 1 >= MAX_REVIEW_ROUND_TRIPS)
       throw new Error(`상대 검토는 최대 ${MAX_REVIEW_ROUND_TRIPS}왕복이다 — 마지막 왕복에는 합의 또는 불합의로 끝낸다`);
     const claim = oneLine(input.claim ?? (verdict === 'agree' ? '동의 — 제안대로 실행한다' : ''), 'claim');
@@ -249,7 +273,7 @@ export class ConsensusEngine {
     this.appendLens(input.by, { action: 'reviewed', proposalId: proposal.id, at, verdict, ...(provider ? { provider } : {}) });
     debug.log('loops.consensus', 'reviewed', { proposalId: proposal.id, verdict, roundTrip: review.roundTrip, by: input.by });
     const updated = this.show(proposal.id);
-    if (verdict === 'agree') this.executeHook(updated);
+    if (this.canExecute(updated.id)) this.executeHook(updated);
     return { proposal: updated, ...(crownCard ? { crownCard } : {}) };
   }
 

package/src/loops/loop-cli.ts

@@ -1,7 +1,7 @@
 import type { Command } from 'commander';
 import { writeStdoutJson } from '../cli/stdout-json.js';
 import { listAllLoops, listLoops, loopStatus, runLoop, setLoopEnabled, unregisteredCronLoops, type AllLoopEntry, type LoopRegistryOptions } from './registry.js';
-import { checkLoops, countLoopStates, entriesFromRegistry, LOOP_STATES, notifyOwners, observeLoopCheck, type RegistryAdapterDeps } from './checker.js';
+import { checkLoops, countLoopStates, entriesFromRegistry, LOOP_STATES, notifyOwners, observeLoopCheck, pruneJudgment, pruneText, type RegistryAdapterDeps } from './checker.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { verifyLoopPackage } from './package/verify.js';
 import { loopActivity } from './activity.js';
@@ -56,7 +56,8 @@ export function registerLoopCommands(program: Command, checkerDeps: RegistryAdap
     }));
   loop.command('status [id]').option('--all', 'Check all registered loops')
     .option('--json', 'Print JSON').option('--notify', 'Queue late/failing loops for their owners')
-    .action((id: string | undefined, opts: { all?: boolean; json?: boolean; notify?: boolean }) => handle(async () => {
+    .option('--prune', 'Judge idle retire · unregistered cleanup · sibling folding · alive ≤ 25')
+    .action((id: string | undefined, opts: { all?: boolean; json?: boolean; notify?: boolean; prune?: boolean }) => handle(async () => {
       if (!opts.all) {
         if (!id) throw new Error('loop status requires an id or --all');
         await output(loopStatus(id), !!opts.json);
@@ -65,15 +66,19 @@ export function registerLoopCommands(program: Command, checkerDeps: RegistryAdap
       if (id) throw new Error('loop status --all does not take an id');
       const now = checkerDeps.now ?? new Date();
       const root = checkerDeps.root ?? effectiveInstanceRoot();
-      const { entries, scope } = entriesFromRegistry({ ...checkerDeps, now });
+      const registryOpts = checkerDeps.registryOptions;
+      const { entries, scope } = entriesFromRegistry({ ...checkerDeps, now,
+        listAllLoops: checkerDeps.listAllLoops ?? (registryOpts ? () => listAllLoops(registryOpts) : undefined) });
       const results = checkLoops(entries, now);
       const counts = countLoopStates(results);
+      const prune = pruneJudgment(results, { now });
       observeLoopCheck(results, scope, { root, now });
       if (opts.notify) notifyOwners(results, { root, now });
-      if (opts.json) { await output({ results, counts, scope }, true); return; }
+      if (opts.json) { await output({ results, counts, scope, prune }, true); return; }
       console.log('id\tstate\tlast run\texpected interval\towner\treason');
       for (const result of results) console.log(`${result.id}\t${result.state}\t${result.lastRunAt ?? '—'}\t${result.expectEveryMinutes === undefined ? '—' : `${result.expectEveryMinutes}m`}\t${result.owner ?? '—'}\t${result.reason}`);
       console.log(`${LOOP_STATES.map(state => `${state} ${counts[state]}`).join(' · ')} · scope ${scope}`);
+      if (opts.prune) console.log(pruneText(prune));
     }));
   for (const [name, enabled] of [['start', true], ['stop', false]] as const) {
     loop.command(`${name} <id>`).option('--yes', 'Apply the crontab change (otherwise preview only)')

package/src/loops/orchestrator/anomaly-cluster.ts

@@ -0,0 +1,243 @@
+/**
+ * ANOMALY-CLUSTER-PRODUCT — repeated failure signatures hold relaunches.
+ *
+ * Reference contract (read-only, unchanged): `seat-state/OP/tools/anomaly-cluster.{sh,py}` groups the same
+ * failures for an OP seat by eye and never holds anything automatically. This module is the product
+ * transfer of that reading contract: it computes a signature and turns it into a hold/release decision.
+ *
+ * Boundary: when the SAME signature shows up in 3+ DIFFERENT runs, relaunches of that goal·host are held
+ * automatically until a cause verdict (`release`) clears them. The host is a hold key, never part of the
+ * signature. When there is nothing measured for a goal·host, the hold reason says so ("원천 미측정").
+ *
+ * Pure module: no fs, no network, no clock reads unless a `now` seam is injected.
+ */
+
+/** Runs of the same signature required before relaunches are held. */
+export const ANOMALY_HOLD_THRESHOLD = 3;
+
+/** Signature components: failure kind · container exit · stage · tail of `lastLines` reason. */
+export interface FailureObservation {
+  /** Goal identifier — a hold key, not part of the signature. */
+  goal: string;
+  /** Host (seat / surface / launch host) — a hold key, not part of the signature. */
+  host: string;
+  /** Run identifier — the unit counted as "a different run". */
+  runId: string;
+  /** Failure kind (`preflight` · `exit` · `timeout` · adapter name …). */
+  kind: string;
+  /** Container exit code when observed; `null`/absent when the failure never reached a container. */
+  containerExit?: number | null;
+  /** Stage the failure was observed at (`launch` · `delegate` · `monitor` …). */
+  stage: string;
+  /** Tail lines of the failure; the last non-empty line is the "reason tail" that splits signatures. */
+  lastLines?: readonly string[];
+  at?: string;
+}
+
+export interface HoldDecision {
+  /** `true` when relaunches of this goal·host are held. */
+  hold: boolean;
+  /** Korean explanation — includes "원천 미측정" when nothing was measured. */
+  reason: string;
+  signature?: string;
+  /** Distinct runs counted for the holding signature. */
+  runs?: number;
+}
+
+export interface ReleaseDecision {
+  released: boolean;
+  reason: string;
+}
+
+const REASON_TAIL_LIMIT = 160;
+
+/** Collapse whitespace and cap length — the reason tail is a signature component, not a payload. */
+function reasonTail(lines: readonly string[] | undefined): string {
+  if (!lines || lines.length === 0) return 'none';
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = (lines[i] ?? '').replace(/\s+/g, ' ').trim().replace(/^reason\s*[:=]\s*/i, '');
+    if (line) return line.slice(0, REASON_TAIL_LIMIT);
+  }
+  return 'none';
+}
+
+/** Pull a container exit code out of free text (`exited with code 137`, `exit status 1`, `exit=137`). */
+export function extractContainerExit(text: string): number | null {
+  const match = /(?:exit(?:ed)?(?: with)?(?: code| status)?|exit=)\s*[:=]?\s*(\d+)/i.exec(text ?? '');
+  if (!match) return null;
+  const value = Number.parseInt(match[1]!, 10);
+  return Number.isFinite(value) ? value : null;
+}
+
+/**
+ * Signature = kind · exit · stage · reason tail. Host and run are deliberately excluded: the host is a
+ * hold key and the run is the counter.
+ */
+export function failureSignature(obs: FailureObservation): string {
+  const exit = obs.containerExit === undefined || obs.containerExit === null ? 'none' : String(obs.containerExit);
+  return `kind=${obs.kind}|exit=${exit}|stage=${obs.stage}|reason=${reasonTail(obs.lastLines)}`;
+}
+
+interface ClusterState {
+  goal: string;
+  host: string;
+  signature: string;
+  runs: Set<string>;
+  held: boolean;
+  /** First `FailureObservation.at` read into this cluster — the observation window shown in the reason. */
+  firstAt?: string;
+  /** Latest `FailureObservation.at` read into this cluster. */
+  lastAt?: string;
+}
+
+function keyOf(goal: string, host: string): string {
+  return `${goal}\u0000${host}`;
+}
+
+/** In-memory grouping state — written by the failure observation point, read by the relaunch point. */
+export class AnomalyCluster {
+  private readonly threshold: number;
+  private readonly now: () => Date;
+  private readonly clusters = new Map<string, ClusterState>();
+  /**
+   * Observations of a DIFFERENT signature that arrived while its goal·host was held. They are kept
+   * counting in a side bucket so a late-arriving observation can never drop a hold before a cause
+   * verdict — the hold is only ever cleared by `release`.
+   */
+  private readonly parked = new Map<string, ClusterState>();
+
+  constructor(opts: { threshold?: number; now?: () => Date } = {}) {
+    this.threshold = Math.max(1, Math.trunc(opts.threshold ?? ANOMALY_HOLD_THRESHOLD));
+    this.now = opts.now ?? (() => new Date());
+  }
+
+  /** Record one failure observation and return the resulting hold decision for its goal·host. */
+  record(obs: FailureObservation): { signature: string; runs: number; hold: HoldDecision } {
+    const signature = failureSignature(obs);
+    const key = keyOf(obs.goal, obs.host);
+    const at = typeof obs.at === 'string' && obs.at.trim() ? obs.at.trim() : undefined;
+    let cluster = this.clusters.get(key);
+    if (cluster && cluster.signature !== signature && cluster.held) {
+      // Held: the signature is frozen until a cause verdict. A late observation of another signature is
+      // counted in the parked bucket — replacing the cluster here would silently drop the hold.
+      const parkedKey = keyOf(key, signature);
+      let parked = this.parked.get(parkedKey);
+      if (!parked) {
+        parked = { goal: obs.goal, host: obs.host, signature, runs: new Set(), held: false };
+        this.parked.set(parkedKey, parked);
+      }
+      this.touch(parked, obs.runId, at);
+      const held = this.describe(cluster);
+      return {
+        signature: cluster.signature,
+        runs: cluster.runs.size,
+        hold: {
+          ...held,
+          reason: `${held.reason} · 보류 중 도착한 다른 서명 ${parked.runs.size}건은 해제 없이 별도 보관(판정 뒤 재판정)`,
+        },
+      };
+    }
+    if (!cluster || cluster.signature !== signature) {
+      // Not held: a different signature takes over. A parked bucket of that same signature keeps its runs.
+      const parkedKey = keyOf(key, signature);
+      const resumed = this.parked.get(parkedKey);
+      for (const stale of [...this.parked.keys()]) {
+        if (stale !== parkedKey && stale.startsWith(`${key}\u0000`)) this.parked.delete(stale);
+      }
+      if (resumed) this.parked.delete(parkedKey);
+      cluster = resumed ?? { goal: obs.goal, host: obs.host, signature, runs: new Set(), held: false };
+      this.clusters.set(key, cluster);
+    }
+    this.touch(cluster, obs.runId, at);
+    return { signature, runs: cluster.runs.size, hold: this.describe(cluster) };
+  }
+
+  /** Relaunch gate. A hold is decided before any cause verdict; the reason names an unmeasured source. */
+  hold(goal: string, host: string): HoldDecision {
+    const cluster = this.clusters.get(keyOf(goal, host));
+    if (!cluster) {
+      return { hold: false, reason: `원천 미측정: ${goal}·${host} 의 실패 관측이 없다 — 보류 판정 근거 없음` };
+    }
+    return this.describe(cluster);
+  }
+
+  isHeld(goal: string, host: string): boolean {
+    return this.clusters.get(keyOf(goal, host))?.held ?? false;
+  }
+
+  /** Cause verdict — clears the hold. Returns `released: false` when nothing was held. */
+  release(goal: string, host: string, cause: string): ReleaseDecision {
+    const key = keyOf(goal, host);
+    const cluster = this.clusters.get(key);
+    if (!cluster || !cluster.held) {
+      return { released: false, reason: `${goal}·${host} 는 보류 상태가 아니다` };
+    }
+    const judged = cluster.signature;
+    const judgedRuns = cluster.runs.size;
+    cluster.held = false;
+    cluster.runs.clear();
+    cluster.firstAt = undefined;
+    cluster.lastAt = undefined;
+    const promoted = this.takeStrongestParked(key);
+    if (promoted) this.clusters.set(key, promoted);
+    const head = `보류 해제: ${cause} (${this.now().toISOString()}) — 판정한 서명 ${judged} ${judgedRuns}건`;
+    return {
+      released: true,
+      reason: promoted
+        ? `${head} · 보류 중 보관한 다른 서명 ${promoted.signature} ${promoted.runs.size}건을 재판정 대상으로 승격${promoted.held ? ' (임계 도달 — 새 서명 기준 재보류)' : ''}`
+        : head,
+    };
+  }
+
+  private touch(cluster: ClusterState, runId: string, at: string | undefined): void {
+    cluster.runs.add(runId);
+    if (at) {
+      cluster.firstAt ??= at;
+      cluster.lastAt = at;
+    }
+    if (cluster.runs.size >= this.threshold) cluster.held = true;
+  }
+
+  /** The parked bucket of this goal·host with the most runs — the next signature to judge. */
+  private takeStrongestParked(key: string): ClusterState | undefined {
+    let best: ClusterState | undefined;
+    let bestKey: string | undefined;
+    for (const [parkedKey, state] of this.parked) {
+      if (!parkedKey.startsWith(`${key}\u0000`)) continue;
+      if (!best || state.runs.size > best.runs.size) {
+        best = state;
+        bestKey = parkedKey;
+      }
+    }
+    if (best && bestKey) this.parked.delete(bestKey);
+    return best;
+  }
+
+  private describe(cluster: ClusterState): HoldDecision {
+    const runs = cluster.runs.size;
+    const window = cluster.firstAt ? ` · 관측 ${cluster.firstAt}${cluster.lastAt && cluster.lastAt !== cluster.firstAt ? `..${cluster.lastAt}` : ''}` : '';
+    if (cluster.held) {
+      return {
+        hold: true,
+        reason: `같은 서명 ${runs}건(임계 ${this.threshold}) — 원인 판정 전 ${cluster.goal}·${cluster.host} 재발사 보류${window}`,
+        signature: cluster.signature,
+        runs,
+      };
+    }
+    return {
+      hold: false,
+      reason: `같은 서명 ${runs}건 < 임계 ${this.threshold} — 보류하지 않는다${window}`,
+      signature: cluster.signature,
+      runs,
+    };
+  }
+}
+
+/** Process-wide cluster shared by the tick failure record point and the dispatcher relaunch gate. */
+let shared: AnomalyCluster | undefined;
+
+/** Lazily created shared instance — no fs side effects, process-wide by design. */
+export function defaultAnomalyCluster(): AnomalyCluster {
+  shared ??= new AnomalyCluster();
+  return shared;
+}

package/src/loops/orchestrator/inbox-once.ts

@@ -0,0 +1,28 @@
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { resolveConfiguredAgentRoleLlm } from '../../user-config.js';
+import type { RoleLlmSpec } from '../../user-config.js';
+import { loadAgentRolePack } from '../agent-reply.js';
+import type { MsgStore } from '../../msg/msg-store.js';
+import { runAskOpContextInbox, runCoordinatorAgentInbox, type CoordinatorInboxResult } from './inbox.js';
+import type { AskOpContextBundle } from '../../context-bus/context-now.js';
+
+export interface InboxOnceOptions {
+  root?: string;
+  store?: MsgStore;
+  role?: RoleLlmSpec | null;
+  limit?: number;
+  context?: (question: string, options: { audience?: string; limit?: number }) => Promise<AskOpContextBundle>;
+}
+
+/** One scan of the same durable inbox as the orchestrator tick, without running its graph. */
+export async function runCoordinatorInboxOnce(options: InboxOnceOptions = {}): Promise<CoordinatorInboxResult> {
+  const root = options.root ?? effectiveInstanceRoot();
+  const path = join(root, 'msg', 'messages.db');
+  const role = options.role === undefined ? resolveConfiguredAgentRoleLlm('coordinator') : options.role;
+  if (role) return runCoordinatorAgentInbox({ role, pack: loadAgentRolePack('coordinator'), root, path,
+    limit: options.limit ?? 100, ...(options.store ? { store: options.store } : {}) });
+  return runAskOpContextInbox({ path, limit: options.limit ?? 100,
+    ...(options.store ? { store: options.store } : {}),
+    ...(options.context ? { context: options.context } : {}) });
+}

package/src/loops/orchestrator/inbox.ts

@@ -1,15 +1,90 @@
+import { ASK_OP_COMMAND } from '../../session/channel-ask-op-envelope.js';
 import { openMsgStore, type Message, type MsgStore } from '../../msg/msg-store.js';
 import { classifySeatTrafficProposal } from '../../seat-loop/traffic-signal.js';
-import { debug } from '../../debug/log.js';
+import { debug, redactSecretText } from '../../debug/log.js';
 import { LOOP_MESSAGE_ROUTES } from '../msg-address.js';
 import { replyWithAgent, type AgentReplyInput } from '../agent-reply.js';
 import { knowhowAdvice, type KnowhowAdvice, type KnowhowOptions } from './knowhow-pack.js';
 import type { RoleLlmSpec } from '../../user-config.js';
 import type { LLMProvider } from '../../llm.js';
+import { askOpContextBundle, type AskOpContextBundle } from '../../context-bus/context-now.js';
 
 const RECIPIENT = LOOP_MESSAGE_ROUTES.orchestrator.msgAddress;
 
 export interface CoordinatorInboxResult { replied: number; acknowledged: number }
+export interface AskOpTestHarness {
+  /** A test-only sink; this never defaults to a real surface transport. */
+  replySink: (reply: { from: string; to: string; body: string; kind: 'reply'; replyTo: number }) => Message;
+  /** Capture both clocks without writing to the production log store in tests. */
+  eventSink?: (event: { requestId: number; requestToReplyMs: number | null; processingMs: number }) => void;
+}
+export interface AskOpContextInboxOptions {
+  store?: MsgStore;
+  path?: string;
+  limit?: number;
+  context?: typeof askOpContextBundle;
+  knowhow?: KnowhowOptions | false;
+  /** Only the ordered tick scan may advance the durable cursor. */
+  acknowledge?: boolean;
+  /** SSE delivery handles exactly its message; the ordered tick scans the cursor. */
+  request?: Message;
+  /** Explicit opt-in for synthetic TEST ASK-OP questions only. Production callers must omit this. */
+  testHarness?: AskOpTestHarness;
+}
+
+const ASK_OP_SENDERS = new Set(['TELEGRAM', 'DISCORD']);
+const REFUSE = '모름 — 확인된 근거가 없어 답할 수 없습니다.';
+
+function isAskOpRequest(request: Message, allowTestSource = false): boolean {
+  const testSource = allowTestSource && request.from === 'TEST'
+    && /^Test \/(?:askop|ask-op)(?:\r?\n|$)/.test(request.body);
+  return request.kind === 'question' && (ASK_OP_SENDERS.has(request.from) || testSource)
+    && (testSource || new RegExp(`^(?:Telegram|Discord) \/(?:${ASK_OP_COMMAND}|ask-op)(?:\\r?\\n|$)`).test(request.body));
+}
+
+function askOpLatencyMs(request: Message, repliedAt: number): number | null {
+  const createdAt = Date.parse(request.createdAt);
+  const latencyMs = repliedAt - createdAt;
+  return Number.isFinite(createdAt) && latencyMs >= 0 ? latencyMs : null;
+}
+
+function writeAskOpReply(store: MsgStore, request: Message, replyText: string, options: AskOpContextInboxOptions) {
+  if (options.testHarness && request.from === 'TEST') {
+    const marker = `re #${request.id}\n`;
+    const body = replyText.startsWith(marker) ? replyText.slice(marker.length) : replyText;
+    const reply = options.testHarness.replySink({ from: RECIPIENT, to: request.from,
+      body, kind: 'reply', replyTo: request.id });
+    return { id: reply.id, posted: true };
+  }
+  return writeCoordinatorReply(store, request, replyText);
+}
+
+function askOpQuestion(request: Message): string {
+  const match = /^question: (.*)$/m.exec(request.body);
+  return match?.[1]?.trim() ?? '';
+}
+
+function unsafeAskOp(question: string): boolean {
+  // Reject explicit commands, not descriptive questions such as "What changed since the release?".
+  return /^(?:(?:please|can you|could you|would you)\s+)?(?:run|execute|deploy|publish|push|merge|delete|drop|write|edit|change|set)\b|(?:실행해|발행해|배포해|푸시해|병합해|삭제해|수정해|바꿔|설정해)(?:줘|주세요)?|\b(?:show|reveal|give|tell|display|print|read|open|what is|what's)\b.{0,80}\b(?:secret|token|password|credential|api[ -]?key|private[ -]?key)\b|(?:비밀|토큰|암호|패스워드|인증키|API\s*키).{0,80}(?:보여|알려|공개|읽어)/i.test(question);
+}
+
+async function askOpAnswer(request: Message, options: AskOpContextInboxOptions): Promise<string> {
+  const question = askOpQuestion(request);
+  if (!question) return `제안: ${REFUSE}\n근거: 질문이 비었습니다.`;
+  if (unsafeAskOp(question)) return '제안: 요청한 권한 실행·비밀 조회·traffic/칸 변경은 실행할 수 없습니다.\n근거: OP 질문 답변은 읽기 전용입니다.';
+  let bundle: AskOpContextBundle;
+  // These replies are delivered to an external channel, not the private operator console.
+  try { bundle = await (options.context ?? askOpContextBundle)(question, { audience: 'public-demo', limit: 8 }); }
+  catch { return `제안: ${REFUSE}\n근거: 맥락 조회 실패.`; }
+  const facts = bundle.facts.filter(fact => fact.source?.trim() && fact.summary?.trim()).slice(0, 8);
+  if (!facts.length) {
+    const gaps = bundle.gaps.slice(0, 3).map(gap => `${redactSecretText(gap.kind)}: ${redactSecretText(gap.reason)}`).join('; ');
+    return `제안: ${REFUSE}\n근거: ${gaps || '미관측'}.`;
+  }
+  const evidence = facts.map(fact => `- ${redactSecretText(fact.summary)} — ${redactSecretText(fact.source)} (관측 ${redactSecretText(fact.observedAt)})`).join('\n');
+  return `제안: 다음은 관측된 OP 맥락입니다 (${redactSecretText(bundle.topic)}; 조회 ${redactSecretText(bundle.queriedAt)}).\n근거:\n${evidence}\n판단·승인·실행은 하지 않았습니다.`;
+}
 export interface CoordinatorAgentInboxOptions {
   role: RoleLlmSpec;
   pack: string;
@@ -95,6 +170,57 @@ function writeCoordinatorReply(store: MsgStore, request: Message, replyText: str
   return { id: reply.id, posted: true };
 }
 
+/** Surface ask-op questions use the same linked reply and durable acknowledgement as the resident inbox. */
+export async function runAskOpContextInbox(options: AskOpContextInboxOptions = {}): Promise<CoordinatorInboxResult> {
+  const store = options.store ?? openMsgStore(options.path);
+  const ownStore = options.store === undefined;
+  const result = { replied: 0, acknowledged: 0 };
+  const acknowledge = options.acknowledge !== false;
+  try {
+    const requests = options.request ? [options.request]
+      : store.listByRecipient(RECIPIENT, store.getCursor(RECIPIENT), options.limit ?? 100);
+    for (const request of requests) {
+      if (request.to !== RECIPIENT || request.from === RECIPIENT ||
+        (request.kind !== undefined && request.kind !== 'request' && request.kind !== 'question')) {
+        if (acknowledge) { store.ack(RECIPIENT, request.id); result.acknowledged++; }
+        continue;
+      }
+      const testAskOp = request.from === 'TEST' && isAskOpRequest(request, true);
+      if (testAskOp && !options.testHarness) continue;
+      const key = `coord-inbox:${request.id}:${request.from}`;
+      const existing = store.db.query('SELECT message_id FROM msg_provenance WHERE provenance_key = ?')
+        .get(key) as { message_id: number } | null;
+      // Legacy seat traffic and knowhow requests preserve the existing answer path.
+      const startedAt = Date.now();
+      const replyText = existing ? '' : (isAskOpRequest(request, options.testHarness !== undefined)
+        ? `re #${request.id}\n${await askOpAnswer(request, options)}` : coordinatorReply(request, options.knowhow ?? {}));
+      const one = store.db.transaction(() => {
+        const receipt = store.db.query('SELECT message_id FROM msg_provenance WHERE provenance_key = ?')
+          .get(key) as { message_id: number } | null;
+        const reply = receipt ? { id: receipt.message_id, posted: false } : writeAskOpReply(store, request, replyText, options);
+        if (!receipt) store.db.query('INSERT INTO msg_provenance(provenance_key, message_id) VALUES (?, ?)').run(key, reply.id);
+        if (acknowledge) store.ack(RECIPIENT, request.id);
+        return reply.posted;
+      }).immediate();
+      if (one) result.replied++;
+      if (acknowledge) result.acknowledged++;
+      debug.log('loop.coordinator-inbox', 'reply', { requestId: request.id, recipient: request.from, duplicate: !one });
+      if (one && isAskOpRequest(request, options.testHarness !== undefined)) {
+        const repliedAt = Date.now();
+        const latencyMs = askOpLatencyMs(request, repliedAt);
+        const processingMs = Math.max(0, repliedAt - startedAt);
+        if (options.testHarness && request.from === 'TEST') {
+          options.testHarness.eventSink?.({ requestId: request.id, requestToReplyMs: latencyMs, processingMs });
+        } else {
+          debug.log('ask-op.inbox', 'replied', { requestId: request.id, requestToReplyMs: latencyMs,
+            processingMs, clockSkew: latencyMs === null });
+        }
+      }
+    }
+    return result;
+  } finally { if (ownStore) store.close(); }
+}
+
 /** One transaction ties a reply to its acknowledgement. A retry finds the durable receipt. */
 export function runCoordinatorInbox(inputStore?: MsgStore, limit = 100, path?: string,
   options: CoordinatorInboxOptions = {}): CoordinatorInboxResult {
@@ -144,6 +270,9 @@ export async function handleCoordinatorAgentMessage(
   const ownStore = input.store === undefined;
   const acknowledge = input.acknowledge === true;
   try {
+    if (isAskOpRequest(request) && request.to === RECIPIENT) {
+      return await runAskOpContextInbox({ store, request, acknowledge });
+    }
     if (request.to !== RECIPIENT || request.from === RECIPIENT ||
       (request.kind !== undefined && request.kind !== 'request' && request.kind !== 'question')) {
       if (acknowledge) store.ack(RECIPIENT, request.id);