elanous 0.2.40 → 0.2.42

package/src/msg/msg-mirror-runner.ts

@@ -0,0 +1,219 @@
+import type { Message } from './msg-store.js';
+import { buildMirrorSummary, isMirrorEvent, MIRROR_SUMMARY_INTERVAL_MS, selectMirrorEvents, shouldRotateMirrorChannel } from './msg-mirror-policy.js';
+
+export interface MirrorTarget {
+  repo: string;
+  issueNumber: number;
+}
+
+export interface MsgMirrorState {
+  version: 1;
+  target: MirrorTarget;
+  messageCursor: number;
+  summaryWindowEnd: string;
+  rotationPending?: { from: MirrorTarget; to: MirrorTarget };
+}
+
+export interface MsgMirrorSource {
+  listAfter(afterId: number, limit: number): Message[];
+  listWindow(start: string, end: string): Message[];
+  latestId(): number;
+}
+
+export interface MsgMirrorStateStore {
+  read(): MsgMirrorState | null;
+  write(state: MsgMirrorState): void;
+}
+
+export interface MsgMirrorTransport {
+  beginTick?(): Promise<void> | void;
+  countComments(target: MirrorTarget): Promise<number> | number;
+  hasMarker(target: MirrorTarget, marker: string): Promise<boolean> | boolean;
+  postComment(target: MirrorTarget, body: string): Promise<void> | void;
+  createNextChannel(target: MirrorTarget, idempotencyKey: string): Promise<MirrorTarget> | MirrorTarget;
+  linkAndCloseChannel(from: MirrorTarget, to: MirrorTarget): Promise<void> | void;
+}
+
+export interface MsgMirrorTickOptions {
+  configuredTarget?: MirrorTarget;
+  nowMs?: number;
+  dryRun?: boolean;
+  source: MsgMirrorSource;
+  state: MsgMirrorStateStore;
+  transport: MsgMirrorTransport;
+}
+
+export interface MsgMirrorTickResult {
+  status: 'disabled' | 'dry-run' | 'synced';
+  target: MirrorTarget | null;
+  scanned: number;
+  posted: number;
+  rotated: number;
+  summaries: number;
+  sourceCursor: number;
+}
+
+const VALID_REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+
+export function validateMirrorTarget(value: unknown): MirrorTarget {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('mirror target must be an object');
+  const target = value as Record<string, unknown>;
+  if (typeof target.repo !== 'string' || !VALID_REPO.test(target.repo)
+    || typeof target.issueNumber !== 'number' || !Number.isSafeInteger(target.issueNumber) || target.issueNumber < 1) {
+    throw new Error('mirror target requires repo=owner/name and a positive issueNumber');
+  }
+  return { repo: target.repo, issueNumber: target.issueNumber as number };
+}
+
+/** Sparse settings are disabled by default; malformed nonempty settings are rejected. */
+export function configuredMirrorTarget(raw: unknown): MirrorTarget | undefined {
+  if (raw === undefined) return undefined;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('msgMirror config must be an object');
+  const target = (raw as Record<string, unknown>).target;
+  return target === undefined ? undefined : validateMirrorTarget(target);
+}
+
+export function validateMsgMirrorState(value: unknown): MsgMirrorState {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid message mirror state');
+  const state = value as Record<string, unknown>;
+  if (state.version !== 1 || typeof state.messageCursor !== 'number' || !Number.isSafeInteger(state.messageCursor) || state.messageCursor < 0
+    || typeof state.summaryWindowEnd !== 'string' || !Number.isFinite(Date.parse(state.summaryWindowEnd))) throw new Error('invalid message mirror state');
+  const target = validateMirrorTarget(state.target);
+  const pending = state.rotationPending;
+  const rotationPending = pending && typeof pending === 'object' && !Array.isArray(pending)
+    ? { from: validateMirrorTarget((pending as Record<string, unknown>).from), to: validateMirrorTarget((pending as Record<string, unknown>).to) }
+    : undefined;
+  if (pending !== undefined && !rotationPending) throw new Error('invalid pending mirror rotation');
+  return { version: 1, target, messageCursor: state.messageCursor as number, summaryWindowEnd: new Date(state.summaryWindowEnd as string).toISOString(),
+    ...(rotationPending ? { rotationPending } : {}) };
+}
+
+function initialState(target: MirrorTarget, nowMs: number, latestMessageId: number): MsgMirrorState {
+  if (!Number.isSafeInteger(latestMessageId) || latestMessageId < 0) throw new Error('source latest message ID is invalid');
+  const end = Math.floor(nowMs / MIRROR_SUMMARY_INTERVAL_MS) * MIRROR_SUMMARY_INTERVAL_MS;
+  return { version: 1, target, messageCursor: latestMessageId, summaryWindowEnd: new Date(end).toISOString() };
+}
+
+function eventMarker(id: number): string { return `<!-- elanous-msg-mirror:event:${id} -->`; }
+function summaryMarker(start: string): string { return `<!-- elanous-msg-mirror:summary:${start} -->`; }
+
+function renderEvent(message: Message): string {
+  return `## ${message.kind} · #${message.id}\n\n**${message.from} → ${message.to}** · ${message.createdAt}\n\n${message.body.trim()}`;
+}
+
+async function prepareTarget(state: MsgMirrorState, transport: MsgMirrorTransport, dryRun: boolean): Promise<{
+  state: MsgMirrorState; rotated: number;
+}> {
+  let current = state;
+  let rotated = 0;
+  if (current.rotationPending) {
+    if (dryRun) return { state: current, rotated };
+    await transport.linkAndCloseChannel(current.rotationPending.from, current.rotationPending.to);
+    current = { ...current, rotationPending: undefined };
+  }
+  const count = await transport.countComments(current.target);
+  if (!shouldRotateMirrorChannel(count)) return { state: current, rotated };
+  if (dryRun) return { state: current, rotated };
+  const oldTarget = current.target;
+  const nextTarget = validateMirrorTarget(await transport.createNextChannel(oldTarget,
+    `msg-mirror-rotate:${oldTarget.repo}#${oldTarget.issueNumber}`));
+  current = { ...current, target: nextTarget, rotationPending: { from: oldTarget, to: nextTarget } };
+  // Persist the pointer before closing the old issue. On restart the pending link/close is retried.
+  // If this write fails, the adapter's idempotency key prevents creating another channel.
+  return { state: current, rotated: 1 };
+}
+
+/** One idempotent mirror pass. All GitHub effects are behind the injected transport. */
+export async function runMsgMirrorTick(options: MsgMirrorTickOptions): Promise<MsgMirrorTickResult> {
+  const nowMs = options.nowMs ?? Date.now();
+  if (!Number.isFinite(nowMs)) throw new Error('nowMs must be finite');
+  const stored = options.state.read();
+  const configured = options.configuredTarget ? validateMirrorTarget(options.configuredTarget) : undefined;
+  if (!stored && !configured) return { status: 'disabled', target: null, scanned: 0, posted: 0, rotated: 0, summaries: 0, sourceCursor: 0 };
+  await options.transport.beginTick?.();
+  let state = stored ? validateMsgMirrorState(stored) : initialState(configured!, nowMs, options.source.latestId());
+  let scanned = 0, posted = 0, rotated = 0, summaries = 0;
+  if (!options.dryRun) options.state.write(state);
+
+  const startTarget = state.target;
+  const prepared = await prepareTarget(state, options.transport, options.dryRun === true);
+  state = prepared.state;
+  rotated += prepared.rotated;
+  if (!options.dryRun && state !== stored) options.state.write(state);
+
+  // A rotation is recorded before side effects that close the previous issue.
+  if (state.rotationPending && !options.dryRun) {
+    await options.transport.linkAndCloseChannel(state.rotationPending.from, state.rotationPending.to);
+    state = { ...state, rotationPending: undefined };
+    options.state.write(state);
+  }
+
+  let page = options.source.listAfter(state.messageCursor, 1000);
+  while (page.length > 0) {
+    const eligible = new Map(selectMirrorEvents(page, state.messageCursor).map(message => [message.id, message]));
+    for (const message of page) {
+      scanned++;
+      const event = eligible.get(message.id);
+      if (event) {
+        const preparedNext = await prepareTarget(state, options.transport, options.dryRun === true);
+        if (preparedNext.rotated) {
+          state = preparedNext.state;
+          rotated += preparedNext.rotated;
+          if (!options.dryRun) {
+            options.state.write(state);
+            if (state.rotationPending) {
+              await options.transport.linkAndCloseChannel(state.rotationPending.from, state.rotationPending.to);
+              state = { ...state, rotationPending: undefined };
+              options.state.write(state);
+            }
+          }
+        }
+        const marker = eventMarker(event.id);
+        if (!options.dryRun && !(await options.transport.hasMarker(state.target, marker))) {
+          await options.transport.postComment(state.target, `${marker}\n${renderEvent(event)}`);
+          posted++;
+        }
+      }
+      state = { ...state, messageCursor: message.id };
+      if (!options.dryRun) options.state.write(state);
+    }
+    if (page.length < 1000) break;
+    page = options.source.listAfter(state.messageCursor, 1000);
+  }
+
+  let windowStart = Date.parse(state.summaryWindowEnd);
+  const nowWindowEnd = Math.floor(nowMs / MIRROR_SUMMARY_INTERVAL_MS) * MIRROR_SUMMARY_INTERVAL_MS;
+  while (windowStart + MIRROR_SUMMARY_INTERVAL_MS <= nowWindowEnd) {
+    const windowEnd = windowStart + MIRROR_SUMMARY_INTERVAL_MS;
+    const from = new Date(windowStart).toISOString();
+    const to = new Date(windowEnd).toISOString();
+    const summary = buildMirrorSummary(options.source.listWindow(from, to), from, to);
+    if (summary) {
+      const preparedNext = await prepareTarget(state, options.transport, options.dryRun === true);
+      if (preparedNext.rotated) {
+        state = preparedNext.state;
+        rotated += preparedNext.rotated;
+        if (!options.dryRun) {
+          options.state.write(state);
+          if (state.rotationPending) {
+            await options.transport.linkAndCloseChannel(state.rotationPending.from, state.rotationPending.to);
+            state = { ...state, rotationPending: undefined };
+            options.state.write(state);
+          }
+        }
+      }
+      const marker = summaryMarker(from);
+      if (!options.dryRun && !(await options.transport.hasMarker(state.target, marker))) {
+        await options.transport.postComment(state.target, `${marker}\n${summary}`);
+        posted++;
+      }
+      summaries++;
+    }
+    state = { ...state, summaryWindowEnd: to };
+    if (!options.dryRun) options.state.write(state);
+    windowStart = windowEnd;
+  }
+
+  return { status: options.dryRun ? 'dry-run' : 'synced', target: options.dryRun ? startTarget : state.target,
+    scanned, posted, rotated, summaries, sourceCursor: state.messageCursor };
+}

