elanous 0.2.0 → 0.2.5

package/src/loops/registry.ts

@@ -0,0 +1,196 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import type { Database } from 'bun:sqlite';
+import { debug } from '../debug/log.js';
+import { emitDecision } from '../live/detail-switch.js';
+import { cronMatches } from '../domains/cron-match.js';
+import { resolveTimeZone } from '../time/format.js';
+import { inventoryCrontab, listSchedules, openSchedulesDb, type ScheduleRow } from '../domains/schedule-registry.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { runGraph, type GraphRunState } from '../graph-runner/runner.js';
+
+export interface LoopRun {
+  at: string;
+  status: GraphRunState['status'];
+  path: string;
+  runId: string;
+  failedNodes: string[];
+  durationMs: number | null;
+}
+export interface LoopEntry {
+  id: string;
+  title: string;
+  description: string | null;
+  file: string;
+  trigger: { cron: string | null; events: string[] };
+  jobs: Array<{ id: string; cron: string | null; enabled: boolean }>;
+  enabled: boolean;
+  lastRun: LoopRun | null;
+  nextRun: string | null;
+}
+export interface LoopRegistryOptions {
+  root?: string;
+  stateRoot?: string;
+  now?: Date;
+  /** An already-inventoried registry; keeps focused tests isolated. */
+  schedules?: ScheduleRow[];
+  scheduleAction?: (action: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => Promise<unknown>;
+}
+
+function graphFiles(dir: string): string[] {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return entries.flatMap(e => e.isDirectory() ? graphFiles(join(dir, e.name)) : e.isFile() && /\.ya?ml$/.test(e.name) ? [join(dir, e.name)] : []).sort();
+}
+
+/** A wrapper cron that runs the graph itself declares its loop with a trailing `# elanous-loop=<graph_id>` comment. */
+const LOOP_MARKER = /#\s*elanous-loop=([A-Za-z0-9][\w.-]*)\s*$/;
+
+/** Match only the actual graph CLI invocation, not a filename mentioned in a shell argument. */
+export function graphJobMatches(command: string | null, file: string, root: string, graphId?: string): boolean {
+  if (!command) return false;
+  if (graphId && command.match(LOOP_MARKER)?.[1] === graphId) return true;
+  const invocation = /(?:^|&&\s*|;\s*)(?:(?:\S*\/)?(?:bun|node)\s+(?:\S*\/)?bin\/elanous\.mjs|(?:\S*\/)?elanous)\s+(?:--test(?:=\S+|\s+\S+)\s+)?graph\s+run\s+(['"]?)([^\s'";&|]+)\1(?=\s|$|[;&|])/g;
+  for (const match of command.matchAll(invocation)) {
+    const arg = match[2]!;
+    if (resolve(root, arg) === file || (isAbsolute(arg) && resolve(arg) === file)) return true;
+  }
+  return false;
+}
+
+function recentRuns(id: string, stateRoot: string, count = 5): LoopRun[] {
+  const dir = join(stateRoot, 'graph-runs', id);
+  let files: string[];
+  try { files = readdirSync(dir).filter(f => f.endsWith('.json') && !f.endsWith('.decision.json')); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return files.map(file => ({ file, at: statSync(join(dir, file)).mtimeMs }))
+    .sort((a, b) => b.at - a.at).slice(0, count).map(({ file, at }) => {
+      const path = join(dir, file);
+      const state = JSON.parse(readFileSync(path, 'utf8')) as GraphRunState;
+      if (state.graphId !== id) throw new Error(`graph run identity mismatch: ${path}`);
+      const start = state.startedAt ? Date.parse(state.startedAt) : NaN;
+      const end = state.finishedAt ? Date.parse(state.finishedAt) : NaN;
+      return { at: state.startedAt ?? new Date(at).toISOString(), status: state.status, path, runId: state.runId,
+        failedNodes: state.nodes.filter(n => !n.ok || !!n.error).map(n => n.nodeId),
+        durationMs: Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : null };
+    });
+}
+
+export function nextLoopFire(cron: string, now: Date): string | null {
+  if (cron.trim().split(/\s+/).length !== 5) return null;
+  let minute = Math.floor(now.getTime() / 60000) * 60000 + 60000;
+  const timeZone = resolveTimeZone().timeZone;
+  // Covers leap years and annual cron expressions; a nonmatching expression stays unknown.
+  for (let i = 0; i < 527040; i++, minute += 60000) {
+    if (cronMatches(cron, new Date(minute), { timeZone })) return new Date(minute).toISOString();
+  }
+  return null;
+}
+
+function schedules(opts: LoopRegistryOptions): ScheduleRow[] {
+  if (opts.schedules) return opts.schedules;
+  const db: Database = openSchedulesDb();
+  try {
+    inventoryCrontab(db);
+    return listSchedules(db);
+  } finally { db.close(); }
+}
+
+/** Where loop graphs live and where their cron line `cd`s — the same rule as the other elanous crons:
+ *  the installed package when there is one, else this checkout. Never the caller's cwd: a loop started
+ *  from a disposable worktree would schedule a cron into a directory that is about to disappear (🅣 09-29). */
+export function defaultLoopRoot(): string {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { installedCronRoot, repoRoot } = require('../domains/schedule-registry.js') as typeof import('../domains/schedule-registry.js');
+  return installedCronRoot() ?? repoRoot();
+}
+
+export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
+  const root = resolve(opts.root ?? defaultLoopRoot());
+  const stateRoot = opts.stateRoot ?? effectiveInstanceRoot();
+  const rows = schedules(opts);
+  const loops: LoopEntry[] = [];
+  for (const file of graphFiles(join(root, 'graphs'))) {
+    let doc: Record<string, unknown> | null;
+    try { doc = parseYaml(readFileSync(file, 'utf8')) as Record<string, unknown> | null; }
+    catch (error) {
+      debug.log('loops.registry', 'graph-read-failed', { file, error: String(error) });
+      continue;
+    }
+    if (!doc || typeof doc !== 'object' || Array.isArray(doc) || typeof doc.graph_id !== 'string' || !doc.graph_id) continue;
+    const header = doc.loop && typeof doc.loop === 'object' && !Array.isArray(doc.loop) ? doc.loop as Record<string, unknown> : null;
+    const trigger = header?.trigger && typeof header.trigger === 'object' && !Array.isArray(header.trigger) ? header.trigger as Record<string, unknown> : null;
+    const declaredCron = typeof trigger?.cron === 'string' ? trigger.cron : null;
+    const events = Array.isArray(trigger?.events) ? trigger.events.filter((e): e is string => typeof e === 'string') : [];
+    const matched = rows.filter(row => graphJobMatches(row.command, file, root, doc.graph_id as string) && row.source === 'crontab' && row.run_via === 'crontab' && row.disabled_reason !== 'vanished');
+    if (!declaredCron && !events.length && !matched.length) continue;
+    if (!/^[a-zA-Z0-9][\w.-]*$/.test(doc.graph_id)) throw new Error(`unsafe loop graph_id: ${doc.graph_id}`);
+    if (loops.some(loop => loop.id === doc.graph_id)) throw new Error(`duplicate loop graph_id: ${doc.graph_id}`);
+    const jobs = matched.map(row => ({ id: row.id, cron: row.cron, enabled: !!row.enabled }));
+    const active = matched.filter(row => !!row.enabled && !!row.cron);
+    const next = active.map(row => nextLoopFire(row.cron!, opts.now ?? new Date())).filter((v): v is string => v !== null).sort()[0] ?? null;
+    const entry: LoopEntry = { id: doc.graph_id, title: typeof header?.title === 'string' ? header.title : doc.graph_id,
+      description: typeof header?.description === 'string' ? header.description : null, file: relative(root, file),
+      trigger: { cron: declaredCron, events }, jobs, enabled: matched.some(row => !!row.enabled),
+      lastRun: recentRuns(doc.graph_id, stateRoot, 1)[0] ?? null, nextRun: next };
+    loops.push(entry);
+  }
+  debug.log('loops.registry', 'list', { count: loops.length });
+  return loops;
+}
+
+export function loopStatus(id: string, opts: LoopRegistryOptions = {}): LoopEntry & { recentRuns: LoopRun[] } {
+  const loop = listLoops(opts).find(entry => entry.id === id);
+  if (!loop) throw new Error(`loop not found: ${id}`);
+  const recent = recentRuns(id, opts.stateRoot ?? effectiveInstanceRoot());
+  debug.log('loops.registry', 'status', { id, runs: recent.length });
+  return { ...loop, recentRuns: recent };
+}
+
+/** The crontab line a loop runs — same shape as the other elanous crons: cron starts in $HOME with a thin PATH,
+ *  so a bare `elanous graph run <relative file>` fails silently every tick (09-29 steward). */
+export function loopCronCommand(id: string, file: string, root: string, bun = process.execPath): string {
+  // Quote only when needed: the other crons (and `graphJobMatches`) use bare absolute paths.
+  const q = (value: string) => /^[\w./@+-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+  const log = `/tmp/elanous-loop-${id.replace(/[^\w.-]/g, '_')}.log`;
+  return `cd ${q(root)} && ${q(bun)} bin/elanous.mjs graph run ${q(file)} >> ${log} 2>&1`;
+}
+
+export async function setLoopEnabled(id: string, enabled: boolean, yes = false, opts: LoopRegistryOptions = {}): Promise<unknown> {
+  const loop = loopStatus(id, opts);
+  const action = enabled ? 'start' : 'stop';
+  if (!loop.jobs.length && (!enabled || !loop.trigger.cron)) throw new Error(`loop ${id} has no cron job to ${action}`);
+  const pending = loop.jobs.filter(job => job.enabled !== enabled);
+  if (!pending.length && loop.jobs.length) return { action, id, changed: false, enabled: loop.enabled };
+  const changes = loop.jobs.length ? pending.map(job => ({ action: enabled ? 'enable' : 'disable', id: job.id })) :
+    [{ action: 'create', cron: loop.trigger.cron, command: loopCronCommand(id, loop.file, resolve(opts.root ?? defaultLoopRoot())) }];
+  if (!yes) return { action, id, dryRun: true, changes, note: 'Apply with --yes (crontab backup).' };
+  const dispatch = opts.scheduleAction ?? (async (kind: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => {
+    const { dispatchScheduleManage } = await import('../domains/schedule-manage-tool.js');
+    return dispatchScheduleManage({ action: kind, ...args });
+  });
+  const results = [];
+  for (const change of changes) {
+    const { action: kind, ...args } = change;
+    const result = await dispatch(kind as 'create' | 'enable' | 'disable', args);
+    if (result && typeof result === 'object' && 'error' in result) throw new Error(String(result.error));
+    results.push(result);
+  }
+  debug.log('loops.registry', action, { id, changes });
+  emitDecision({ kind: 'ROUTE', what: `루프 ${enabled ? '켬' : '끔'}: ${id}`, reason: enabled ? '사용자 요청으로 예약 발화 활성화' : '사용자 요청으로 예약 발화 일시 중지', purpose: '루프 라이프사이클 제어', target: id });
+  return { action, id, changed: true, results };
+}
+
+export async function runLoop(id: string, dryRun = false, opts: LoopRegistryOptions = {}): Promise<GraphRunState> {
+  const loop = loopStatus(id, opts);
+  debug.log('loops.registry', 'run', { id, dryRun });
+  return runGraph(join(resolve(opts.root ?? defaultLoopRoot()), loop.file), { dryRun, deps: { root: opts.stateRoot ?? effectiveInstanceRoot() } });
+}

package/src/market/official-keys.ts

@@ -0,0 +1,5 @@
+/** Public keys that sign the official Elanous marketplace index (signed-index SPEC §3). The private key stays offline
+ *  on the owner's machine. Clients trust these by default; `market.trustedKeys` in config may add keys (rotation overlap). */
+export const OFFICIAL_INDEX_KEYS: ReadonlyArray<{ keyId: string; publicKey: string }> = [
+  { keyId: '4d809b69', publicKey: 'iNHq4yuuJNuB6BSDyAZhcYvaGTImtOGfbIPGUg4EbNQ=' },
+];

package/src/market/publish.ts

@@ -0,0 +1,329 @@
+import { createHash, createPublicKey } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, isAbsolute, join, posix, relative, resolve } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { parse as parseYaml } from 'yaml';
+import { debug } from '../debug/log.js';
+import { packDirDeterministic } from './tgz.js';
+import { signIndex, verifyIndex, type MarketplaceIndex } from './signed-index.js';
+
+type IndexConnector = MarketplaceIndex['plugins'][number]['ai.elanous']['connectors'][number];
+
+function normalizeConnectors(connectors: unknown): { ok: true; value: IndexConnector[] } | { ok: false } {
+  if (!Array.isArray(connectors)) return { ok: false };
+  const value: IndexConnector[] = [];
+  const record = (item: unknown): item is Record<string, unknown> =>
+    item !== null && typeof item === 'object' && !Array.isArray(item);
+  for (const connector of connectors) {
+    if (!record(connector) || typeof connector.id !== 'string' || !connector.id) return { ok: false };
+    if (Array.isArray(connector.userConfig)) {
+      if (typeof connector.kind !== 'string' || !connector.userConfig.every((field: unknown) =>
+        record(field) && typeof field.key === 'string' && field.key.trim().length > 0 && typeof field.label === 'string' &&
+        typeof field.secret === 'boolean' && (field.env === undefined || typeof field.env === 'string'))) {
+        return { ok: false };
+      }
+      value.push(connector as IndexConnector);
+    } else if (Array.isArray(connector.fields)) {
+      if ((connector.kind !== undefined && typeof connector.kind !== 'string') || !connector.fields.every((field: unknown) =>
+        record(field) && typeof field.name === 'string' && field.name.trim().length > 0 && typeof field.secret === 'boolean' &&
+        (field.label === undefined || typeof field.label === 'string') &&
+        (field.env === undefined || typeof field.env === 'string'))) {
+        return { ok: false };
+      }
+      value.push({ id: connector.id, kind: (connector.kind ?? 'credentials') as string,
+        userConfig: connector.fields.map((field: Record<string, unknown>) => ({
+          key: field.name as string, label: (field.label ?? field.name) as string, secret: field.secret === true,
+          ...(field.env ? { env: field.env as string } : {}),
+        })) });
+    } else {
+      return { ok: false };
+    }
+  }
+  return { ok: true, value };
+}
+
+function unpackLocal(archive: Uint8Array, destination: string): void {
+  const tar = gunzipSync(archive);
+  const field = (part: Buffer) => part.toString('utf8').replace(/\0.*$/, '');
+  for (let offset = 0; offset + 512 <= tar.length;) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every(byte => byte === 0)) break;
+    const size = parseInt(field(header.subarray(124, 136)).trim(), 8);
+    const name = field(header.subarray(0, 100));
+    const prefix = field(header.subarray(345, 500));
+    const path = prefix ? `${prefix}/${name}` : name;
+    if (!Number.isSafeInteger(size) || size < 0 || !path || path.split('/').some(part => !part || part === '.' || part === '..') ||
+        header[156] !== 48 || offset + 512 + size > tar.length) throw new Error('invalid packed archive');
+    const file = join(destination, path);
+    mkdirSync(join(file, '..'), { recursive: true });
+    writeFileSync(file, tar.subarray(offset + 512, offset + 512 + size),
+      { mode: parseInt(field(header.subarray(100, 108)).trim(), 8) });
+    offset += 512 + Math.ceil(size / 512) * 512;
+  }
+}
+
+export interface PublishResult {
+  ok: boolean;
+  sequence: number;
+  published: Array<{ name: string; version: string; sha256: string; bundled: string[] }>;
+  skipped: Array<{ dir: string; reason: string }>;
+  /** Published anyway, but a reviewer should look (e.g. a third-party graph relying on core recipes). */
+  warnings: Array<{ dir: string; graph: string; reason: 'third-party-core-recipe'; recipes: string[] }>;
+}
+
+export function publishMarket(input: {
+  pluginsDir: string;
+  bundleRoot?: string;
+  outDir: string;
+  market: { name: string; displayName: string };
+  key: { keyId: string; privateKeyPem: string };
+  source?: { repoUrl: string; sha: string; basePath: string };
+  now?: Date;
+}): PublishResult {
+  let sequence = 1;
+  let currentName: string | undefined;
+  let currentVersion: string | undefined;
+  try {
+    const indexPath = join(input.outDir, 'marketplace.json');
+    const previous: MarketplaceIndex | undefined = existsSync(indexPath) ? JSON.parse(readFileSync(indexPath, 'utf8')) : undefined;
+    if (previous) {
+      if (!Number.isSafeInteger(previous.sequence) || previous.sequence < 0 || !Array.isArray(previous.plugins)) throw new Error('invalid previous marketplace.json');
+      sequence = previous.sequence + 1;
+    }
+    // The public index describes the current catalog, not every version ever published.
+    const historyPath = join(input.outDir, '.publication-history.json');
+    const history: Array<{ name: string; version: string; sha256: string }> = existsSync(historyPath)
+      ? JSON.parse(readFileSync(historyPath, 'utf8')) : [];
+    if (!Array.isArray(history) || history.some(item => !item || typeof item.name !== 'string' ||
+        typeof item.version !== 'string' || typeof item.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(item.sha256))) {
+      throw new Error('invalid publication history');
+    }
+    if (!existsSync(historyPath) && previous && previous.sequence > 1) {
+      throw new Error('missing publication history: cannot prove version immutability');
+    }
+    const recordedHashes = new Map<string, string>();
+    const remember = (name: string, version: string, sha256: string) => {
+      const identity = JSON.stringify([name, version]);
+      const recorded = recordedHashes.get(identity);
+      if (recorded && recorded !== sha256) throw new Error(`version-immutable: ${name}@${version}`);
+      if (!recorded) {
+        recordedHashes.set(identity, sha256);
+        history.push({ name, version, sha256 });
+      }
+    };
+    const saved = history.splice(0);
+    for (const item of saved) remember(item.name, item.version, item.sha256);
+    for (const item of previous?.plugins ?? []) {
+      if (!item.artifact || typeof item.artifact.sha256 !== 'string') throw new Error('invalid previous marketplace.json');
+      remember(item.name, item.version, item.artifact.sha256);
+    }
+    const published: PublishResult['published'] = [];
+    const skipped: PublishResult['skipped'] = [];
+    const warnings: PublishResult['warnings'] = [];
+    const plugins: MarketplaceIndex['plugins'] = [];
+    const archives: Array<{ key: string; data: Uint8Array; name: string }> = [];
+    for (const dir of readdirSync(input.pluginsDir).sort()) {
+      const folder = join(input.pluginsDir, dir);
+      if (!lstatSync(folder).isDirectory()) continue;
+      currentName = dir;
+      currentVersion = undefined;
+      const manifestPath = join(folder, 'plugin.json');
+      const skip = (reason: string) => {
+        skipped.push({ dir, reason });
+        debug.log('market.publish', 'skipped', { name: dir, version: currentVersion, sequence, reason });
+      };
+      if (!existsSync(manifestPath)) { skip('missing-plugin.json'); continue; }
+      let manifest: Record<string, unknown>;
+      try { manifest = JSON.parse(readFileSync(manifestPath, 'utf8')); }
+      catch { skip('invalid-plugin.json'); continue; }
+      const ai = manifest?.extensions && typeof manifest.extensions === 'object'
+        ? (manifest.extensions as Record<string, unknown>)['ai.elanous'] : undefined;
+      if (!manifest || typeof manifest.name !== 'string' || typeof manifest.version !== 'string' ||
+          typeof manifest.description !== 'string' || !ai || typeof ai !== 'object' || Array.isArray(ai)) {
+        skip('invalid-plugin.json'); continue;
+      }
+      currentVersion = manifest.version;
+      if (!/^[a-z0-9-]{2,40}$/.test(manifest.name) || manifest.name !== dir ||
+          !/^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][a-zA-Z0-9.-]+)?$/.test(manifest.version)) {
+        skip('invalid-plugin.json'); continue;
+      }
+      const { category, bundle, ...metadata } = ai as MarketplaceIndex['plugins'][number]['ai.elanous'] & { category?: string; bundle?: unknown };
+      if (!Array.isArray(metadata.capabilities) ||
+          (category !== undefined && typeof category !== 'string')) {
+        skip('invalid-plugin.json'); continue;
+      }
+      if (metadata.pricing !== undefined && metadata.pricing?.model !== 'free') {
+        skip('paid-not-allowed-in-M0'); continue;
+      }
+      const normalized = normalizeConnectors(metadata.connectors);
+      if (!normalized.ok) { skip('invalid-connectors'); continue; }
+      const bundleItem = (item: unknown): item is string | { from: string; as: string } => typeof item === 'string' ||
+        (!!item && typeof item === 'object' && !Array.isArray(item) && typeof (item as { from?: unknown }).from === 'string' &&
+          typeof (item as { as?: unknown }).as === 'string');
+      if (bundle !== undefined && (!Array.isArray(bundle) || !bundle.every(bundleItem))) {
+        skip('invalid-plugin.json'); continue;
+      }
+      const extraDirs: Array<{ from: string; as: string }> = [];
+      const bundled: string[] = [];
+      let bundleError: string | undefined;
+      if (bundle !== undefined && !input.bundleRoot) bundleError = 'bundle-root-missing';
+      if (bundle !== undefined && input.bundleRoot) {
+        const root = realpathSync(input.bundleRoot);
+        const inside = (path: string) => {
+          const rel = relative(root, path);
+          return rel !== '..' && !rel.startsWith(`..${posix.sep}`) && !isAbsolute(rel);
+        };
+        for (const entry of bundle as Array<string | { from: string; as: string }>) {
+          // A string names a skill folder (skills/<name>); { from, as } places any file or folder at `as`.
+          const item = typeof entry === 'string' ? entry : entry.from;
+          const candidate = resolve(root, item);
+          if (isAbsolute(item) || !inside(candidate)) { bundleError = 'bundle-path-outside-root'; break; }
+          if (!existsSync(candidate)) { bundleError = 'bundle-missing'; break; }
+          const from = realpathSync(candidate);
+          if (!inside(from)) { bundleError = 'bundle-path-outside-root'; break; }
+          if (typeof entry !== 'string') {
+            const stat = lstatSync(from);
+            if (stat.isFile()) { extraDirs.push({ from, as: entry.as }); bundled.push(entry.as); continue; }
+            if (!stat.isDirectory()) { bundleError = 'bundle-missing'; break; }
+          } else if (!lstatSync(from).isDirectory()) { bundleError = 'bundle-missing'; break; }
+          const checkContents = (path: string): boolean => readdirSync(path).every(name => {
+            const child = join(path, name);
+            const stat = lstatSync(child);
+            if (stat.isSymbolicLink()) return false;
+            const real = realpathSync(child);
+            if (!inside(real)) return false;
+            return !stat.isDirectory() || checkContents(child);
+          });
+          if (!checkContents(from)) { bundleError = 'bundle-path-outside-root'; break; }
+          if (typeof entry !== 'string') { extraDirs.push({ from, as: entry.as }); bundled.push(entry.as); continue; }
+          if (!['SKILL.md', 'skill.md'].some(file => {
+            const skill = join(from, file);
+            return existsSync(skill) && lstatSync(skill).isFile();
+          })) {
+            bundleError = 'bundle-not-a-skill'; break;
+          }
+          const name = basename(candidate);
+          extraDirs.push({ from, as: `skills/${name}` });
+          bundled.push(name);
+        }
+      }
+      // The loader registers only graphs listed in the manifest, so each listed path must ship in the package.
+      if (!bundleError && Array.isArray(metadata.graphs) && !metadata.graphs.every(graph => typeof graph === 'string' &&
+          (existsSync(join(folder, graph)) || extraDirs.some(extra => graph === extra.as || graph.startsWith(`${extra.as}/`))))) {
+        bundleError = 'graph-missing';
+      }
+      if (bundleError) { skip(bundleError); continue; }
+      // Third-party graphs may only use their own recipes (graphs/…/recipes.yaml next to the graph) or custom nodes;
+      // leaning on core code recipes is published but flagged. First-party packs may point at core recipes.
+      if ((ai as { trust?: unknown }).trust !== 'official' && Array.isArray(metadata.graphs)) {
+        const packagePath = (path: string): string | null => {
+          if (existsSync(join(folder, path))) return join(folder, path);
+          const extra = extraDirs.find(item => path === item.as || path.startsWith(`${item.as}/`));
+          return extra ? join(extra.from, path.slice(extra.as.length)) : null;
+        };
+        for (const graph of metadata.graphs) {
+          try {
+            const source = packagePath(graph);
+            if (!source || !lstatSync(source).isFile()) continue;
+            const spec = parseYaml(readFileSync(source, 'utf8')) as { nodes?: Array<{ recipe?: unknown }> } | null;
+            const recipesFile = packagePath(posix.join(posix.dirname(graph), 'recipes.yaml'));
+            const own = recipesFile && existsSync(recipesFile)
+              ? new Set(Object.keys((parseYaml(readFileSync(recipesFile, 'utf8')) as Record<string, unknown> | null) ?? {})) : new Set<string>();
+            const foreign = [...new Set((spec?.nodes ?? []).map(node => node?.recipe)
+              .filter((recipe): recipe is string => typeof recipe === 'string' && !own.has(recipe)))].sort();
+            if (foreign.length) {
+              warnings.push({ dir, graph, reason: 'third-party-core-recipe', recipes: foreign });
+              debug.log('market.publish', 'warning', { name: manifest.name, version: manifest.version, sequence, reason: 'third-party-core-recipe', graph, recipes: foreign });
+            }
+          } catch { /* A graph that cannot be read is the loader's validation error, not a publish warning. */ }
+        }
+      }
+      let archive: Uint8Array;
+      try { archive = packDirDeterministic(folder, { extraDirs }); }
+      catch (error) {
+        const message = error instanceof Error ? error.message : '';
+        if (message.startsWith('bundle-conflict')) { skip('bundle-conflict'); continue; }
+        throw error;
+      }
+      let sha256 = createHash('sha256').update(archive).digest('hex');
+      const recorded = recordedHashes.get(JSON.stringify([manifest.name, manifest.version]));
+      if (recorded && recorded !== sha256) {
+        const existingPath = join(input.outDir, manifest.name, manifest.version, `${recorded}.tgz`);
+        let sameContent = false;
+        if (existsSync(existingPath)) {
+          try {
+            const existing = readFileSync(existingPath);
+            sameContent = createHash('sha256').update(existing).digest('hex') === recorded &&
+              gunzipSync(existing).equals(gunzipSync(archive));
+            if (sameContent) {
+              archive = existing;
+              sha256 = recorded;
+            }
+          } catch { /* An unreadable archive cannot prove immutability. */ }
+        }
+        if (!sameContent) throw new Error(`version-immutable: ${manifest.name}@${manifest.version}`);
+        debug.log('market.publish', 'reused-artifact', { name: manifest.name, version: manifest.version,
+          reason: 'same-content-different-gzip' });
+      }
+      remember(manifest.name, manifest.version, sha256);
+      const key = `${manifest.name}/${manifest.version}/${sha256}.tgz`;
+      const source: MarketplaceIndex['plugins'][number]['source'] = input.source
+        ? { source: 'git-subdir', url: input.source.repoUrl, path: posix.join(input.source.basePath, dir), sha: input.source.sha }
+        : { source: 'local', path: `./plugins/${dir}` };
+      plugins.push({ name: manifest.name, source,
+        policy: { installation: 'AVAILABLE', authentication: 'ON_USE' },
+        category: category ?? 'Productivity', version: manifest.version,
+        description: manifest.description, artifact: { sha256, bytes: archive.length, key },
+        'ai.elanous': { ...metadata, connectors: normalized.value, pricing: metadata.pricing ?? { model: 'free' } },
+      });
+      archives.push({ key, data: archive, name: dir });
+      published.push({ name: manifest.name, version: manifest.version, sha256, bundled });
+      debug.log('market.publish', 'bundled', { name: manifest.name, version: manifest.version, skills: bundled });
+    }
+    const index: MarketplaceIndex = { name: input.market.name, interface: { displayName: input.market.displayName },
+      sequence, generatedAt: (input.now ?? new Date()).toISOString(), plugins };
+    const bytes = Buffer.from(JSON.stringify(index, null, 2) + '\n');
+    let signatureText: string;
+    let publicKey: string;
+    try {
+      signatureText = signIndex(bytes, input.key.privateKeyPem, input.key.keyId);
+      publicKey = createPublicKey(input.key.privateKeyPem).export({ format: 'der', type: 'spki' }).subarray(-32).toString('base64');
+    } catch {
+      throw new Error('invalid signing key');
+    }
+    const trustedKeys = [{ keyId: input.key.keyId, publicKey }];
+    const candidate = verifyIndex({ marketplaceBytes: bytes, signatureText, trustedKeys });
+    if (!candidate.ok) throw new Error(`index verification failed: ${candidate.reason}: ${candidate.detail}`);
+    for (const archive of archives) {
+      const destination = join(input.outDir, archive.key);
+      mkdirSync(join(destination, '..'), { recursive: true });
+      writeFileSync(destination, archive.data);
+      if (!input.source) {
+        const unpacked = join(input.outDir, 'plugins', archive.name);
+        rmSync(unpacked, { recursive: true, force: true });
+        unpackLocal(archive.data, unpacked);
+      }
+    }
+    mkdirSync(input.outDir, { recursive: true });
+    // Preserve the ledger before exposing an index that may later omit these versions.
+    writeFileSync(historyPath, JSON.stringify(history, null, 2) + '\n');
+    writeFileSync(indexPath, bytes);
+    if (!input.source) {
+      const codexIndex = join(input.outDir, '.agents', 'plugins', 'marketplace.json');
+      mkdirSync(join(codexIndex, '..'), { recursive: true });
+      writeFileSync(codexIndex, bytes);
+    }
+    writeFileSync(join(input.outDir, 'index.sig'), signatureText);
+    const verified = verifyIndex({ marketplaceBytes: readFileSync(indexPath),
+      signatureText: readFileSync(join(input.outDir, 'index.sig'), 'utf8'), trustedKeys });
+    if (!verified.ok) throw new Error(`index verification failed: ${verified.reason}: ${verified.detail}`);
+    for (const item of published) debug.log('market.publish', 'published', { name: item.name, version: item.version, sequence });
+    return { ok: true, sequence, published, skipped, warnings };
+  } catch (error) {
+    const rawReason = error instanceof Error ? error.message : 'unknown-error';
+    const reason = input.key.privateKeyPem && rawReason.includes(input.key.privateKeyPem) ? 'invalid signing key' : rawReason;
+    debug.log('market.publish', 'failed', { name: currentName, version: currentVersion, sequence, reason });
+    if (reason.startsWith('version-immutable')) throw new Error(reason);
+    throw new Error(`market publish failed: ${reason}`);
+  }
+}