elanous 0.2.10 → 0.2.11

package/src/plugins/maker/wizard-generate.ts

@@ -0,0 +1,103 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+
+/** Research is descriptive. Credential values are never an input to the generator. */
+export interface WizardResearchDraft {
+  description: string;
+  connectors?: Array<{
+    id: string;
+    credentials?: Array<{ name: string }>;
+  }>;
+  skill?: { description: string; instructions: string; requires?: string[] };
+}
+
+const SLUG = /^[a-z0-9][a-z0-9-]{1,31}$/;
+const FIELD = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+
+/** Materialize a research draft; its graph steps fail until the requested processing is implemented. */
+export function generateWizardFiles(dir: string, slug: string, draft: WizardResearchDraft): string[] {
+  if (!SLUG.test(slug)) throw new Error(`invalid wizard plugin name: ${slug}`);
+  if (!draft || typeof draft.description !== 'string' || !draft.description.trim()) throw new Error('wizard description is required');
+  if (draft.connectors !== undefined && !Array.isArray(draft.connectors)) throw new Error('invalid wizard connectors');
+  const connectors = (draft.connectors ?? []).map(connector => {
+    if (!connector || typeof connector !== 'object' || Object.keys(connector).some(key => key !== 'id' && key !== 'credentials') ||
+      !SLUG.test(connector.id) || (connector.credentials !== undefined && !Array.isArray(connector.credentials))) {
+      throw new Error('wizard connectors must contain ids and credential names only');
+    }
+    const names = (connector.credentials ?? []).map(credential => {
+      if (!credential || typeof credential !== 'object' || !FIELD.test(credential.name) || Object.keys(credential).some(key => key !== 'name')) {
+        throw new Error('wizard credentials must contain names only');
+      }
+      return credential.name;
+    });
+    if (new Set(names).size !== names.length) throw new Error(`duplicate wizard credential name: ${connector.id}`);
+    return { id: connector.id, fields: names.map(name => ({ name, secret: true })) };
+  });
+  if (new Set(connectors.map(connector => connector.id)).size !== connectors.length) throw new Error('duplicate wizard connector id');
+  if (draft.skill && (typeof draft.skill.description !== 'string' || typeof draft.skill.instructions !== 'string')) {
+    throw new Error('invalid wizard skill');
+  }
+  const catalog = parseYaml(readFileSync(join(import.meta.dir, '../../../catalog/resources.yaml'), 'utf8')) as {
+    resources: Array<{ id: string }>;
+  };
+  const knownResources = new Set(catalog.resources.map(resource => resource.id));
+  const requires = draft.skill?.requires ?? [];
+  if (!Array.isArray(requires) || requires.some(resource => typeof resource !== 'string' || !knownResources.has(resource))) {
+    throw new Error('wizard requires must reference existing resource ids');
+  }
+  const manifestPath = join(dir, 'plugin.json');
+  const existing = existsSync(manifestPath) ? JSON.parse(readFileSync(manifestPath, 'utf8')) as {
+    name: string; extensions: { 'ai.elanous': { connectors?: unknown[]; graphs?: string[]; researchDraft?: boolean } };
+  } : undefined;
+  if (existing && (existing.name !== slug || !existing.extensions?.['ai.elanous'])) {
+    throw new Error('wizard scaffold name or extension mismatch');
+  }
+  if (existsSync(join(dir, `skills/${slug}/SKILL.md`))) {
+    throw new Error(`wizard file already exists: skills/${slug}/SKILL.md`);
+  }
+  const scaffoldConnectors = existing?.extensions['ai.elanous'].connectors;
+  if (scaffoldConnectors !== undefined && (!Array.isArray(scaffoldConnectors) || scaffoldConnectors.length > 0)) {
+    throw new Error('wizard cannot replace existing scaffold connectors');
+  }
+  const manifest = existing ?? { name: slug, version: '0.1.0', description: draft.description,
+    extensions: { 'ai.elanous': { graphs: [`./graphs/${slug}.yaml`],
+      capabilities: ['fs:workdir', 'proc:bun', 'proc:elanous'], connectors: [] as unknown[], researchDraft: true } } };
+  manifest.extensions['ai.elanous'].connectors = connectors;
+  manifest.extensions['ai.elanous'].researchDraft = true;
+
+  const files: Array<[string, string]> = [
+    ['plugin.json', JSON.stringify(manifest, null, 2) + '\n'],
+    [`graphs/${slug}.yaml`, stringifyYaml({ graph_id: slug, version: 1, entry_node: 'prepare', terminal_nodes: ['done', 'failed'],
+      nodes: [
+        { node_id: 'prepare', kind: 'agent', recipe: 'cmd:prepare', max_visits: 1 },
+        { node_id: 'summarize', kind: 'agent', recipe: 'cmd:summarize', max_visits: 1 },
+        { node_id: 'done', kind: 'gate', recipe: 'none', max_visits: 1 },
+        { node_id: 'failed', kind: 'gate', recipe: 'none', max_visits: 1 },
+      ], edges: [
+        { from: 'prepare', on: 'outcome', map: { ok: 'summarize', fail: 'failed' } },
+        { from: 'summarize', on: 'outcome', map: { ok: 'done', fail: 'failed' } },
+      ] })],
+    ['graphs/recipes.yaml', stringifyYaml({ prepare: { command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" prepare', timeout_ms: 120000 },
+      summarize: { command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" summarize', timeout_ms: 120000 } })],
+    ['graphs/run-step.ts', `const step = process.argv[2];
+console.log(JSON.stringify({ outcome: 'fail', error: step === 'prepare' || step === 'summarize'
+  ? 'Research draft only: implement the requested processing before running this graph.'
+  : 'unknown step' }));
+process.exitCode = 1;
+`],
+    ['examples/input.json', '{}\n'],
+    ['README.md', `# ${slug}\n\n${draft.description}\n\nResearch draft only. Connector declarations contain credential names, not values. The graph cannot perform the requested processing yet: implement and validate its steps, then remove extensions["ai.elanous"].researchDraft from plugin.json before installing or running it. No messages are sent.\n`],
+    [`skills/${slug}/SKILL.md`, `---\n${stringifyYaml({ name: slug, description: draft.skill?.description ?? draft.description, requires: [...new Set(requires)] })}---\n\n${draft.skill?.instructions ?? draft.description}\n`],
+  ];
+  const generated = existing ? files.filter(([path]) => path === 'plugin.json' || path.startsWith('skills/')) : files;
+  for (const [path] of generated) {
+    if (path !== 'plugin.json' && existsSync(join(dir, path))) throw new Error(`wizard file already exists: ${path}`);
+  }
+  for (const [path, content] of generated) {
+    const target = join(dir, path);
+    mkdirSync(join(target, '..'), { recursive: true });
+    writeFileSync(target, content, { flag: path === 'plugin.json' && existing ? 'w' : 'wx' });
+  }
+  return generated.map(([path]) => path);
+}

package/src/pod-lease/admission.ts

@@ -0,0 +1,150 @@
+import { debug } from '../debug/log.js';
+import type { PoolLeaseRecommendation } from '../task-orchestrator/surfaces/pod-lease.js';
+import type { PredecessorState } from './dependency-state.js';
+
+/** A release belongs to one admitted launch and is idempotent. */
+export type PodLeaseRelease = () => void;
+
+/** A goal ID or PR number that must be merged before admission. */
+export type PodLeasePredecessor = string | number;
+
+export interface PodLeaseAdmissionOptions {
+  /** The same recommendation returned by pod lease status, for the launch pool. */
+  status: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>;
+  /** Predecessor state: merged admits · waiting stays queued (unknown/error too) · blocked rejects. A boolean means merged/waiting. */
+  dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean>;
+  /** Recheck even when there are no local releases (another launcher may free a slot). */
+  pollMs?: number;
+}
+
+/** FIFO admission across launches sharing this instance. Unknown status never grants a slot. */
+export class PodLeaseAdmission {
+  private readonly queue: Array<{ resolve: (release: PodLeaseRelease) => void; reject: (error: Error) => void; signal?: AbortSignal; after?: PodLeasePredecessor; onAbort?: () => void; cancelCheck?: () => void; waitReason?: string }> = [];
+  private active = 0;
+  private limit = 0;
+  private checking: Promise<void> | undefined;
+  private recheckRequested = false;
+  private timer: ReturnType<typeof setTimeout> | undefined;
+  private readonly pollMs: number;
+
+  constructor(private readonly options: PodLeaseAdmissionOptions) {
+    this.pollMs = options.pollMs ?? 15_000;
+    if (!Number.isFinite(this.pollMs) || this.pollMs <= 0) throw new Error('pod lease pollMs must be positive');
+  }
+
+  /** Queue view: each waiting item says why it waits (predecessor not merged yet, or no free slot). */
+  snapshot(): { active: number; queued: number; recommended: number; waiting: Array<{ after?: PodLeasePredecessor; reason: string }> } {
+    return { active: this.active, queued: this.queue.length, recommended: this.limit,
+      waiting: this.queue.map((w) => ({ ...(w.after !== undefined ? { after: w.after } : {}), reason: w.waitReason ?? 'no-free-slot' })) };
+  }
+
+  /** A launch stays queued until an admitted slot can be reserved. */
+  acquire(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease> {
+    if (signal?.aborted) return Promise.reject(new Error('pod lease admission aborted'));
+    return new Promise((resolve, reject) => {
+      const waiter: (typeof this.queue)[number] = { resolve, reject, signal, after };
+      if (signal) {
+        waiter.onAbort = () => {
+          const index = this.queue.indexOf(waiter);
+          if (index < 0) return;
+          this.queue.splice(index, 1);
+          waiter.cancelCheck?.();
+          reject(new Error('pod lease admission aborted'));
+          this.schedule();
+        };
+        signal.addEventListener('abort', waiter.onAbort, { once: true });
+      }
+      this.queue.push(waiter);
+      void this.refresh();
+    });
+  }
+
+  /** Re-evaluate the measured recommended N; never use accountSlots as an admission bound. */
+  refresh(): Promise<void> {
+    if (this.checking) {
+      if (this.queue.length) this.recheckRequested = true;
+      return this.checking;
+    }
+    if (!this.queue.length) return Promise.resolve();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    this.checking = this.checkUntilCurrent();
+    return this.checking;
+  }
+
+  private async checkUntilCurrent(): Promise<void> {
+    try {
+      do {
+        this.recheckRequested = false;
+        try {
+          const status = await this.options.status();
+          this.limit = status.recommended !== null && Number.isSafeInteger(status.recommended) && status.recommended >= 0
+            ? status.recommended : 0;
+        } catch {
+          this.limit = 0;
+        }
+        // No head-of-line blocking: a waiter whose predecessor is not merged yet is skipped and later waiters may admit.
+        let index = 0;
+        while (this.active < this.limit && index < this.queue.length) {
+          const waiter = this.queue[index]!;
+          if (waiter.after !== undefined) {
+            let state: PredecessorState = 'waiting';
+            const controller = new AbortController();
+            try {
+              const check = this.options.dependencyMerged?.(waiter.after, controller.signal);
+              const result = await Promise.race([
+                Promise.resolve(check),
+                new Promise<PredecessorState>((resolve) => { waiter.cancelCheck = () => { controller.abort(); resolve('waiting'); }; }),
+              ]);
+              state = result === true ? 'merged' : result === false || result === undefined ? 'waiting' : result;
+            } catch {
+              // An unavailable dependency state cannot grant admission.
+            } finally {
+              waiter.cancelCheck = undefined;
+            }
+            if (!this.queue.includes(waiter)) continue; // aborted while checking
+            if (state === 'blocked') {
+              this.queue.splice(this.queue.indexOf(waiter), 1);
+              if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
+              debug.log('pod-lease', 'predecessor-blocked', { after: waiter.after });
+              waiter.reject(new Error(`pod lease predecessor blocked: ${String(waiter.after)} was closed without merging`));
+              continue;
+            }
+            if (state !== 'merged') {
+              waiter.waitReason = `predecessor-unmerged:${String(waiter.after)}`;
+              index++;
+              continue;
+            }
+          }
+          this.queue.splice(this.queue.indexOf(waiter), 1);
+          if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
+          this.active++;
+          let released = false;
+          waiter.resolve(() => {
+            if (released) return;
+            released = true;
+            this.active--;
+            void this.refresh();
+          });
+        }
+        for (const waiter of this.queue.slice(index)) if (!waiter.waitReason?.startsWith('predecessor-')) waiter.waitReason = 'no-free-slot';
+      } while (this.recheckRequested && this.queue.length > 0);
+    } finally {
+      this.checking = undefined;
+      this.schedule();
+    }
+  }
+
+  private schedule(): void {
+    if (!this.queue.length) {
+      if (this.timer) clearTimeout(this.timer);
+      this.timer = undefined;
+      return;
+    }
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      void this.refresh();
+    }, this.pollMs);
+  }
+}

package/src/pod-lease/dependency-state.ts

@@ -0,0 +1,85 @@
+import { execFile } from 'node:child_process';
+import { listRunLedgers } from '../self-implement/run-ledger.js';
+import { runGitCommand } from '../git-fs/runner.js';
+import type { PodLeasePredecessor } from './admission.js';
+
+/** merged = admit · waiting = keep queued (open, unknown, unreadable) · blocked = predecessor closed without merging. */
+export type PredecessorState = 'merged' | 'waiting' | 'blocked';
+
+type PrState = string | null;
+
+type DependencyStateDeps = {
+  prState?: (number: number, signal?: AbortSignal) => PrState | Promise<PrState>;
+  ledgers?: () => ReturnType<typeof listRunLedgers>['matches'];
+};
+
+function githubRepository(): string | null {
+  const remote = runGitCommand(process.cwd(), ['config', '--get', 'remote.origin.url'], { encoding: 'utf8', timeout: 5_000 });
+  const repository = /^(?:https:\/\/github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?\/?$/.exec(remote.stdout.trim())?.[1];
+  return remote.status !== 0 || !repository || repository.includes('..') ? null : repository;
+}
+
+/** Async so a slow GitHub lookup never blocks the event loop (admission, cancellation, other launches). */
+function githubPrState(number: number, signal?: AbortSignal): Promise<PrState> {
+  const repository = githubRepository();
+  if (!repository) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    execFile('gh', ['pr', 'view', String(number), '--repo', repository, '--json', 'state'], {
+      encoding: 'utf8', timeout: 15_000, env: process.env, ...(signal ? { signal } : {}),
+    }, (error, stdout) => {
+      if (error) return resolve(null);
+      try {
+        const response: unknown = JSON.parse(stdout);
+        resolve(response && typeof response === 'object' && 'state' in response && typeof response.state === 'string' ? response.state : null);
+      } catch { resolve(null); }
+    });
+  });
+}
+
+const prNumberOf = (after: PodLeasePredecessor): number | null => {
+  const number = typeof after === 'number' ? after : Number(after.replace(/^#/, ''));
+  return Number.isSafeInteger(number) && number > 0 ? number : null;
+};
+
+async function readState(number: number, deps: DependencyStateDeps, signal?: AbortSignal): Promise<PrState> {
+  try { return await (deps.prState ?? githubPrState)(number, signal); } catch { return null; }
+}
+
+/** Only a verified merged predecessor grants a Pod lease; a predecessor closed without merging blocks; everything else waits. */
+export async function predecessorState(after: PodLeasePredecessor, deps: DependencyStateDeps = {}, signal?: AbortSignal): Promise<PredecessorState> {
+  const isPr = typeof after === 'number' || (typeof after === 'string' && !/^[a-f0-9]{16}$/.test(after) && /^#?[1-9]\d*$/.test(after));
+  if (isPr) {
+    const number = prNumberOf(after);
+    if (number === null) return 'waiting';
+    const state = await readState(number, deps, signal);
+    return state === 'MERGED' ? 'merged' : state === 'CLOSED' ? 'blocked' : 'waiting';
+  }
+  if (typeof after !== 'string' || !after.trim()) return 'waiting';
+  let numbers: Set<number>;
+  try {
+    const matches = (deps.ledgers ?? (() => listRunLedgers().matches))()
+      .filter(({ entries }) => entries.some((entry) => entry.goalId === after));
+    numbers = new Set<number>();
+    for (const { entries } of matches) {
+      for (const entry of entries) {
+        if (entry.event !== 'pr-opened' || entry.goalId !== after) continue;
+        const number = entry.data.number;
+        if (typeof number === 'number' && Number.isSafeInteger(number) && number > 0) numbers.add(number);
+      }
+    }
+  } catch { return 'waiting'; }
+  if (numbers.size === 0) return 'waiting';
+  // A later attempt or manual merge can land an opened PR without an in-run merged event.
+  let allClosed = true;
+  for (const number of numbers) {
+    const state = await readState(number, deps, signal);
+    if (state === 'MERGED') return 'merged';
+    if (state !== 'CLOSED') allClosed = false;
+  }
+  return allClosed ? 'blocked' : 'waiting';
+}
+
+/** Back-compat boolean view: true only when merged. */
+export async function predecessorMerged(after: PodLeasePredecessor, deps: DependencyStateDeps = {}, signal?: AbortSignal): Promise<boolean> {
+  return (await predecessorState(after, deps, signal)) === 'merged';
+}

package/src/pod-lease/host-lease.ts

@@ -0,0 +1,127 @@
+// L7b — cross-process Pod admission on one host. Each admitted launch holds a lease file (pid ⊕ process start time)
+// in a per-user directory; a launch is admitted only while live leases stay under the pool's measured total.
+// Without this, independent CLI processes each measured an empty pool and all launched (review round 2 of #23212).
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir, userInfo } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export interface HostLeaseRecord { pid: number; startedAt: string; at: string }
+
+export interface HostPoolLeaseOptions {
+  /** Base directory — default `$TMPDIR/elanous-pod-leases-<uid>` (0700). */
+  dir?: string;
+  pid?: number;
+  /** `ps -o lstart=` text for a pid, or null when the process is gone. */
+  processStart?: (pid: number) => string | null;
+  now?: () => number;
+  /** A lock older than this is a crash leftover and is cleared. */
+  staleLockMs?: number;
+}
+
+export function hostLeaseBaseDir(env: NodeJS.ProcessEnv = process.env): string {
+  if (env.ELANOUS_POD_LEASE_DIR?.trim()) return env.ELANOUS_POD_LEASE_DIR.trim();
+  // Test runs get a per-process directory so parallel test files never share real host leases.
+  if (env.NODE_ENV === 'test') return join(tmpdir(), `elanous-pod-leases-test-${process.pid}`);
+  let uid: string;
+  try { uid = String(userInfo().uid); } catch { uid = 'unknown'; }
+  return join(tmpdir(), `elanous-pod-leases-${uid}`);
+}
+
+/** Process start time as `ps` prints it (C locale so the text is stable). Null = no such process. */
+export function psProcessStart(pid: number): string | null {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+  const result = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], { encoding: 'utf8', env: { ...process.env, LC_ALL: 'C', LANG: 'C' } });
+  const text = result.status === 0 ? result.stdout.trim() : '';
+  return text || null;
+}
+
+export class HostPoolLease {
+  readonly dir: string;
+  private readonly pid: number;
+  private readonly processStart: (pid: number) => string | null;
+  private readonly now: () => number;
+  private readonly staleLockMs: number;
+  private ownStart: string | null | undefined;
+
+  constructor(poolKey: string, options: HostPoolLeaseOptions = {}) {
+    this.dir = join(options.dir ?? hostLeaseBaseDir(), poolKey.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 120) || 'pool');
+    this.pid = options.pid ?? process.pid;
+    this.processStart = options.processStart ?? psProcessStart;
+    this.now = options.now ?? Date.now;
+    this.staleLockMs = options.staleLockMs ?? 10_000;
+  }
+
+  /** Live leases after removing stale ones (dead pid or a recycled pid whose start time differs). */
+  live(): HostLeaseRecord[] {
+    const out: HostLeaseRecord[] = [];
+    let names: string[] = [];
+    try { names = readdirSync(this.dir).filter((name) => name.endsWith('.json')); } catch { return out; }
+    for (const name of names) {
+      const file = join(this.dir, name);
+      let record: HostLeaseRecord | null = null;
+      try { record = JSON.parse(readFileSync(file, 'utf8')) as HostLeaseRecord; } catch { record = null; }
+      const alive = record && this.processStart(record.pid) === record.startedAt;
+      if (record && alive) { out.push(record); continue; }
+      try { unlinkSync(file); } catch { /* another process cleaned it */ }
+      debug.log('pod.lease', 'host-lease-stale-cleared', { file: name, pid: record?.pid ?? null });
+    }
+    return out;
+  }
+
+  /** Unapplied leases held by other processes — launches admitted elsewhere whose Job the cluster can't see yet. */
+  othersPending(): number {
+    if (this.ownStart === undefined) this.ownStart = this.processStart(this.pid);
+    return this.live().filter((r) => !(r.pid === this.pid && r.startedAt === this.ownStart)).length;
+  }
+
+  /**
+   * Under the host lock, take a lease only if `allowed(othersPending)` holds — the check and the write are one step,
+   * so independent processes measuring the same empty pool cannot all pass. Null = refused or lock busy (retry later).
+   */
+  tryReserve(allowed: (othersPending: number) => boolean): (() => void) | null {
+    try { mkdirSync(this.dir, { recursive: true, mode: 0o700 }); } catch { return null; }
+    if (!this.lock()) return null;
+    try {
+      if (this.ownStart === undefined) this.ownStart = this.processStart(this.pid);
+      if (!this.ownStart) return null;
+      const others = this.live().filter((r) => !(r.pid === this.pid && r.startedAt === this.ownStart)).length;
+      if (!allowed(others)) {
+        debug.log('pod.lease', 'host-lease-refused', { othersPending: others });
+        return null;
+      }
+      const file = join(this.dir, `${this.pid}-${this.now()}-${Math.random().toString(36).slice(2, 8)}.json`);
+      const record: HostLeaseRecord = { pid: this.pid, startedAt: this.ownStart, at: new Date(this.now()).toISOString() };
+      writeFileSync(file, JSON.stringify(record), { flag: 'wx', mode: 0o600 });
+      debug.log('pod.lease', 'host-lease-acquired', { othersPending: others });
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        try { unlinkSync(file); } catch { /* already cleaned */ }
+      };
+    } finally {
+      this.unlock();
+    }
+  }
+
+  private lockDir(): string { return join(this.dir, '.lock'); }
+
+  private lock(): boolean {
+    const dir = this.lockDir();
+    try { mkdirSync(dir); return true; } catch { /* held */ }
+    try {
+      if (this.now() - statSync(dir).mtimeMs > this.staleLockMs) {
+        rmSync(dir, { recursive: true, force: true });
+        mkdirSync(dir);
+        return true;
+      }
+    } catch { /* raced */ }
+    return false;
+  }
+
+  private unlock(): void {
+    try { rmSync(this.lockDir(), { recursive: true, force: true }); } catch { /* gone */ }
+  }
+}

package/src/project/project-suggestion.ts

@@ -0,0 +1,16 @@
+// 작업 폴더 → 프로젝트 제안을 «폴더가 바뀔 때마다» 다시 계산한다(IA1 리뷰 must-fix · 시작 시 process.cwd() 한 번만 보던 것).
+// 같은 프로젝트를 연달아 다시 알리지 않는다 — 바뀐 경우에만 돌려준다.
+import type { Project } from './project-store.js';
+
+export function createProjectSuggester(suggest: (folder: string) => Project | null): (folder: string) => Project | null {
+  let lastId: string | null = null;
+  return (folder) => {
+    let project: Project | null;
+    try { project = suggest(folder); }
+    catch { return null; } // 제안은 대화를 끊지 않는다
+    const id = project?.id ?? null;
+    if (id === lastId) return null;
+    lastId = id;
+    return project;
+  };
+}

package/src/project/session-context.ts

@@ -0,0 +1,24 @@
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { getProject } from './project-store.js';
+import { loadSession } from '../session/index.js';
+
+/** Resolve the assigned project's folder for a persisted conversation, never from client-supplied paths. */
+export function resolveSessionProjectContext(sessionId: string | undefined): { cwd: string; instructions?: string } | null {
+  if (!sessionId) return null;
+  const projectId = loadSession(sessionId)?.meta.projectId;
+  if (!projectId) return null;
+  const folder = getProject(projectId)?.primaryFolder;
+  if (!folder) return null;
+  try {
+    if (!statSync(folder).isDirectory()) return null;
+  } catch { return null; }
+  const file = join(folder, 'AGENTS.md');
+  try {
+    const instructions = readFileSync(file, 'utf8');
+    return { cwd: folder, ...(instructions.trim() ? { instructions: `Project instructions (${file}):\n${instructions}` } : {}) };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    return { cwd: folder };
+  }
+}

package/src/release-loop/checklist.ts

@@ -68,8 +68,8 @@ function decodeClaimHistory(data: Checklist): Checklist {
   return { ...data, history: data.history.map(decodeClaimHistoryEntry) };
 }
 
-export function listChecklist(v: string): Checklist {
-  return decodeClaimHistory(store.list(v));
+export function listChecklist(v: string, root?: string): Checklist {
+  return decodeClaimHistory(root === undefined ? store.list(v) : store.list(v, undefined, undefined, root));
 }
 
 /** Status events in the requested window; other ledger fields never become status changes. */

package/src/release-loop/feature-store.ts

@@ -278,10 +278,12 @@ function importLegacyAll(): void {
   } finally { db.close(); }
 }
 
-export function list(version: string, released = releasedVersion(), dev = devVersion()): Checklist {
+/** `root` reads another ledger (no legacy JSON import there); omitted = the default ledger as before. */
+export function list(version: string, released?: string, dev = devVersion(), root?: string): Checklist {
   validateVersion(version);
-  importJson(version);
-  const db = open();
+  if (root === undefined) importJson(version);
+  released ??= releasedVersion(root);
+  const db = open(root);
   try { return readTransaction(db, () => snapshot(db, version, released, dev)); } finally { db.close(); }
 }
 

package/src/release-loop/next-md-merge.ts

@@ -0,0 +1,58 @@
+// Deterministic merge for `release/next.md` — two landings that each append a line to the same section
+// keep both lines (union per section, same sentence once). Returns null when it cannot decide (the caller
+// falls back to its usual resolver): a side deleted a line, or a stage is missing.
+
+export const NEXT_MD_PATH = 'release/next.md';
+
+type Section = { header: string | null; lines: string[] };
+
+function sections(text: string): Section[] {
+  const out: Section[] = [{ header: null, lines: [] }];
+  for (const line of text.replace(/\r\n/g, '\n').split('\n')) {
+    if (/^## /.test(line)) out.push({ header: line.trim(), lines: [] });
+    else out[out.length - 1]!.lines.push(line);
+  }
+  return out;
+}
+
+const key = (line: string) => line.trim();
+
+function added(base: Section | undefined, side: Section): string[] {
+  const before = new Set((base?.lines ?? []).map(key));
+  return side.lines.filter((line) => key(line) !== '' && !before.has(key(line)));
+}
+
+function deletedAny(base: Section[], side: Section[]): boolean {
+  for (const b of base) {
+    const s = side.find((x) => x.header === b.header);
+    const kept = new Set((s?.lines ?? []).map(key));
+    if (b.lines.some((line) => key(line) !== '' && !kept.has(key(line)))) return true;
+  }
+  return false;
+}
+
+/** Union of both sides' additions over `theirs` (the branch being merged in). Null = not decidable here. */
+export function resolveNextMdConflict(base: string, ours: string, theirs: string): string | null {
+  const b = sections(base);
+  const o = sections(ours);
+  // Our side only appends (harness landings add one line); a deletion on our side is not ours to decide.
+  if (deletedAny(b, o)) return null;
+  const result = sections(theirs);
+  for (const section of o) {
+    const extra = added(b.find((x) => x.header === section.header), section);
+    if (extra.length === 0) continue;
+    let target = result.find((x) => x.header === section.header);
+    if (!target) {
+      target = { header: section.header, lines: [''] };
+      result.push(target);
+    }
+    const present = new Set(target.lines.map(key));
+    const fresh = extra.filter((line) => !present.has(key(line)));
+    if (fresh.length === 0) continue;
+    // Insert before the section's trailing blank lines so the blank separator stays last.
+    let end = target.lines.length;
+    while (end > 0 && key(target.lines[end - 1]!) === '') end -= 1;
+    target.lines.splice(end, 0, ...fresh);
+  }
+  return result.map((section) => (section.header === null ? section.lines : [section.header, ...section.lines]).join('\n')).join('\n');
+}