package/src/msg/msg-mirror-state.ts

@@ -0,0 +1,33 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { validateMsgMirrorState, type MsgMirrorState, type MsgMirrorStateStore } from './msg-mirror-runner.js';
+
+export function defaultMsgMirrorStatePath(): string {
+  return join(elanousStateRoot(), 'msg', 'github-mirror-state.json');
+}
+
+/** One durable rotation pointer and progress cursor, stored atomically in the active state universe. */
+export class JsonMsgMirrorStateStore implements MsgMirrorStateStore {
+  constructor(readonly path: string = defaultMsgMirrorStatePath()) {}
+
+  read(): MsgMirrorState | null {
+    if (!existsSync(this.path)) return null;
+    const parsed: unknown = JSON.parse(readFileSync(this.path, 'utf8'));
+    return validateMsgMirrorState(parsed);
+  }
+
+  write(state: MsgMirrorState): void {
+    const normalized = validateMsgMirrorState(state);
+    mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+    const temp = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temp, `${JSON.stringify(normalized, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+      renameSync(temp, this.path);
+    } catch (error) {
+      try { rmSync(temp, { force: true }); } catch { /* preserve the original write error */ }
+      throw error;
+    }
+  }
+}

package/src/msg/msg-store.ts

@@ -129,6 +129,7 @@ export class MsgStore {
       created_at TEXT NOT NULL
     );
     CREATE INDEX IF NOT EXISTS idx_msg_messages_recipient_id ON msg_messages(recipient, id);
+    CREATE INDEX IF NOT EXISTS idx_msg_messages_created_at_id ON msg_messages(created_at, id);
     CREATE TABLE IF NOT EXISTS msg_cursors (
       recipient TEXT PRIMARY KEY,
       last_id INTEGER NOT NULL DEFAULT 0 CHECK(last_id >= 0)
@@ -307,6 +308,16 @@ export class MsgStore {
       WHERE id > ? ORDER BY id ASC LIMIT ?`).all(after, limit) as MessageRow[]).map(fromRow));
   }
 
