elanous 0.2.11 → 0.2.13

package/src/nexus/api/workflow-history.ts

@@ -0,0 +1,88 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getGlobalWorkflowDir, getProjectWorkflowDir } from '../../workflow-runtime/discovery.js';
+
+export interface WorkflowHistoryOpts {
+  scope?: 'project' | 'global';
+  cwd?: string;
+}
+
+export interface WorkflowHistoryVersion {
+  id: string;
+  createdAt: string;
+  size: number;
+}
+
+const MAX_VERSIONS = 20;
+const VERSION_ID = /^(\d{13})-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+function safeName(name: string): void {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) || name.includes('..')) {
+    throw new Error('invalid workflow name');
+  }
+}
+
+function safeVersionId(id: string): void {
+  if (!/^[A-Za-z0-9_-]+$/.test(id)) throw new Error('invalid workflow history version id');
+}
+
+function workflowDir(opts: WorkflowHistoryOpts): string {
+  return opts.scope === 'global'
+    ? getGlobalWorkflowDir()
+    : getProjectWorkflowDir(opts.cwd ?? process.cwd());
+}
+
+function historyDir(name: string, opts: WorkflowHistoryOpts): string {
+  safeName(name);
+  return join(workflowDir(opts), '.history', name);
+}
+
+/** Capture the current YAML before its caller overwrites it; a missing file has no history. */
+export function snapshotBeforeSave(name: string, opts: WorkflowHistoryOpts = {}): WorkflowHistoryVersion | null {
+  const dir = historyDir(name, opts);
+  const source = join(workflowDir(opts), `${name}.yaml`);
+  if (!existsSync(source)) return null;
+  const content = readFileSync(source);
+  const previous = listWorkflowHistory(name, opts)[0];
+  if (previous && readFileSync(join(dir, `${previous.id}.yaml`)).equals(content)) return null;
+
+  mkdirSync(dir, { recursive: true });
+  const timestamp = Math.max(Date.now(), previous ? Number(previous.id.slice(0, 13)) + 1 : 0);
+  const id = `${String(timestamp).padStart(13, '0')}-${randomUUID()}`;
+  const version: WorkflowHistoryVersion = {
+    id,
+    createdAt: new Date(Number(id.slice(0, 13))).toISOString(),
+    size: content.byteLength,
+  };
+  writeFileSync(join(dir, `${id}.yaml`), content, { flag: 'wx' });
+  for (const old of listWorkflowHistory(name, opts).slice(MAX_VERSIONS)) {
+    unlinkSync(join(dir, `${old.id}.yaml`));
+  }
+  return version;
+}
+
+/** Enumerate only this workflow's snapshots, newest first. */
+export function listWorkflowHistory(name: string, opts: WorkflowHistoryOpts = {}): WorkflowHistoryVersion[] {
+  const dir = historyDir(name, opts);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter(file => file.endsWith('.yaml') && VERSION_ID.test(file.slice(0, -5)))
+    .map(file => {
+      const id = file.slice(0, -5);
+      const filePath = join(dir, file);
+      const stat = statSync(filePath);
+      return stat.isFile() ? { id, createdAt: new Date(Number(id.slice(0, 13))).toISOString(), size: stat.size } : null;
+    })
+    .filter((version): version is WorkflowHistoryVersion => version !== null)
+    .sort((a, b) => b.id.localeCompare(a.id));
+}
+
+/** A missing (well-formed) version returns null rather than an empty YAML draft. */
+export function getWorkflowHistoryVersion(name: string, id: string, opts: WorkflowHistoryOpts = {}): string | null {
+  const dir = historyDir(name, opts);
+  safeVersionId(id);
+  const file = join(dir, `${id}.yaml`);
+  if (!VERSION_ID.test(id) || !existsSync(file)) return null;
+  return readFileSync(file, 'utf-8');
+}

package/src/nexus/api/workflows.ts

