elanous 0.2.10 → 0.2.12

package/src/outputs/ledger.ts

@@ -0,0 +1,120 @@
+import { appendFileSync, closeSync, mkdirSync, openSync, readFileSync, readdirSync } from 'node:fs';
+import { dlopen, FFIType } from 'bun:ffi';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { OUTPUT_KINDS, type OutputKind } from '../exec-requests/default-outputs.js';
+
+export interface OutputEntry {
+  kind: OutputKind | 'file';
+  title: string;
+  path?: string;
+  url?: string;
+  source: 'exec' | 'field-reel' | 'field-feed';
+  sourceId: string;
+  seat?: string;
+  at: string;
+}
+
+type NewOutput = Omit<OutputEntry, 'at'> & { at?: string };
+const validKinds = new Set<unknown>([...Object.keys(OUTPUT_KINDS), 'file']);
+
+function kstMonth(at: Date): string {
+  return new Date(at.getTime() + 9 * 60 * 60 * 1000).toISOString().slice(0, 7);
+}
+
+function ledgerPath(root: string, month: string): string { return join(root, 'outputs', `outputs-${month}.jsonl`); }
+
+function readEntries(file: string): { entries: OutputEntry[]; newline: boolean } {
+  let text: string;
+  try { text = readFileSync(file, 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { entries: [], newline: true };
+    throw error;
+  }
+  const entries: OutputEntry[] = [];
+  text.split('\n').forEach((line, index) => {
+    if (!line.trim()) return;
+    try {
+      const entry: unknown = JSON.parse(line);
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)
+        || !('source' in entry) || (entry.source !== 'exec' && entry.source !== 'field-reel' && entry.source !== 'field-feed')
+        || !('sourceId' in entry) || typeof entry.sourceId !== 'string' || !entry.sourceId
+        || !('kind' in entry) || !validKinds.has(entry.kind)
+        || !('title' in entry) || typeof entry.title !== 'string' || !entry.title
+        || !('at' in entry) || typeof entry.at !== 'string' || !entry.at
+        || (!('path' in entry) || typeof entry.path !== 'string' || !entry.path)
+          && (!('url' in entry) || typeof entry.url !== 'string' || !entry.url)
+        || ('path' in entry && entry.path !== undefined && typeof entry.path !== 'string')
+        || ('url' in entry && entry.url !== undefined && typeof entry.url !== 'string')
+        || ('seat' in entry && entry.seat !== undefined && typeof entry.seat !== 'string')) throw new Error('invalid output entry');
+      entries.push(entry as OutputEntry);
+    } catch (error) {
+      debug.log('outputs.ledger', 'invalid-line', { line: index + 1, error: String(error) });
+    }
+  });
+  return { entries, newline: !text || text.endsWith('\n') };
+}
+
+// Keep the lock inode in place: unlinking it lets a second writer lock a new inode while the first still holds the old one.
+const flock = dlopen(process.platform === 'darwin' ? 'libSystem.B.dylib' : 'libc.so.6',
+  { flock: { args: [FFIType.int, FFIType.int], returns: FFIType.int } }).symbols.flock;
+function acquireLock(file: string): () => void {
+  const fd = openSync(`${file}.lock`, 'a+', 0o600);
+  const deadline = Date.now() + 5_000;
+  try {
+    while (flock(fd, 2 | 4) !== 0) {
+      if (Date.now() >= deadline) throw new Error('outputs ledger lock timed out');
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  } catch (error) { closeSync(fd); throw error; }
+  return () => { try { flock(fd, 8); } finally { closeSync(fd); } };
+}
+
+/** The optional root keeps writers with an explicitly selected instance in the same universe. */
+export function recordOutput(output: NewOutput, root?: string): void {
+  try {
+    const instanceRoot = root ?? effectiveInstanceRoot();
+    const file = ledgerPath(instanceRoot, kstMonth(new Date()));
+    mkdirSync(join(instanceRoot, 'outputs'), { recursive: true, mode: 0o700 });
+    const release = acquireLock(file);
+    try {
+      const { entries, newline } = readEntries(file);
+      if (entries.some(entry => entry.source === output.source && entry.sourceId === output.sourceId
+        && (entry.path ?? entry.url) === (output.path ?? output.url))) return;
+      appendFileSync(file, `${newline ? '' : '\n'}${JSON.stringify({ ...output, at: output.at ?? new Date().toISOString() })}\n`, { mode: 0o600 });
+      debug.log('outputs.ledger', 'recorded', { source: output.source, kind: output.kind });
+    } finally { release(); }
+  } catch (error) {
+    debug.log('outputs.ledger', 'write-failed', { source: output.source, kind: output.kind, error: String(error) });
+  }
+}
+
+export function listOutputs({ since, source, limit }: { since?: string; source?: OutputEntry['source']; limit?: number } = {}, root = effectiveInstanceRoot()): OutputEntry[] {
+  let months = 0;
+  let rows = 0;
+  const entries: OutputEntry[] = [];
+  const take = (file: string) => {
+    try {
+      const read = readEntries(file).entries;
+      rows += read.length;
+      for (const entry of read) {
+        if ((!since || entry.at >= since) && (!source || entry.source === source)) entries.push(entry);
+      }
+    } catch { /* A damaged month does not hide the other months. */ }
+  };
+  try {
+    const dir = join(root, 'outputs');
+    const files = readdirSync(dir).filter(name => /^outputs-\d{4}-(0[1-9]|1[0-2])\.jsonl$/.test(name)).sort().reverse();
+    // Month names reflect write time, not entry.at; an older file may hold the newest entry.
+    for (const name of files) {
+      take(join(dir, name));
+      months++;
+    }
+    // The unrotated ledger has no month boundary; its rows can be newer than any monthly row.
+    take(join(dir, 'outputs.jsonl'));
+  } catch { /* Missing outputs directory. */ }
+  entries.sort((a, b) => b.at.localeCompare(a.at));
+  debug.log('outputs.ledger', 'rotated-read', { months, rows });
+  return entries.slice(0, limit === undefined ? undefined : Math.max(0, limit));
+}

package/src/persona/persona-todo.ts

@@ -0,0 +1,79 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface PersonaTodo {
+  id: string;
+  title: string;
+  status: 'open' | 'done';
+  createdAt: string;
+}
+
+export interface PersonaTodoReadResult {
+  todos: PersonaTodo[];
+  errors: { line: number; message: string }[];
+}
+
+/** One JSONL file per persona. Reject path components in the id. */
+export function personaTodoPath(dir: string, personaId: string): string {
+  if (!personaId || personaId === '.' || personaId === '..' || /[/\\]/.test(personaId)) {
+    throw new Error('Invalid persona id');
+  }
+  return join(dir, `${personaId}.todo.jsonl`);
+}
+
+function isPersonaTodo(value: unknown): value is PersonaTodo {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const item = value as Record<string, unknown>;
+  return typeof item.id === 'string' && item.id.length > 0
+    && typeof item.title === 'string' && item.title.length > 0
+    && (item.status === 'open' || item.status === 'done')
+    && typeof item.createdAt === 'string'
+    && Number.isFinite(Date.parse(item.createdAt));
+}
+
+/** Missing files are empty; malformed lines are skipped and returned for observation. */
+export function readPersonaTodos(dir: string, personaId: string): PersonaTodoReadResult {
+  const path = personaTodoPath(dir, personaId);
+  let text: string;
+  try {
+    text = readFileSync(path, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { todos: [], errors: [] };
+    throw error;
+  }
+
+  const todos: PersonaTodo[] = [];
+  const errors: PersonaTodoReadResult['errors'] = [];
+  for (const [index, line] of text.split('\n').entries()) {
+    if (!line.trim()) continue;
+    try {
+      const item: unknown = JSON.parse(line);
+      if (!isPersonaTodo(item)) throw new Error('Invalid todo record');
+      todos.push(item);
+    } catch (error) {
+      errors.push({ line: index + 1, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { todos, errors };
+}
+
+/** Replace a persona's JSONL file with one valid record per line. */
+export function writePersonaTodos(dir: string, personaId: string, todos: readonly PersonaTodo[]): void {
+  const path = personaTodoPath(dir, personaId);
+  for (const todo of todos) {
+    if (!isPersonaTodo(todo)) throw new Error('Invalid todo record');
+  }
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path, todos.map(todo => JSON.stringify(todo)).join('\n') + (todos.length ? '\n' : ''), 'utf8');
+}
+
+/** Earliest created open item; original order breaks equal-timestamp ties. */
+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;
+}

package/src/persona/presets.ts

@@ -1,10 +1,12 @@
 // PS1 — 페르소나 프리셋(MK 문면 · persona-presets/<id>.yaml)을 «내 페르소나»로 만든다.
 // 용어: «페르소나»(대표 10-01) — 사용자가 고르고 꾸미는 AI 동료. ⚠️ `SessionSurfaceId`(이름만 Surface 인 캐릭터 축) ·
-// `modelTier.persona`(모델 등급 축)와는 «다른 것»이다 — 여기서 만드는 것은 기존 페르소나 저장소(`resolveStatePersonaDir()`,
+// `modelTier.profile`(모델 등급 프로필 축)와는 «다른 것»이다 — 여기서 만드는 것은 기존 페르소나 저장소(`resolveStatePersonaDir()`,
 // Discord·PWA 가 이미 읽는 `<id>.yaml`)의 한 파일이다. 프리셋 원본은 고치지 않는다.
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { existsSync, linkSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { parse, stringify } from 'yaml';
+import { resolveRepositoryPersonaDir, resolveStatePersonaDir } from './global-registry.js';
+import { parsePersonaYaml } from './loader.js';
 
 export interface PersonaPreset {
   personaId: string;
@@ -91,6 +93,125 @@ export function presetToProfileYaml(p: PersonaPreset, common: PresetCommon, opts
   return `# 프리셋 «${p.personaId}» 에서 만든 페르소나 — elanous persona add (원본: persona-presets/${p.personaId}.yaml)\n${stringify(profile, { lineWidth: 0 })}`;
 }
 
+export interface PersonaWriteOptions { dir?: string; dryRun?: boolean }
+export interface PersonaWriteResult { personaId: string; displayName: string; path: string; yaml: string; dryRun: boolean }
+
+// 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',
+]);
+const NESTED_KEYS: Record<string, readonly string[]> = {
+  models: ['primary', 'fallback', 'providers'], 'models.providers': ['ollama', 'openai'],
+  'models.providers.ollama': ['model'], 'models.providers.openai': ['model'],
+  capabilities: ['core', 'extended', 'evidence'],
+};
+
+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 UnknownPersonaSchemaKeyError(`${parent ? `${parent}.` : ''}${key}`);
+    }
+    const path = parent ? `${parent}.${key}` : key;
+    if (NESTED_KEYS[path] && mapping(child)) assertSchemaKeys(child, path);
+  }
+}
+
+function storedProfiles(dir: string): Array<{ path: string; data: Record<string, unknown> }> {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((file) => file.endsWith('.yaml') && !file.startsWith('_')).map((file) => {
+    const path = join(dir, file);
+    const text = readFileSync(path, 'utf8');
+    const checked = parsePersonaYaml(text, path);
+    if (!checked.ok) throw new Error(`invalid stored persona ${path}: ${checked.error.message}`);
+    const data: unknown = parse(text);
+    if (!mapping(data)) throw new Error(`invalid stored persona ${path}`);
+    return { path, data };
+  });
+}
+
+function normalizedName(name: string): string { return name.trim().toLocaleLowerCase(); }
+function assertUnusedName(name: string, dir: string, except?: string): void {
+  if (!name.trim()) throw new Error('persona name is required');
+  const all = [...storedProfiles(dir), ...(dir === resolveRepositoryPersonaDir() ? [] : storedProfiles(resolveRepositoryPersonaDir()))];
+  if (all.some(({ path, data }) => path !== except &&
+    (normalizedName(String(data.displayName)) === normalizedName(name) || normalizedName(String(data.personaId)) === normalizedName(name)))) {
+    throw new Error(`persona name already exists: ${name}`);
+  }
+}
+
+function checkedYaml(data: Record<string, unknown>, path: string): { yaml: string; personaId: string; displayName: string } {
+  const yaml = stringify(data, { lineWidth: 0 });
+  const check = parsePersonaYaml(yaml, path);
+  if (!check.ok) throw new Error(`invalid persona: ${check.error.message}`);
+  return { yaml, personaId: check.profile.personaId, displayName: check.profile.displayName };
+}
+
+/** Write beside the destination, then atomically replace it (or install a new file without overwriting). */
+function atomicPersonaWrite(path: string, yaml: string, create: boolean): void {
+  const temp = `${path}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, yaml, { flag: 'wx' });
+    if (create) linkSync(temp, path); // atomic, exclusive: concurrent creations cannot replace a persona
+    else renameSync(temp, path);
+  } finally {
+    if (existsSync(temp)) unlinkSync(temp);
+  }
+}
+
+/** Edit a stored persona by exact id or display name; dry-run validates but never creates a directory or file. */
+export function editPersona(name: string, edits: Record<string, unknown>, opts: PersonaWriteOptions = {}): PersonaWriteResult {
+  const dir = opts.dir ?? resolveStatePersonaDir();
+  if (!name.trim()) throw new Error('persona name is required');
+  if (!mapping(edits)) throw new Error('persona edits must be a mapping');
+  assertSchemaKeys(edits);
+  const matches = storedProfiles(dir).filter(({ data }) =>
+    normalizedName(String(data.personaId)) === normalizedName(name) || normalizedName(String(data.displayName)) === normalizedName(name));
+  if (matches.length !== 1) throw new Error(matches.length ? `ambiguous persona name: ${name}` : `persona not found: ${name}`);
+  const { path, data } = matches[0]!;
+  if (edits.personaId !== undefined && edits.personaId !== data.personaId) throw new Error('personaId cannot be changed');
+  const updated = { ...data, ...edits };
+  const result = checkedYaml(updated, path);
+  assertUnusedName(result.displayName, dir, path);
+  if (!opts.dryRun) atomicPersonaWrite(path, result.yaml, false);
+  return { ...result, path, dryRun: Boolean(opts.dryRun) };
+}
+
+/** Clone a shipped preset into the state persona store under a new, unique display name. */
+export function clonePreset(preset: PersonaPreset | string, name: string, opts: PersonaWriteOptions = {}): PersonaWriteResult {
+  const source = typeof preset === 'string' ? findPreset(loadPresets(), preset) : preset;
+  if (!source) throw new Error(`preset not found: ${preset}`);
+  const dir = opts.dir ?? resolveStatePersonaDir();
+  assertUnusedName(name, dir);
+  const taken = new Set([...storedProfiles(dir), ...storedProfiles(resolveRepositoryPersonaDir())]
+    .map(({ data }) => String(data.personaId)));
+  const personaId = choosePersonaId(source, name, taken);
+  const path = join(dir, `${personaId}.yaml`);
+  if (existsSync(path)) throw new Error(`persona already exists: ${personaId}`);
+  const generated = presetToProfileYaml(source, loadPresetIndex().common, { personaId, name });
+  const raw: unknown = parse(generated);
+  if (!mapping(raw)) throw new Error('invalid generated persona');
+  const result = checkedYaml(raw, path);
+  assertUnusedName(result.displayName, dir);
+  if (!opts.dryRun) {
+    mkdirSync(dir, { recursive: true });
+    atomicPersonaWrite(path, generated, true);
+  }
+  return { ...result, yaml: generated, path, dryRun: Boolean(opts.dryRun) };
+}
+
 /** Short block for `persona show` and `persona list`. */
 export function describePreset(p: PersonaPreset): string[] {
   return [

package/src/persona/team-set.ts

@@ -0,0 +1,155 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse, stringify } from 'yaml';
+import { resolveRepositoryPersonaDir, resolveStatePersonaDir } from './global-registry.js';
+import { parsePersonaYaml } from './loader.js';
+
+interface Member { persona: string; title: string; checklistTemplate: string; rules: string[] }
+interface Handoff { from: string; to: string; when: string }
+export interface TeamSet { 'team-set': string; members: Member[]; handoffs: Handoff[] }
+const idPattern = /^[a-z0-9_][a-z0-9_-]*$/i;
+const namePattern = /^[\p{L}\p{N}_][\p{L}\p{N} _-]*$/u;
+const mapping = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value);
+const nonempty = (value: unknown): value is string => typeof value === 'string' && value.trim().length > 0;
+
+function readDefinition(text: string): TeamSet {
+  const raw: unknown = parse(text);
+  if (!mapping(raw) || !nonempty(raw['team-set']) || !namePattern.test(raw['team-set'])) {
+    throw new Error('team-set must be a non-empty filesystem-safe name');
+  }
+  if (!Array.isArray(raw.members) || raw.members.length === 0) throw new Error('members must be a non-empty list');
+  const members: Member[] = raw.members.map((item: unknown) => {
+    if (!mapping(item) || !nonempty(item.persona) || !idPattern.test(item.persona)
+      || !nonempty(item.title) || !nonempty(item.checklistTemplate)
+      || !(nonempty(item.rules) || (Array.isArray(item.rules) && item.rules.length > 0 && item.rules.every(nonempty)))) {
+      throw new Error('each member requires persona (safe id), title, checklistTemplate and rules');
+    }
+    return { persona: item.persona, title: item.title, checklistTemplate: item.checklistTemplate,
+      rules: typeof item.rules === 'string' ? [item.rules] : item.rules as string[] };
+  });
+  const ids = new Set(members.map((member) => member.persona));
+  if (ids.size !== members.length) throw new Error('duplicate team-set member persona');
+  if (!Array.isArray(raw.handoffs)) throw new Error('handoffs must be a list');
+  const handoffs: Handoff[] = raw.handoffs.map((item: unknown) => {
+    if (!mapping(item) || !nonempty(item.from) || !nonempty(item.to) || !nonempty(item.when)) {
+      throw new Error('each handoff requires from, to and when');
+    }
+    if (!ids.has(item.from) || !ids.has(item.to)) throw new Error(`handoff references missing member: ${item.from} -> ${item.to}`);
+    return { from: item.from, to: item.to, when: item.when };
+  });
+  const edges = new Map(members.map((member) => [member.persona, [] as string[]]));
+  for (const edge of handoffs) edges.get(edge.from)!.push(edge.to);
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+  const visit = (id: string): void => {
+    if (visiting.has(id)) throw new Error(`handoff cycle at ${id}`);
+    if (visited.has(id)) return;
+    visiting.add(id);
+    for (const next of edges.get(id)!) visit(next);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const id of ids) visit(id);
+  return { 'team-set': raw['team-set'], members, handoffs };
+}
+
+function store(dir: string): string { return join(dir, '_team-sets'); }
+function record(dir: string, name: string): string { return join(store(dir), `${name}.yaml`); }
+function memberPath(dir: string, id: string): string { return join(dir, `${id}.yaml`); }
+
+function recordedOwners(dir: string): Map<string, string> {
+  const owners = new Map<string, string>();
+  if (!existsSync(store(dir))) return owners;
+  for (const file of readdirSync(store(dir)).filter((name) => name.endsWith('.yaml'))) {
+    const data: unknown = parse(readFileSync(join(store(dir), file), 'utf8'));
+    if (!mapping(data) || !mapping(data.definition)) throw new Error(`invalid installed team-set: ${file}`);
+    const definition = readDefinition(stringify(data.definition));
+    const name = file.slice(0, -'.yaml'.length);
+    if (definition['team-set'] !== name) throw new Error(`invalid installed team-set: ${file}`);
+    for (const member of definition.members) {
+      const previous = owners.get(member.persona);
+      if (previous !== undefined) throw new Error(`persona has multiple team-set owners: ${member.persona} (${previous}, ${name})`);
+      owners.set(member.persona, name);
+    }
+  }
+  return owners;
+}
+
+function occupiedIds(dir: string): Set<string> {
+  const ids = new Set<string>();
+  if (!existsSync(dir)) return ids;
+  for (const file of readdirSync(dir).filter((name) => /\.ya?ml$/.test(name))) {
+    ids.add(file.replace(/\.ya?ml$/, ''));
+    const path = join(dir, file);
+    const parsed = parsePersonaYaml(readFileSync(path, 'utf8'), path);
+    if (parsed.ok) ids.add(parsed.profile.personaId);
+  }
+  return ids;
+}
+
+export function addTeamSet(file: string, dir = resolveStatePersonaDir()): TeamSet {
+  const definition = readDefinition(readFileSync(file, 'utf8'));
+  if (existsSync(record(dir, definition['team-set']))) throw new Error(`team-set already exists: ${definition['team-set']}`);
+  const occupied = new Set([...occupiedIds(dir), ...occupiedIds(resolveRepositoryPersonaDir()), ...recordedOwners(dir).keys()]);
+  for (const member of definition.members) {
+    if (occupied.has(member.persona) || existsSync(memberPath(dir, member.persona))) throw new Error(`persona already exists: ${member.persona}`);
+  }
+  const files = definition.members.map((member) => {
+    const yaml = stringify({ personaId: member.persona, displayName: `${member.persona} · ${member.title}`,
+      systemPrompt: [`직함: ${member.title}`, `체크리스트 템플릿: ${member.checklistTemplate}`, '규칙:', ...member.rules.map((rule) => `- ${rule}`)].join('\n') }, { lineWidth: 0 });
+    const check = parsePersonaYaml(yaml, memberPath(dir, member.persona));
+    if (!check.ok) throw new Error(check.error.message);
+    return { persona: member.persona, yaml };
+  });
+  mkdirSync(dir, { recursive: true });
+  mkdirSync(store(dir), { recursive: true });
+  const created: string[] = [];
+  try {
+    for (const entry of files) {
+      const path = memberPath(dir, entry.persona);
+      writeFileSync(path, entry.yaml, { flag: 'wx' });
+      created.push(path);
+    }
+    writeFileSync(record(dir, definition['team-set']), stringify({ definition, files }, { lineWidth: 0 }), { flag: 'wx' });
+  } catch (error) {
+    for (const path of created) unlinkSync(path);
+    throw error;
+  }
+  return definition;
+}
+
+export function listTeamSets(dir = resolveStatePersonaDir()): TeamSet[] {
+  if (!existsSync(store(dir))) return [];
+  return readdirSync(store(dir)).filter((name) => name.endsWith('.yaml')).sort().map((name) => {
+    const data: unknown = parse(readFileSync(join(store(dir), name), 'utf8'));
+    if (!mapping(data) || !mapping(data.definition)) throw new Error(`invalid installed team-set: ${name}`);
+    return readDefinition(stringify(data.definition));
+  });
+}
+
+export function removeTeamSet(name: string, dir = resolveStatePersonaDir()): void {
+  if (!namePattern.test(name)) throw new Error('invalid team-set name');
+  const path = record(dir, name);
+  if (!existsSync(path)) throw new Error(`team-set not found: ${name}`);
+  const data: unknown = parse(readFileSync(path, 'utf8'));
+  if (!mapping(data) || !mapping(data.definition) || !Array.isArray(data.files)) throw new Error(`invalid installed team-set: ${name}`);
+  const definition = readDefinition(stringify(data.definition));
+  if (definition['team-set'] !== name || data.files.length !== definition.members.length) throw new Error(`invalid installed team-set: ${name}`);
+  const owners = recordedOwners(dir);
+  const filesToRemove: string[] = [];
+  for (let index = 0; index < definition.members.length; index++) {
+    const file: unknown = data.files[index];
+    const id = definition.members[index]!.persona;
+    if (!mapping(file) || file.persona !== id || typeof file.yaml !== 'string') {
+      throw new Error(`invalid installed team-set: ${name}`);
+    }
+    if (owners.get(id) !== name) throw new Error(`persona is not owned by team-set ${name}: ${id}`);
+    const personaPath = memberPath(dir, id);
+    if (existsSync(personaPath) && readFileSync(personaPath, 'utf8') === file.yaml) {
+      filesToRemove.push(personaPath);
+    }
+  }
+  for (const personaPath of filesToRemove) unlinkSync(personaPath);
+  unlinkSync(path);
+  if (readdirSync(store(dir)).length === 0) rmdirSync(store(dir));
+}

package/src/plugins/install/plugin-install.ts

@@ -314,6 +314,20 @@ export async function installPlugin(spec: string, opts: InstallOptions = {}): Pr
     const source = marketSpec(spec, opts)
       ? await fetchedMarketSource(spec, join(stage, 'package'), opts)
       : resolvePluginSource(spec, join(stage, 'package'), opts);
+    const stagedManifest = join(stage, 'package', 'plugin.json');
+    if (existsSync(stagedManifest)) {
+      const rawManifest: unknown = JSON.parse(readFileSync(stagedManifest, 'utf8'));
+      if (rawManifest && typeof rawManifest === 'object' && !Array.isArray(rawManifest)) {
+        const rawExtensions = (rawManifest as Record<string, unknown>).extensions;
+        if (rawExtensions && typeof rawExtensions === 'object' && !Array.isArray(rawExtensions)) {
+          const elanous = (rawExtensions as Record<string, unknown>)['ai.elanous'];
+          if (elanous && typeof elanous === 'object' && !Array.isArray(elanous) &&
+            (elanous as Record<string, unknown>).researchDraft === true) {
+            fail('io', 'research draft only: implement and validate graph steps before installation');
+          }
+        }
+      }
+    }
     const manifest: PluginManifest = loadPluginManifestFromDir(join(stage, 'package'), { id: source.expectedName ?? basename(spec) }).manifest;
     if (!NAME.test(manifest.id) || !VERSION.test(manifest.version)) fail('io', 'invalid plugin name or version');
     if (source.expectedName && (manifest.id !== source.expectedName || manifest.version !== source.expectedVersion)) fail('conflict', 'market name or version differs from manifest');

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

@@ -0,0 +1,110 @@
+import { createHash, createPublicKey } from 'node:crypto';
+import { signIndex, validateMarketplaceIndex, verifyIndex, type MarketplaceIndex } from '../../market/signed-index.js';
+import { spawnSync } from 'node:child_process';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
+import { userConfigPath } from '../../user-config.js';
+import { loadPluginManifestFromDir } from '../core/manifest.js';
+import { LEAK_MARKERS, loadPrivateRedactions, privateIdentifierMarkers, scanLeaks } from '../../../scripts/public-export.js';
+
+export interface MarketBundleResult {
+  path: string;
+  artifact: string;
+  signature: 'signed' | 'signing-required';
+}
+
+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 === '.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);
+  }
+  return files;
+}
+
+/** Prepare a local, reviewable official-market index and tar artifact; never publishes either file. */
+export function bundleInstalledWizardPlugin(installedPath: string, outputDir: string, configPath = userConfigPath()): MarketBundleResult {
+  const source = resolve(installedPath);
+  const manifestFile = join(source, 'plugin.json');
+  if (!lstatSync(source).isDirectory() || !lstatSync(manifestFile).isFile() || lstatSync(manifestFile).isSymbolicLink()) {
+    throw new Error('market bundle requires an installed plugin.json');
+  }
+  const raw: unknown = JSON.parse(readFileSync(manifestFile, 'utf8'));
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw) || typeof (raw as { name?: unknown }).name !== 'string') {
+    throw new Error('invalid market plugin manifest name');
+  }
+  const { manifest, inferred } = loadPluginManifestFromDir(source, { id: (raw as { name: string }).name });
+  if (inferred || !/^[a-z0-9][a-z0-9-]{1,39}$/.test(manifest.id) ||
+    !/^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][a-zA-Z0-9.-]+)?$/.test(manifest.version)) {
+    throw new Error('invalid market plugin manifest name or version');
+  }
+  if ((raw as { extensions?: { 'ai.elanous'?: { researchDraft?: boolean } } }).extensions?.['ai.elanous']?.researchDraft === true) {
+    throw new Error('research draft cannot be bundled for market');
+  }
+  const files = packageFiles(source);
+  if (!files.length) throw new Error('empty plugin bundle');
+  if (manifest.id !== (raw as { name: string }).name) throw new Error('market plugin manifest name mismatch');
+  for (const asset of [manifest.main, ...(manifest.contributes.graphs ?? []), ...(manifest.contributes.vocab ?? []), ...(manifest.contributes.nodes ?? [])]) {
+    if (asset === './plugin.ts' && !('main' in (raw as object))) continue;
+    if (!files.includes(asset.replace(/^\.\//, ''))) throw new Error(`market manifest asset missing: ${asset}`);
+  }
+  const redactions = loadPrivateRedactions();
+  if (!redactions) throw new Error('private export redaction list unavailable; market bundle refused');
+  const hits = scanLeaks(source, files, [...LEAK_MARKERS, ...privateIdentifierMarkers(redactions)]);
+  if (hits.length) throw new Error(`market bundle leak: ${hits.map(hit => `${hit.file}:${hit.line} ${hit.marker}`).join(', ')}`);
+  const config: unknown = existsSync(configPath) ? JSON.parse(readFileSync(configPath, 'utf8')) : {};
+  if (!config || typeof config !== 'object' || Array.isArray(config)) throw new Error('invalid market signing config');
+  const signing = (config as { market?: { signing?: { keyId?: unknown; privateKey?: unknown } } }).market?.signing;
+  const hasKey = signing?.privateKey !== undefined || signing?.keyId !== undefined;
+  if (hasKey && (typeof signing?.privateKey !== 'string' || !signing.privateKey.trim() || typeof signing.keyId !== 'string' || !signing.keyId.trim())) {
+    throw new Error('market signing requires configured keyId and privateKey');
+  }
+  const target = resolve(outputDir);
+  if (target === source || target.startsWith(`${source}${sep}`) || source.startsWith(`${target}${sep}`)) throw new Error('market bundle output must be outside plugin directory');
+  if (existsSync(target)) throw new Error(`market bundle already exists: ${target}`);
+  mkdirSync(dirname(target), { recursive: true });
+  mkdirSync(target);
+  try {
+    const artifactKey = `${manifest.id}-${manifest.version}.tgz`;
+    const artifact = join(target, artifactKey);
+    const tar = spawnSync('tar', ['-czf', artifact, '-C', source, '--', ...files], { encoding: 'utf8' });
+    if (tar.status !== 0 || tar.error) throw new Error(`market archive failed: ${tar.error?.message ?? tar.stderr}`);
+    const bytes = readFileSync(artifact);
+    const index: MarketplaceIndex = { name: 'elanous', interface: { displayName: 'Elanous' }, sequence: 1, plugins: [{
+      name: manifest.id, version: manifest.version, description: manifest.description,
+      source: { source: 'local', path: '.' },
+      artifact: { key: artifactKey, sha256: createHash('sha256').update(bytes).digest('hex'), bytes: bytes.length },
+      'ai.elanous': {
+        capabilities: manifest.capabilities.map(capability => capability.kind),
+        connectors: (manifest.contributes.connectors ?? []).map(connector => ({
+          id: connector.id, kind: 'user-config', userConfig: (connector.userConfig ?? connector.fields?.map(field => ({
+            key: field.name, label: field.name, secret: field.secret === true,
+          })) ?? []).map(field => ({ key: field.key, label: field.label ?? field.key, secret: field.secret === true })),
+        })),
+        graphs: manifest.contributes.graphs ?? [], vocab: manifest.contributes.vocab ?? [],
+        pricing: { model: 'free' },
+      },
+    }] };
+    const invalid = validateMarketplaceIndex(index);
+    if (invalid) throw new Error(`invalid market index: ${invalid}`);
+    const indexBytes = Buffer.from(JSON.stringify(index, null, 2) + '\n');
+    writeFileSync(join(target, 'marketplace.json'), indexBytes);
+    if (hasKey) {
+      const signatureText = signIndex(indexBytes, signing!.privateKey as string, signing!.keyId as string);
+      const check = verifyIndex({ marketplaceBytes: indexBytes, signatureText, trustedKeys: [{
+        keyId: signing!.keyId as string,
+        publicKey: createPublicKey(signing!.privateKey as string).export({ format: 'der', type: 'spki' }).subarray(12).toString('base64'),
+      }] });
+      if (!check.ok) throw new Error(`market index signature invalid: ${check.detail}`);
+      writeFileSync(join(target, 'index.sig'), signatureText);
+    }
+    return { path: target, artifact, signature: hasKey ? 'signed' : 'signing-required' };
+  } catch (error) {
+    rmSync(target, { recursive: true, force: true });
+    throw error;
+  }
+}