+  /** Read a half-open UTC timestamp window for periodic message-mirror summaries. */
+  listCreatedBetween(start: string, end: string): Message[] {
+    const startMs = Date.parse(start);
+    const endMs = Date.parse(end);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) throw new Error('invalid message time window');
+    return this.readWithSchema(hasReplyTo => (this.db.query(`SELECT id, sender, recipient, body, kind,
+      ${hasReplyTo ? 'reply_to' : 'NULL AS reply_to'}, created_at FROM msg_messages
+      WHERE created_at >= ? AND created_at < ? ORDER BY id ASC`).all(new Date(startMs).toISOString(), new Date(endMs).toISOString()) as MessageRow[]).map(fromRow));
+  }
+
   latestId(): number {
     return (this.db.query('SELECT COALESCE(MAX(id), 0) AS id FROM msg_messages').get() as { id: number }).id;
   }

package/src/native-tool-catalog.ts

@@ -676,8 +676,8 @@ export const nativeToolCatalog: NativeToolCatalogEntry[] = [
     kind: 'execute',
     aliases: ['SkillExec', 'skill_exec'],
     displayName: 'SkillExec',
-    description: 'Execute one explicitly named allowlisted skill with the supplied task. If you do not know the exact skill name, call elanous_skills_list first. Does not infer a skill name.',
-    promptSummary: '`SkillExec(skill, task)` (execute an explicitly named allowlisted skill; call elanous_skills_list first when its exact name is unknown)',
+    description: 'Execute one explicitly named allowlisted skill with the supplied task. Names may omit spaces or punctuation (for example, "krflow" resolves to "kr-flow") only when the installed match is unique. Call elanous_skills_list when uncertain.',
+    promptSummary: '`SkillExec(skill, task)` (resolve omitted spaces or punctuation only when the installed skill name is unique; call elanous_skills_list when uncertain)',
     host: ['skill', 'tui', 'mcp'],
     safety: ['process'],
     supportsParallel: false,

package/src/nexus/api/harness-traversal.ts

@@ -18,6 +18,7 @@
 
 import { loadFederatedRunLedger, loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../../self-implement/run-ledger.js';
 import { redactSecretText } from '../../debug/log.js';
+import { projectRunLedgerSteps, type RunStep } from '../../self-implement/run-step-projection.js';
 
 export interface TraversalStepWire {
   node: string;
@@ -29,6 +30,8 @@ export interface TraversalStepWire {
   visit: number;
   maxVisits: number | null;
   detail: string | null;
+  /** Ledger sequence of this traversal entry; absent on legacy records. */
+  sourceSeq?: number;
 }
 
 export interface RunTraversalWire {
@@ -43,6 +46,8 @@ export interface RunTraversalWire {
   prNumber: number | null;
   substrate: string | null;
   steps: TraversalStepWire[];
+  /** Structural graph changes in the same per-run sequence domain as `steps[].sourceSeq`. */
+  graphEvents?: RunStep[];
   ledgerEvents: number;
 }
 
@@ -153,6 +158,7 @@ export function buildRunTraversal(runId: string, entries: readonly RunLedgerEntr
     if (isLast && terminal) outcome = TERMINAL_FAIL.has(status) ? 'fail' : (outcome ?? 'pass');
     const endIso = nextAt !== undefined ? sorted[nextAt]!.timestamp : terminal?.timestamp;
     const duration = ms(endIso) - ms(entry.timestamp);
+    const sourceSeq = (entry as RunLedgerEntry & { seq?: unknown }).seq ?? entry.data.seq;
     return {
       node,
       round: num(entry.data.round),
@@ -162,11 +168,15 @@ export function buildRunTraversal(runId: string, entries: readonly RunLedgerEntr
       visit,
       maxVisits: num(budget?.data.maxVisits),
       detail,
+      ...(typeof sourceSeq === 'number' && Number.isSafeInteger(sourceSeq) && sourceSeq > 0 ? { sourceSeq } : {}),
     };
   });
 
   const contract = sorted.find((entry) => entry.event === 'graph-run-contract-resolved')?.data;
   const pr = [...sorted].reverse().find((entry) => entry.event === 'pr-opened')?.data;
+  const projected = projectRunLedgerSteps(runId, sorted);
+  const graphEvents = projected.steps.filter((step) =>
+    step.type === 'node-added' || step.type === 'edge-rerouted' || step.type === 'unit-expanded' || step.type === 'unit-collapsed');
   return {
     runId,
     graphId: str(contract?.graphId) ?? str(sorted.find((entry) => entry.event === 'pipeline-node-entry')?.data.graphId),
@@ -178,6 +188,7 @@ export function buildRunTraversal(runId: string, entries: readonly RunLedgerEntr
     prNumber: num(pr?.number),
     substrate: str(contract?.actualSubstrate),
     steps,
+    ...(graphEvents.length ? { graphEvents } : {}),
     ledgerEvents: sorted.length,
   };
 }

package/src/output-truncation.ts

@@ -35,7 +35,7 @@ export interface TruncateOptions {
   toolName: string;
   /** File extension for the spilled file (no leading dot). Default 'txt'. */
   ext?: string;
-  /** Bytes above which we spill. Default 8192. */
+  /** Bytes above which we spill. Default 8192. The inline spill marker must fit this limit. */
   inlineLimit?: number;
   /** Head bytes preserved when spilled. Default 4096. */
   headBytes?: number;
@@ -59,8 +59,8 @@ export interface TruncateResult {
 /** Apply head/tail truncation + optional disk spill. */
 export function truncateOutput(body: string, opts: TruncateOptions): TruncateResult {
   const inlineLimit = opts.inlineLimit ?? DEFAULT_INLINE_LIMIT;
-  const head = opts.headBytes ?? DEFAULT_HEAD_BYTES;
-  const tail = opts.tailBytes ?? DEFAULT_TAIL_BYTES;
+  const requestedHead = opts.headBytes ?? DEFAULT_HEAD_BYTES;
+  const requestedTail = opts.tailBytes ?? DEFAULT_TAIL_BYTES;
   const ext = (opts.ext ?? 'txt').replace(/^\./, '');
   const outputDir = opts.outputDir ?? DEFAULT_OUTPUT_DIR;
 
@@ -74,22 +74,51 @@ export function truncateOutput(body: string, opts: TruncateOptions): TruncateRes
   const filename = `${opts.toolName}-${hash}.${ext}`;
   const savedPath = joinPath(outputDir, filename);
 
+  // Reserve enough space for the full path/footer first, then scale the
+  // requested head/tail budgets to fit the inline byte limit. A tiny limit
+  // that cannot hold the recovery marker is invalid instead of silently
+  // exceeding the configured maximum.
+  const marker = (elided: number) =>
+    `\n\n[... ${elided} bytes elided — saved to ${savedPath} (${bytes} bytes total). ` +
+    `Use Read tool with file_path="${savedPath}" to inspect more. ...]\n\n`;
+  const markerBudget = Buffer.byteLength(marker(bytes), 'utf8');
+  if (markerBudget >= inlineLimit) {
+    throw new RangeError(`inlineLimit must leave room for the saved-output marker (minimum ${markerBudget + 1} bytes)`);
+  }
   if (!existsSync(savedPath)) {
     mkdirSync(outputDir, { recursive: true });
     writeFileSync(savedPath, body, 'utf-8');
   }
+  const availableContentBytes = inlineLimit - markerBudget;
+  const requestedContentBytes = requestedHead + requestedTail;
+  const scale = requestedContentBytes > availableContentBytes
+    ? availableContentBytes / requestedContentBytes
+    : 1;
+  const head = Math.floor(requestedHead * scale);
+  const tail = Math.floor(requestedTail * scale);
 
-  // Build head+tail+footer. Slice on the string (not bytes) for
-  // simplicity; cap is a hint, not an invariant. UTF-8 multi-byte
-  // boundaries don't matter because we feed it to the LLM, not a
-  // byte-stream consumer.
-  const headStr = body.slice(0, head);
-  const tailStr = body.slice(-tail);
-  const elided = bytes - headStr.length - tailStr.length;
+  // Preserve byte budgets and never split a UTF-8 code point. The LLM
+  // inline limit is a byte limit too, so character slicing would allow
+  // multibyte output to exceed it by up to 4x.
+  const bodyBuffer = Buffer.from(body, 'utf8');
+  const alignStart = (offset: number): number => {
+    let index = Math.max(0, Math.min(bodyBuffer.length, offset));
+    while (index < bodyBuffer.length && (bodyBuffer[index]! & 0b1100_0000) === 0b1000_0000) index++;
+    return index;
+  };
+  const alignEnd = (offset: number): number => {
+    let index = Math.max(0, Math.min(bodyBuffer.length, offset));
+    while (index > 0 && index < bodyBuffer.length && (bodyBuffer[index]! & 0b1100_0000) === 0b1000_0000) index--;
+    return index;
+  };
+  const headEnd = alignEnd(head);
+  const tailStart = alignStart(bodyBuffer.length - tail);
+  const headStr = bodyBuffer.toString('utf8', 0, headEnd);
+  const tailStr = bodyBuffer.toString('utf8', tailStart);
+  const elided = bytes - Buffer.byteLength(headStr, 'utf8') - Buffer.byteLength(tailStr, 'utf8');
   const out = [
     headStr,
-    `\n\n[... ${elided} bytes elided — saved to ${savedPath} (${bytes} bytes total). ` +
-      `Use Read tool with file_path="${savedPath}" to inspect more. ...]\n\n`,
+    marker(elided),
     tailStr,
   ].join('');
 

package/src/pr-tool/census.ts

@@ -41,7 +41,7 @@ export interface GuardReason { code: GuardCode; detail: string; prs?: readonly n
 /** PR-GUARD-HUNK-WARN (대표 10-17): 줄 겹침은 기본 경고 — 착지 쪽 스마트 머지가 푼다. 'refuse' = 옛 거부 동작. */
 export type HunkOverlapMode = 'refuse' | 'warn';
 export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[];
-  sameCellConflicts?: readonly { pr: number; cardId: string | null; slice?: { slice: number; total: number } | null }[];
+  sameCellConflicts?: readonly { pr: number; branch: string | null; headSha: string; cardId: string | null; slice?: { slice: number; total: number } | null }[];
   sameCellReuse?: { number: number; branch: string; headSha: string; cellId: string; cardId: string; legacyBound?: true } }
 
 const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
@@ -511,7 +511,8 @@ export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat
     ? { number: sameCell[0].number, branch: sameCell[0].headRefName, headSha: sameCell[0].headSha,
       cellId: input.cellId!, cardId: input.cardId, ...(legacyBound ? { legacyBound: true as const } : {}) } : undefined;
   return { status, reasons, warnings,
-    ...(sameCell.length ? { sameCellConflicts: sameCell.map(pr => ({ pr: pr.number, cardId: pr.cardId ?? null, slice: pr.slice ?? null })) } : {}),
+    ...(sameCell.length ? { sameCellConflicts: sameCell.map(pr => ({ pr: pr.number, branch: pr.headRefName ?? null,
+      headSha: pr.headSha, cardId: pr.cardId ?? null, slice: pr.slice ?? null })) } : {}),
     ...(reusable ? { sameCellReuse: reusable } : {}) };
 }
 

package/src/project/project-store.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, createHmac, randomBytes, randomUUID } from 'node:crypto';
 import { linkSync, mkdirSync, readFileSync, readdirSync, realpathSync, unlinkSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { parse, stringify } from 'yaml';
@@ -133,3 +133,50 @@ export function getProject(id: string): Project | null {
 export function suggestProjectForFolder(folder: string): Project | null {
   return new ProjectStore().suggestForFolder(folder);
 }
+
+// TENANT-BOUNDARY (0.2.41 · nfr:security): 고객 프로젝트 원장이 설치 밖으로 나가는
+// 출구는 이 익명 내보내기 하나다 — 식별 필드(이름·경로)는 익명 토큰으로 치환되고
+// id(이미 불투명한 uuid)·createdAt·relations 만 남는다.
+export interface AnonymousProject {
+  id: string;
+  name: string;
+  createdAt: string;
+  primaryFolder?: string;
+  relations?: Project['relations'];
+}
+
+const ANONYMOUS_EXPORT_DOMAIN = 'elanous-tenant-boundary';
+
+function anonymousExportSecret(): Buffer {
+  const configDir = getElanousConfigDir();
+  const path = join(configDir, 'tenant-boundary-secret');
+  try {
+    const existing = readFileSync(path);
+    if (existing.length === 32) return existing;
+  } catch { /* first use */ }
+  mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  const secret = randomBytes(32);
+  try { writeFileSync(path, secret, { flag: 'wx', mode: 0o600 }); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+    const existing = readFileSync(path);
+    if (existing.length === 32) return existing;
+    throw new Error('invalid tenant boundary secret');
+  }
+  return secret;
+}
+
+export function anonymousToken(prefix: 'project' | 'folder', value: string): string {
+  return `${prefix}-${createHmac('sha256', anonymousExportSecret()).update(`${ANONYMOUS_EXPORT_DOMAIN}\u0000${prefix}\u0000${value}`).digest('hex').slice(0, 16)}`;
+}
+
+export function anonymousExport(project: Project): AnonymousProject {
+  const exported: AnonymousProject = {
+    id: project.id,
+    name: anonymousToken('project', project.name),
+    createdAt: project.createdAt,
+  };
+  if (project.primaryFolder !== undefined) exported.primaryFolder = anonymousToken('folder', project.primaryFolder);
+  if (project.relations !== undefined) exported.relations = project.relations;
+  return exported;
+}