@@ -32,7 +32,9 @@ import { requirePosixShellCommand } from '../../platform/default-shell.js';
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
+import { debug } from '../../debug/log.js';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
+import { getWorkflowHistoryVersion, listWorkflowHistory, snapshotBeforeSave } from './workflow-history.js';
 import {
   deleteWorkflow,
   discoverWorkflows,
@@ -232,6 +234,45 @@ export function handleWorkflowGet(
   );
 }
 
+export function handleWorkflowHistoryList(
+  req: Request,
+  name: string,
+  opts: MetaApiOpts,
+): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed', method: req.method }, 405);
+  const scope = new URL(req.url).searchParams.get('scope') === 'global' ? 'global' : 'project';
+  try {
+    return jsonResponse({ versions: listWorkflowHistory(name, { scope }) }, 200);
+  } catch (err) {
+    if (err instanceof Error && err.message === 'invalid workflow name') {
+      return jsonResponse({ error: 'bad_request', reason: err.message }, 400);
+    }
+    throw err;
+  }
+}
+
+export function handleWorkflowHistoryVersionGet(
+  req: Request,
+  name: string,
+  id: string,
+  opts: MetaApiOpts,
+): Response {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed', method: req.method }, 405);
+  const scope = new URL(req.url).searchParams.get('scope') === 'global' ? 'global' : 'project';
+  try {
+    const yaml = getWorkflowHistoryVersion(name, id, { scope });
+    if (yaml === null) return jsonResponse({ error: 'not_found', name, id }, 404);
+    return jsonResponse({ yaml }, 200);
+  } catch (err) {
+    if (err instanceof Error && (err.message === 'invalid workflow name' || err.message === 'invalid workflow history version id')) {
+      return jsonResponse({ error: 'bad_request', reason: err.message }, 400);
+    }
+    throw err;
+  }
+}
+
 export async function handleWorkflowPut(
   req: Request,
   name: string,
@@ -248,6 +289,17 @@ export async function handleWorkflowPut(
     return jsonResponse({ error: 'bad_request', reason: '`yaml` must be a string' }, 400);
   }
   const scope = scopeRaw === 'global' ? 'global' : 'project';
+  const parsed = parseWorkflowYaml(yamlText);
+  if (parsed.ok && parsed.workflow?.name === name) {
+    // Capture the existing file before saveWorkflow overwrites it; a failed snapshot is non-fatal.
+    try {
+      snapshotBeforeSave(name, { scope });
+    } catch (err) {
+      debug.log('nexus.workflow-history', 'snapshot-failed', {
+        name, scope, error: err instanceof Error ? err.message : String(err),
+      }, { level: 'warn' });
+    }
+  }
   const r = saveWorkflow(name, yamlText, { scope });
   if (!r.ok) {
     return jsonResponse(

package/src/nexus/outbound/delivery-ledger.ts

@@ -52,20 +52,29 @@ export function deliveryDedupKey(kind: string, text: string): string {
   return createHash('sha1').update(`${kind}\n${norm}`).digest('hex').slice(0, 16);
 }
 
-/** ① 중복 발사 제어 — 같은 dedupKey가 windowSec 내에 이미 발송됐나(재팬아웃 억제).
- *  보수적 짧은 창(기본 120s) — 크론 재시도·이중호출 같은 즉시 중복만 잡고,
- *  시간 지난 정당한 재발송은 통과. (의미 중복은 상류 signal-dedup 6h 담당.) */
-export function recentlyDelivered(
+/** ① 중복 발사 제어 — windowSec 내 동일 메시지가 한 채널 이상 성공했으면 그 messageId.
+ *  실패 기록은 재시도를 막지 않는다. 짧은 창(기본 120s) 밖의 재발송은 통과. */
+export function successfulDeliveryId(
   db: Database, dedupKey: string, windowSec = 120, nowMs: number = Date.now(),
-): boolean {
+): string | null {
   // ⚠️ 축 ②(JS 임계 · db-window 참조) — 같은 파일의 `recentDeliveryCount` 와 동형이다.
   //    SQL 안의 `datetime('now')` 를 쓰면 **시계를 주입할 수 없어** 테스트가 실제 시각에
   //    매달린다. 실제로 이 함수의 테스트가 고정 날짜로 seed 한 채 시간이 흘러 어느 날 빨개진
   //    시한폭탄이었다. `deliveries.ts` 는 ISO 로만 쓰므로 raw 비교가 옳고 인덱스도 산다.
   const row = db.prepare(
-    `SELECT 1 FROM deliveries WHERE dedup_key = ? AND ts >= ? LIMIT 1`,
-  ).get(dedupKey, sinceTs(SECONDS(windowSec), nowMs));
-  return !!row;
+    `SELECT message_id FROM deliveries
+     WHERE dedup_key = ? AND ts >= ?
+       AND EXISTS (SELECT 1 FROM json_each(deliveries.channels) WHERE json_extract(value, '$.ok') = 1)
+     ORDER BY ts DESC LIMIT 1`,
+  ).get(dedupKey, sinceTs(SECONDS(windowSec), nowMs)) as { message_id: string } | null;
+  return row?.message_id ?? null;
+}
+
+/** 기존 boolean 호출부 호환 — 성공 배송 기록만 중복으로 센다. */
+export function recentlyDelivered(
+  db: Database, dedupKey: string, windowSec = 120, nowMs: number = Date.now(),
+): boolean {
+  return successfulDeliveryId(db, dedupKey, windowSec, nowMs) !== null;
 }
 
 /** 최근 창(windowSec) 내 총 발송 수 — 버스트(밀림) 판정용. 전 kind 합산.

package/src/nexus/outbound/router.ts

@@ -27,13 +27,14 @@
 // that boolean before falling back to direct Telegram).
 
 import { createHash } from 'node:crypto';
+import { debug } from '../../debug/log.js';
 import { sendTelegramReport } from '../../telegram-report.js';
 import { getPushcutClient } from '../../pushcut/client.js';
 import type { UserConfig } from '../../user-config.js';
 import { formatForChannel, type OutboundChannelType, type OutboundMsg } from './format.js';
 import { spillLongContent } from '../../storage/content-spill.js';
 import {
-  openDeliveryDb, deliveryDedupKey, recentlyDelivered, recordDelivery, type ChannelDelivery,
+  openDeliveryDb, deliveryDedupKey, successfulDeliveryId, recordDelivery, type ChannelDelivery,
 } from './delivery-ledger.js';
 
 // 채널 타입·메시지·분할기는 format.ts가 단일 출처 — 기존 소비처(test 등) 호환 재export.
@@ -71,6 +72,8 @@ export interface RouteResult {
   channels: ChannelResult[];
   /** 중복 발사 제어(dedup)로 재팬아웃이 억제됨 — 최근 동일 발송 존재. */
   suppressed?: boolean;
+  /** 억제 근거가 된 앞선 성공 발송의 식별자. */
+  suppressedBy?: string;
   /** 이 발송의 식별자(리드 동기화·회상 교차참조용). */
   messageId?: string;
 }
@@ -207,9 +210,11 @@ export async function routeOutbound(cfg: UserConfig, msg: OutboundMsg, deps: Rou
   // ① 중복 발사 제어 — 최근(120s) 동일 발송이면 재팬아웃 억제.
   if (ledger && deps.dedup !== false) {
     try {
-      if (recentlyDelivered(ledger, dedupKey)) {
+      const suppressedBy = successfulDeliveryId(ledger, dedupKey);
+      if (suppressedBy) {
         if (ownLedger) ledger.close();
-        return { delivered: true, channels: [], suppressed: true, messageId };
+        try { debug.log('outbound.send', 'suppressed', { kind: msg.kind, suppressedBy }); } catch { /* 관측 실패는 발송 결과에 영향 없음 */ }
+        return { delivered: true, channels: [], suppressed: true, suppressedBy, messageId };
       }
     } catch { /* 원장 조회 실패 — 억제 없이 진행 */ }
   }

package/src/persona/loader.ts

@@ -138,6 +138,22 @@ export function validatePersonaShape(
     models = mr.models;
   }
 
+  let seat: string | undefined;
+  if (Object.hasOwn(obj, 'seat')) {
+    if (typeof obj['seat'] !== 'string' || !obj['seat'].trim()) {
+      return err(path, 'seat must be a non-empty string');
+    }
+    seat = obj['seat'];
+  }
+
+  let todo: string | undefined;
+  if (Object.hasOwn(obj, 'todo')) {
+    if (typeof obj['todo'] !== 'string' || !/^[a-z0-9_][a-z0-9_-]*\.todo\.jsonl$/i.test(obj['todo'])) {
+      return err(path, 'todo must be a per-persona .todo.jsonl filename');
+    }
+    todo = obj['todo'];
+  }
+
   let mentionPatterns: readonly string[] | undefined;
   if (obj['mentionPatterns'] !== undefined) {
     if (!Array.isArray(obj['mentionPatterns'])
@@ -149,6 +165,8 @@ export function validatePersonaShape(
 
   const profile: PersonaProfile = {
     personaId, displayName,
+    ...(seat !== undefined ? { seat } : {}),
+    ...(todo !== undefined ? { todo } : {}),
     ...(description.value !== undefined ? { description: description.value } : {}),
     ...(systemPrompt.value !== undefined ? { systemPrompt: systemPrompt.value } : {}),
     ...(brand !== undefined ? { brand } : {}),

package/src/persona/persona-todo.ts

@@ -6,6 +6,8 @@ export interface PersonaTodo {
   title: string;
   status: 'open' | 'done';
   createdAt: string;
+  priority?: number;
+  dueAt?: string;
 }
 
 export interface PersonaTodoReadResult {
@@ -28,7 +30,9 @@ function isPersonaTodo(value: unknown): value is PersonaTodo {
     && typeof item.title === 'string' && item.title.length > 0
     && (item.status === 'open' || item.status === 'done')
     && typeof item.createdAt === 'string'
-    && Number.isFinite(Date.parse(item.createdAt));
+    && Number.isFinite(Date.parse(item.createdAt))
+    && (item.priority === undefined || (typeof item.priority === 'number' && Number.isInteger(item.priority) && item.priority >= 0))
+    && (item.dueAt === undefined || (typeof item.dueAt === 'string' && Number.isFinite(Date.parse(item.dueAt))));
 }
 
 /** Missing files are empty; malformed lines are skipped and returned for observation. */
@@ -67,13 +71,14 @@ export function writePersonaTodos(dir: string, personaId: string, todos: readonl
   writeFileSync(path, todos.map(todo => JSON.stringify(todo)).join('\n') + (todos.length ? '\n' : ''), 'utf8');
 }
 
-/** Earliest created open item; original order breaks equal-timestamp ties. */
+/** Higher priority first, then earlier deadline, then earlier creation; file order breaks ties. */
+export function orderedPersonaTodos(todos: readonly PersonaTodo[]): PersonaTodo[] {
+  return [...todos].filter((todo) => todo.status === 'open').sort((a, b) =>
+    (b.priority ?? 0) - (a.priority ?? 0)
+    || (a.dueAt && b.dueAt ? Date.parse(a.dueAt) - Date.parse(b.dueAt) : a.dueAt ? -1 : b.dueAt ? 1 : 0)
+    || Date.parse(a.createdAt) - Date.parse(b.createdAt));
+}
+
 export function nextPersonaTodo(todos: readonly PersonaTodo[]): PersonaTodo | null {
-  let oldest: PersonaTodo | null = null;
-  for (const todo of todos) {
-    if (todo.status === 'open' && (!oldest || Date.parse(todo.createdAt) < Date.parse(oldest.createdAt))) {
-      oldest = todo;
-    }
-  }
-  return oldest;
+  return orderedPersonaTodos(todos)[0] ?? null;
 }

package/src/persona/presets.ts

@@ -88,6 +88,7 @@ export function presetToProfileYaml(p: PersonaPreset, common: PresetCommon, opts
     displayName: opts.name?.trim() ? `${opts.name.trim()} · ${p.role}` : p.displayName,
     description: p.oneLine,
     systemPrompt: presetSystemPrompt(p, common, name),
+    todo: `${opts.personaId}.todo.jsonl`,
     preset: { id: p.personaId, role: p.role, ...(title ? { title } : {}), tools: p.tools.map((t) => t.name), firstQuestions: p.firstQuestions },
   };
   return `# 프리셋 «${p.personaId}» 에서 만든 페르소나 — elanous persona add (원본: persona-presets/${p.personaId}.yaml)\n${stringify(profile, { lineWidth: 0 })}`;
@@ -99,7 +100,7 @@ export interface PersonaWriteResult { personaId: string; displayName: string; pa
 // Only fields in the runtime persona schema may be edited; provenance (`preset`) is retained, not editable.
 const PROFILE_KEYS = new Set([
   'personaId', 'displayName', 'description', 'systemPrompt', 'actionHosts', 'offsiteNavigation',
-  'brand', 'models', 'mentionPatterns', 'avatarUrl', 'brandColor', 'browserPort', 'residence', 'capabilities',
+  'brand', 'models', 'mentionPatterns', 'avatarUrl', 'brandColor', 'browserPort', 'residence', 'capabilities', 'todo',
 ]);
 const NESTED_KEYS: Record<string, readonly string[]> = {
   models: ['primary', 'fallback', 'providers'], 'models.providers': ['ollama', 'openai'],
@@ -111,11 +112,18 @@ function mapping(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
+export class UnknownPersonaSchemaKeyError extends Error {
+  constructor(key: string) {
+    super(`unknown persona schema key: ${key}`);
+    this.name = 'UnknownPersonaSchemaKeyError';
+  }
+}
+
 function assertSchemaKeys(value: Record<string, unknown>, parent = ''): void {
   const allowed: ReadonlySet<string> = parent ? new Set(NESTED_KEYS[parent] ?? []) : PROFILE_KEYS;
   for (const [key, child] of Object.entries(value)) {
     if (!allowed.has(key)) {
-      throw new Error(`unknown persona schema key: ${parent ? `${parent}.` : ''}${key}`);
+      throw new UnknownPersonaSchemaKeyError(`${parent ? `${parent}.` : ''}${key}`);
     }
     const path = parent ? `${parent}.${key}` : key;
     if (NESTED_KEYS[path] && mapping(child)) assertSchemaKeys(child, path);

package/src/persona/team.ts

@@ -0,0 +1,105 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { parseDocument } from 'yaml';
+import { parsePersonaYaml } from './loader.js';
+
+export interface TeamMember {
+  persona: string;
+  title: string;
+  checklistTemplate: string[];
+}
+
+export interface TeamHandoff {
+  from: string;
+  to: string;
+}
+
+export interface TeamDefinition {
+  name: string;
+  members: TeamMember[];
+  handoffs: TeamHandoff[];
+}
+
+function mapping(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function fields(value: Record<string, unknown>, required: readonly string[], label: string): void {
+  for (const key of required) {
+    if (!Object.hasOwn(value, key)) throw new Error(`${label}.${key} is required`);
+  }
+  for (const key of Object.keys(value)) {
+    if (!required.includes(key)) throw new Error(`${label}.${key} is not a team schema field`);
+  }
+}
+
+function text(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${label} must be a non-empty string`);
+  return value;
+}
+
+/** Read-only validation: resolve persona paths relative to the team file, not the caller's cwd. */
+export function validateTeamFile(file: string): TeamDefinition {
+  const document = parseDocument(readFileSync(file, 'utf8'), { uniqueKeys: true });
+  if (document.errors.length) throw new Error(`invalid team YAML: ${document.errors[0]!.message}`);
+  const raw: unknown = document.toJS();
+  if (!mapping(raw)) throw new Error('team must be a YAML mapping');
+  fields(raw, ['name', 'members', 'handoffs'], 'team');
+  const name = text(raw.name, 'team.name');
+  if (!Array.isArray(raw.members) || raw.members.length === 0) {
+    throw new Error('team.members must be a non-empty list');
+  }
+  const titles = new Set<string>();
+  const personaIds = new Set<string>();
+  const members: TeamMember[] = raw.members.map((item: unknown, index: number) => {
+    const label = `team.members[${index}]`;
+    if (!mapping(item)) throw new Error(`${label} must be a mapping`);
+    fields(item, ['persona', 'title', 'checklistTemplate'], label);
+    const persona = text(item.persona, `${label}.persona`);
+    const title = text(item.title, `${label}.title`);
+    if (titles.has(title)) throw new Error(`duplicate team title: ${title}`);
+    titles.add(title);
+    if (!Array.isArray(item.checklistTemplate) || item.checklistTemplate.length === 0) {
+      throw new Error(`${label}.checklistTemplate must be a non-empty list of strings`);
+    }
+    const checklistTemplate = item.checklistTemplate.map((entry: unknown) => text(entry, `${label}.checklistTemplate item`));
+    const personaPath = resolve(dirname(file), persona);
+    let yaml: string;
+    try {
+      yaml = readFileSync(personaPath, 'utf8');
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') throw new Error(`persona not found: ${persona} (${title})`);
+      throw error;
+    }
+    const parsed = parsePersonaYaml(yaml, personaPath);
+    if (!parsed.ok) throw new Error(`invalid persona ${persona}: ${parsed.error.message}`);
+    if (parsed.profile.seat !== title) throw new Error(`persona seat mismatch: ${persona} requires seat ${title}`);
+    if (personaIds.has(parsed.profile.personaId)) throw new Error(`duplicate personaId: ${parsed.profile.personaId}`);
+    personaIds.add(parsed.profile.personaId);
+    return { persona, title, checklistTemplate };
+  });
+  if (!Array.isArray(raw.handoffs)) throw new Error('team.handoffs must be a list');
+  const handoffs: TeamHandoff[] = raw.handoffs.map((item: unknown, index: number) => {
+    const label = `team.handoffs[${index}]`;
+    if (!mapping(item)) throw new Error(`${label} must be a mapping`);
+    fields(item, ['from', 'to'], label);
+    const from = text(item.from, `${label}.from`);
+    const to = text(item.to, `${label}.to`);
+    if (!titles.has(from) || !titles.has(to)) throw new Error(`handoff references missing title: ${from} -> ${to}`);
+    return { from, to };
+  });
+  const edges = new Map([...titles].map((title) => [title, [] as string[]]));
+  for (const { from, to } of handoffs) edges.get(from)!.push(to);
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const visit = (title: string): void => {
+    if (visiting.has(title)) throw new Error(`handoff cycle at ${title}`);
+    if (visited.has(title)) return;
+    visiting.add(title);
+    for (const next of edges.get(title)!) visit(next);
+    visiting.delete(title);
+    visited.add(title);
+  };
+  for (const title of titles) visit(title);
+  return { name, members, handoffs };
+}

package/src/persona/types.ts

@@ -19,6 +19,10 @@ export type PersonaBrand =
 export interface PersonaProfile {
   readonly personaId: string;
   readonly displayName: string;
+  /** Seat address (title, id or alias) represented by this persona. */
+  readonly seat?: string;
+  /** Per-persona JSONL todo filename in the state persona directory. */
+  readonly todo?: string;
   readonly description?: string;
 
   /** System prompt to prepend in LLM calls. Markdown text. May

package/src/plugins/maker/market-bundle.ts

@@ -17,7 +17,8 @@ function packageFiles(dir: string, prefix = ''): string[] {
   const files: string[] = [];
   for (const entry of readdirSync(join(dir, prefix), { withFileTypes: true })) {
     const path = prefix ? `${prefix}/${entry.name}` : entry.name;
-    if (entry.name === '.git' || entry.name === '.elanous' || entry.name === 'node_modules') continue;
+    if (entry.name === '.git' || entry.name === '.elanous' || entry.name === '.elanous-local' ||
+      entry.name === '.elanous-test' || entry.name === 'graph-runs' || entry.name === 'node_modules') continue;
     if (entry.isSymbolicLink() || (!entry.isFile() && !entry.isDirectory())) throw new Error(`unsafe market bundle entry: ${path}`);
     if (entry.isDirectory()) files.push(...packageFiles(dir, path));
     else files.push(path);