elanous 0.2.21 → 0.2.23

package/src/nexus/api/error-reports.ts

@@ -25,19 +25,21 @@ function storeDir(root: string): string { return join(root, 'error-reports'); }
 /** Removes day folders older than the keep window. Returns how many days were removed. */
 export function pruneErrorReports(root: string, now: number): number {
   const base = storeDir(root);
-  if (!existsSync(base)) return 0;
   let removed = 0;
-  for (const year of readdirSync(base).filter((n) => /^\d{4}$/.test(n))) {
-    for (const month of readdirSync(join(base, year)).filter((n) => /^\d{2}$/.test(n))) {
-      for (const day of readdirSync(join(base, year, month)).filter((n) => /^\d{2}$/.test(n))) {
-        const at = Date.parse(`${year}-${month}-${day}T00:00:00Z`);
-        if (Number.isFinite(at) && now - at > ERROR_REPORT_KEEP_DAYS * DAY_MS + DAY_MS) {
-          rmSync(join(base, year, month, day), { recursive: true, force: true });
-          removed++;
+  if (existsSync(base)) {
+    for (const year of readdirSync(base).filter((n) => /^\d{4}$/.test(n))) {
+      for (const month of readdirSync(join(base, year)).filter((n) => /^\d{2}$/.test(n))) {
+        for (const day of readdirSync(join(base, year, month)).filter((n) => /^\d{2}$/.test(n))) {
+          const at = Date.parse(`${year}-${month}-${day}T00:00:00Z`);
+          if (Number.isFinite(at) && now - at > ERROR_REPORT_KEEP_DAYS * DAY_MS + DAY_MS) {
+            rmSync(join(base, year, month, day), { recursive: true, force: true });
+            removed++;
+          }
         }
       }
     }
   }
+  debug.log('error-report.prune', 'done', { pruned: removed });
   return removed;
 }
 
@@ -77,6 +79,26 @@ function count24h(root: string, dedupe: string, now: number): number {
   return n;
 }
 
+/** Retention without a receipt: prune once at daemon boot and then once a day (the ingest path still prunes too). */
+export function startErrorReportPruneTick(deps: {
+  root?: () => string;
+  now?: () => number;
+  schedule?: (tick: () => void, ms: number) => { unref?: () => void };
+} = {}): { stop(): void } {
+  const root = deps.root ?? effectiveInstanceRoot;
+  const now = deps.now ?? Date.now;
+  const run = (trigger: 'boot' | 'tick') => {
+    // pruneErrorReports emits error-report.prune/done { pruned }; only a failure is logged here.
+    try { pruneErrorReports(root(), now()); }
+    catch (error) { debug.log('error-report.prune', 'failed', { trigger, reason: error instanceof Error ? error.message : String(error) }); }
+  };
+  run('boot');
+  let stopped = false;
+  const handle = (deps.schedule ?? ((tick, ms) => setInterval(tick, ms)))(() => { if (!stopped) run('tick'); }, DAY_MS);
+  handle.unref?.();
+  return { stop: () => { stopped = true; if (!deps.schedule) clearInterval(handle as ReturnType<typeof setInterval>); } };
+}
+
 /** POST /v1/reports/ingest — the caller (router) has already checked the ingest token. */
 export async function handleErrorReportIngest(req: Request, deps: ErrorReportIngestDeps = {}): Promise<Response> {
   const root = (deps.root ?? effectiveInstanceRoot)();

package/src/nexus/api/graph-peer-edit.ts

@@ -0,0 +1,77 @@
+// W9c run guard (TC security review of #25123) — a peer «edit» grant lets another token rewrite a «mine» graph.
+// Running that graph would run the peer's change with this machine's privileges, so a peer save leaves a
+// marker next to the graph's access grants (`<mine>/.access/<id>.peer-edit.json`) and every run entry for a
+// «mine» graph refuses it until the owner approves that exact version (or re-saves it themselves).
+// Fail closed: a marker that exists but cannot be read or parsed refuses the run.
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const PEER_EDIT_REFUSAL = '상대가 바꾼 그래프 — 변경을 확인하고 승인해야 실행할 수 있다';
+
+export interface PeerEditRecord {
+  /** `peer:<first 8 hex of the peer token's sha256>` — never the token itself. */
+  editedBy: string;
+  /** The version id the peer save produced (`pending` while the save is in flight). */
+  version: string;
+  at: string;
+  approved?: { version: string; at: string };
+}
+
+export type PeerEditGate =
+  | { ok: true }
+  | { ok: false; error: 'peer-edit-unapproved'; record: PeerEditRecord }
+  | { ok: false; error: 'peer-edit-unreadable'; reason: string };
+
+export function peerEditFile(mineDir: string, id: string): string {
+  return join(mineDir, '.access', `${id}.peer-edit.json`);
+}
+
+/** null = no peer ever saved this graph. Throws when the marker exists but is unreadable or malformed. */
+export function readPeerEdit(mineDir: string, id: string): PeerEditRecord | null {
+  let text: string;
+  try { text = readFileSync(peerEditFile(mineDir, id), 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
+  const parsed: unknown = JSON.parse(text);
+  const record = parsed as PeerEditRecord;
+  if (!parsed || typeof parsed !== 'object' || typeof record.editedBy !== 'string' || typeof record.version !== 'string'
+    || typeof record.at !== 'string'
+    || (record.approved !== undefined && (typeof record.approved !== 'object' || record.approved === null
+      || typeof record.approved.version !== 'string' || typeof record.approved.at !== 'string'))) {
+    throw new Error('invalid peer-edit marker');
+  }
+  return record;
+}
+
+export function writePeerEdit(mineDir: string, id: string, record: PeerEditRecord): void {
+  mkdirSync(join(mineDir, '.access'), { recursive: true, mode: 0o700 });
+  const target = peerEditFile(mineDir, id);
+  const temp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(record), { mode: 0o600 });
+    renameSync(temp, target);
+  } finally { rmSync(temp, { force: true }); }
+}
+
+/** An owner-authorized save replaces the peer's bytes with bytes the owner chose. */
+export function clearPeerEdit(mineDir: string, id: string): void {
+  rmSync(peerEditFile(mineDir, id), { force: true });
+}
+
+export function peerEditRunGate(mineDir: string, id: string): PeerEditGate {
+  let record: PeerEditRecord | null;
+  try { record = readPeerEdit(mineDir, id); }
+  catch (error) { return { ok: false, error: 'peer-edit-unreadable', reason: String(error).slice(0, 200) }; }
+  if (!record || record.approved?.version === record.version) return { ok: true };
+  return { ok: false, error: 'peer-edit-unapproved', record };
+}
+
+/** The 409 body every refusing run entry returns — `reason` is what the editor shows. */
+export function peerEditRefusalBody(id: string, gate: Exclude<PeerEditGate, { ok: true }>): Record<string, unknown> {
+  return gate.error === 'peer-edit-unapproved'
+    ? { error: gate.error, id, reason: PEER_EDIT_REFUSAL, editedBy: gate.record.editedBy, version: gate.record.version, editedAt: gate.record.at }
+    : { error: gate.error, id, reason: PEER_EDIT_REFUSAL, detail: gate.reason };
+}

package/src/nexus/api/graph-wizard-api.ts

@@ -1,7 +1,11 @@
 import { debug } from '../../debug/log.js';
-import { GraphWizardInputError, generateGraphFromPrompt, type GraphWizardDeps, type GraphWizardTurn } from '../../graph-wizard/generate.js';
+import { GraphWizardInputError, generateGraphFromPrompt, wizardInstalledPacks, type GraphWizardDeps, type GraphWizardTurn } from '../../graph-wizard/generate.js';
 import { jsonResponse } from './json-response.js';
 
+export function handleGraphWizardPacksGet(deps: GraphWizardDeps = {}): Response {
+  return jsonResponse({ packs: wizardInstalledPacks(deps) });
+}
+
 const MAX_PROMPT = 4000;
 const MAX_YAML = 200_000;
 
@@ -28,6 +32,9 @@ export async function handleGraphWizardPost(req: Request, deps: GraphWizardDeps
   if (body.currentYaml !== undefined && (typeof body.currentYaml !== 'string' || body.currentYaml.length > MAX_YAML)) {
     return jsonResponse({ error: 'bad_request', reason: 'currentYaml must be a string' }, 400);
   }
+  if (body.packId !== undefined && typeof body.packId !== 'string') {
+    return jsonResponse({ error: 'bad_request', reason: 'packId must be a string' }, 400);
+  }
   let history: GraphWizardTurn[] | undefined;
   if (body.history !== undefined) {
     if (!Array.isArray(body.history) || !body.history.every((t) => t && typeof t === 'object' &&
@@ -42,6 +49,7 @@ export async function handleGraphWizardPost(req: Request, deps: GraphWizardDeps
       ...(body.kind ? { kind: body.kind as 'harness' | 'workflow' } : {}),
       ...(typeof body.currentYaml === 'string' && body.currentYaml.trim() ? { currentYaml: body.currentYaml } : {}),
       ...(history ? { history } : {}),
+      ...(typeof body.packId === 'string' ? { packId: body.packId } : {}),
     }, deps);
     return jsonResponse({ ...result, base: result.base ?? null }, result.ok ? 200 : 422);
   } catch (error) {

package/src/nexus/api/graphs-api.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
 import { parse as parseYaml } from 'yaml';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
 import { debug } from '../../debug/log.js';
@@ -10,6 +11,7 @@ import { validateGraphYaml } from './graph-kinds.js';
 import { parseWizardSteps, readWizardSteps, withWizardSteps } from '../../graph-wizard/saved-steps.js';
 import type { WizardNodeStep } from '../../graph-wizard/steps.js';
 import { jsonResponse } from './json-response.js';
+import { clearPeerEdit, peerEditRefusalBody, peerEditRunGate, readPeerEdit, writePeerEdit } from './graph-peer-edit.js';
 
 /** Declared graph ids only. A user string is never joined onto a filesystem path. */
 const GRAPH_ID = /^[a-z0-9-]+$/;
@@ -44,6 +46,93 @@ function mineGraphsDir(): string {
   return join(elanousStateRoot(), 'graphs');
 }
 
+export type GraphPermission = 'view' | 'edit';
+type GraphGrant = { recipient: string; permission: GraphPermission };
+const TOKEN_PATTERN = /^eg_[A-Za-z0-9_-]{32,}$/;
+
+function accessFile(dir: string, id: string): string {
+  return join(dir, '.access', `${id}.json`);
+}
+function tokenHash(token: string): string {
+  return createHash('sha256').update(token).digest('hex');
+}
+function accessGrants(dir: string, id: string): GraphGrant[] {
+  let text: string;
+  try { text = readFileSync(accessFile(dir, id), 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  const parsed: unknown = JSON.parse(text);
+  if (!Array.isArray(parsed) || !parsed.every((entry): entry is GraphGrant => entry !== null && typeof entry === 'object'
+    && typeof entry.recipient === 'string' && /^[a-f0-9]{64}$/.test(entry.recipient)
+    && (entry.permission === 'view' || entry.permission === 'edit'))) throw new Error('invalid graph access store');
+  return parsed;
+}
+
+/** Only a hash is persisted; no owner bearer or raw recipient credential goes into a graph/YAML. */
+export function handleGraphAccess(pathname: string, req: Request, deps: GraphsApiDeps = {}): Response {
+  const match = /^\/v1\/graphs\/([^/]+)\/access$/.exec(pathname);
+  const id = match ? resolveId(match[1]!) : null;
+  if (!id) return jsonResponse({ error: 'bad_request' }, 400);
+  const owned = mineOwnership(id, deps);
+  if (owned instanceof Response) return owned;
+  if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  try { return jsonResponse({ grants: accessGrants(owned.mineDir, id) }); }
+  catch (error) { return saveFailed(id, error); }
+}
+
+export async function handleGraphAccessPut(pathname: string, req: Request, deps: GraphsApiDeps = {}): Promise<Response> {
+  const match = /^\/v1\/graphs\/([^/]+)\/access$/.exec(pathname);
+  const id = match ? resolveId(match[1]!) : null;
+  if (!id) return jsonResponse({ error: 'bad_request' }, 400);
+  const owned = mineOwnership(id, deps);
+  if (owned instanceof Response) return owned;
+  // Detail GET resolves a core id first; do not grant a token for a shadowed mine id.
+  if (indexByDeclaredId(deps.coreDir ?? defaultGraphsDir()).has(id)) return jsonResponse({ error: 'core-id-conflict', id }, 409);
+  let body: { recipient?: unknown; permission?: unknown };
+  try { body = await req.json() as typeof body; }
+  catch { return jsonResponse({ error: 'bad_request' }, 400); }
+  if (!body || typeof body.recipient !== 'string' || !TOKEN_PATTERN.test(body.recipient)
+    || (body.permission !== 'view' && body.permission !== 'edit')) {
+    return jsonResponse({ error: 'bad_request', reason: 'recipient access token and view/edit permission required' }, 400);
+  }
+  const recipient = tokenHash(body.recipient);
+  const dir = join(owned.mineDir, '.access');
+  try {
+    const grants = accessGrants(owned.mineDir, id).filter((grant) => grant.recipient !== recipient);
+    grants.push({ recipient, permission: body.permission });
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const target = accessFile(owned.mineDir, id);
+    const temp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+      writeFileSync(temp, JSON.stringify(grants), { mode: 0o600 });
+      renameSync(temp, target);
+    } finally { rmSync(temp, { force: true }); }
+  } catch (error) { return saveFailed(id, error); }
+  return jsonResponse({ recipient, permission: body.permission });
+}
+
+/** The peer token works only on this graph and the requested read/edit operation. */
+export function graphAccessForRequest(pathname: string, method: string, token: string | null, deps: GraphsApiDeps = {}): boolean {
+  const match = /^\/v1\/graphs\/([^/]+)(?:\/(yaml))?$/.exec(pathname);
+  const id = match ? resolveId(match[1]!) : null;
+  if (!id || !token || !TOKEN_PATTERN.test(token)) return false;
+  if (method !== 'GET' && !(method === 'PUT' && match?.[2] === 'yaml')) return false;
+  try {
+    if (!indexByDeclaredId(deps.mineDir ?? mineGraphsDir()).has(id)) return false;
+    if (indexByDeclaredId(deps.coreDir ?? defaultGraphsDir()).has(id)) return false;
+    const wanted = tokenHash(token);
+    return accessGrants(deps.mineDir ?? mineGraphsDir(), id).some((grant) => {
+      const stored = Buffer.from(grant.recipient, 'hex');
+      return timingSafeEqual(stored, Buffer.from(wanted, 'hex')) && (method === 'GET' || grant.permission === 'edit');
+    });
+  } catch (error) {
+    debug.log('nexus.graphs', 'access-read-failed', { id, reason: String(error) }, { level: 'warn' });
+    return false;
+  }
+}
+
 function resolveId(raw: string): string | null {
   let id: string;
   try { id = decodeURIComponent(raw); }
@@ -203,7 +292,10 @@ export function handleGraphsGet(pathname: string, dir = defaultGraphsDir(), deps
 }
 
 /** PUT writes only under the state-root graphs directory. Core YAML is never opened for write. */
-export async function handleGraphsPut(pathname: string, req: Request, deps: GraphsApiDeps = {}): Promise<Response> {
+/** Who authorized a save: the owner, or a peer token holding an «edit» grant (raw token; only a hash prefix is kept). */
+export type GraphSaveActor = { peerToken: string } | null;
+
+export async function handleGraphsPut(pathname: string, req: Request, deps: GraphsApiDeps = {}, actor: GraphSaveActor = null): Promise<Response> {
   const match = /^\/v1\/graphs\/([^/]+)\/yaml$/.exec(pathname);
   if (!match) return jsonResponse({ error: 'not-found' }, 404);
   const id = resolveId(match[1]!);
@@ -229,11 +321,21 @@ export async function handleGraphsPut(pathname: string, req: Request, deps: Grap
   // Writes go only to <mine>/<id>.yaml; a hand-placed file under another name is not edited over HTTP.
   if (existing.file !== `${id}.yaml`) return jsonResponse({ error: 'file-name-mismatch', id, file: existing.file }, 409);
   let written: { version: string; previous: string };
-  try { written = withWizardSteps(mineDir, id, steps, () => writeWithVersion(mineDir, id, existing, body.yaml as string)); }
+  const editedBy = actor ? `peer:${tokenHash(actor.peerToken).slice(0, 8)}` : null;
+  try {
+    written = withWizardSteps(mineDir, id, steps, () => {
+      // Peer save: the marker goes down «before» the bytes, so a crash in between still refuses the run.
+      if (editedBy) writePeerEdit(mineDir, id, { editedBy, version: 'pending', at: new Date().toISOString() });
+      const result = writeWithVersion(mineDir, id, existing, body.yaml as string);
+      if (editedBy) writePeerEdit(mineDir, id, { editedBy, version: result.version, at: new Date().toISOString() });
+      else clearPeerEdit(mineDir, id);
+      return result;
+    });
+  }
   catch (error) { return saveFailed(id, error); }
   const { version, previous } = written;
-  debug.log('nexus.graphs', 'saved', { id, version, previous, steps: steps ? Object.keys(steps).length : 0 });
-  return jsonResponse({ id, source: 'mine', editable: true, saved: true, version, previous });
+  debug.log('nexus.graphs', 'saved', { id, version, previous, steps: steps ? Object.keys(steps).length : 0, ...(editedBy ? { editedBy } : {}) });
+  return jsonResponse({ id, source: 'mine', editable: true, saved: true, version, previous, ...(editedBy ? { editedBy } : {}) });
 }
 
 const VERSION_ID = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z(?:-\d{4})?$/;
@@ -408,8 +510,14 @@ export async function handleGraphsClone(pathname: string, req: Request, deps: Gr
   if (reservedId) return reservedId;
   const coreDir = deps.coreDir ?? defaultGraphsDir();
   const mineDir = deps.mineDir ?? mineGraphsDir();
-  const source = indexByDeclaredId(coreDir).get(id) ?? indexByDeclaredId(mineDir).get(id);
+  const fromCore = indexByDeclaredId(coreDir).get(id);
+  const source = fromCore ?? indexByDeclaredId(mineDir).get(id);
   if (!source) return jsonResponse({ error: 'not-found', id }, 404);
+  // A clone would carry a peer's unapproved change into a graph with no marker — approve first.
+  if (!fromCore) {
+    const gate = peerEditRunGate(mineDir, id);
+    if (!gate.ok) return jsonResponse(peerEditRefusalBody(id, gate), 409);
+  }
   if (indexByDeclaredId(mineDir).has(body.newId) || indexByDeclaredId(coreDir).has(body.newId)) {
     return jsonResponse({ error: 'conflict', id: body.newId }, 409);
   }
@@ -422,9 +530,39 @@ export async function handleGraphsClone(pathname: string, req: Request, deps: Gr
   return jsonResponse({ id: body.newId, source: 'mine', editable: true, clonedFrom: id }, 201);
 }
 
-export async function handleGraphsMutation(pathname: string, req: Request, deps: GraphsApiDeps = {}): Promise<Response | null> {
+/** POST /v1/graphs/<id>/approve {version} — owner only (the route never accepts a peer token). Approves the
+ *  exact peer version the run refusal named; a newer peer save is a new version and needs a new approval. */
+export async function handleGraphsApprove(pathname: string, req: Request, deps: GraphsApiDeps = {}): Promise<Response> {
+  const match = /^\/v1\/graphs\/([^/]+)\/approve$/.exec(pathname);
+  if (!match) return jsonResponse({ error: 'not-found' }, 404);
+  const id = resolveId(match[1]!);
+  if (!id) return jsonResponse({ error: 'bad_request', reason: 'invalid graph id' }, 400);
+  const owned = mineOwnership(id, deps);
+  if (owned instanceof Response) return owned;
+  let body: { version?: unknown };
+  try { body = await req.json() as { version?: unknown }; }
+  catch { return jsonResponse({ error: 'bad_request', reason: 'json body required' }, 400); }
+  if (typeof body?.version !== 'string' || !body.version) return jsonResponse({ error: 'bad_request', reason: 'version string required' }, 400);
+  let record;
+  try { record = readPeerEdit(owned.mineDir, id); }
+  catch (error) { return saveFailed(id, error); }
+  if (!record) return jsonResponse({ id, approved: true, version: body.version, pending: false });
+  if (record.version !== body.version) {
+    return jsonResponse({ error: 'version-mismatch', id, version: record.version, reason: '승인하려는 판이 최신 상대 변경과 다르다 — 다시 확인하라' }, 409);
+  }
+  const approved = { version: record.version, at: new Date().toISOString() };
+  try { writePeerEdit(owned.mineDir, id, { ...record, approved }); }
+  catch (error) { return saveFailed(id, error); }
+  debug.log('nexus.graphs', 'peer-edit-approved', { id, version: record.version, editedBy: record.editedBy });
+  return jsonResponse({ id, approved: true, version: record.version, editedBy: record.editedBy });
+}
+
+export async function handleGraphsMutation(pathname: string, req: Request, deps: GraphsApiDeps = {}, actor: GraphSaveActor = null): Promise<Response | null> {
+  // Only PUT …/yaml is open to a peer token; every other mutation is the owner's alone.
+  if (actor && !(req.method === 'PUT' && /^\/v1\/graphs\/[^/]+\/yaml$/.test(pathname))) return jsonResponse({ error: 'unauthorized' }, 401);
   if (req.method === 'POST' && pathname === '/v1/graphs') return handleGraphsCreate(req, deps);
-  if (req.method === 'PUT' && /^\/v1\/graphs\/[^/]+\/yaml$/.test(pathname)) return handleGraphsPut(pathname, req, deps);
+  if (req.method === 'PUT' && /^\/v1\/graphs\/[^/]+\/yaml$/.test(pathname)) return handleGraphsPut(pathname, req, deps, actor);
+  if (req.method === 'POST' && /^\/v1\/graphs\/[^/]+\/approve$/.test(pathname)) return handleGraphsApprove(pathname, req, deps);
   if (req.method === 'POST' && /^\/v1\/graphs\/[^/]+\/clone$/.test(pathname)) return handleGraphsClone(pathname, req, deps);
   if (req.method === 'POST' && /^\/v1\/graphs\/[^/]+\/revert$/.test(pathname)) return handleGraphsRevert(pathname, req, deps);
   return null;

package/src/nexus/api/http-server.ts

@@ -19,7 +19,9 @@ import { setInProcessOutbound } from '../../domains/outbound-alert.js';
 import { getUserConfig } from '../../user-config.js';
 import type { TelegramEvent } from '../../workflow-runtime/triggers/telegram-source.js';
 import { spawnSync } from 'node:child_process';
-import { isAbsolute } from 'node:path';
+import { isAbsolute, join, dirname, relative } from 'node:path';
+import { homedir } from 'node:os';
+import { readdirSync, realpathSync, statSync } from 'node:fs';
 import { createProject, listProjects } from '../../project/project-store.js';
 import { handleOutputsGet, type OutputsDeps } from './outputs-route.js';
 import { buildGridData, type GridDeps } from './grid.js';
@@ -168,6 +170,7 @@ import { handleBuildsGet, parseBuildsPath } from './builds-api.js';
 import { handleHarnessAskPost, handleHarnessAskStatusGet, handleHarnessRunEventsGet, handleHarnessRunScreenGet, handleHarnessRunsGet, handleHarnessStopPost } from './harness-api.js';
 import { handleHarnessRunTraversalGet } from './harness-traversal.js';
 import { handleLoopEdgesGet } from './loop-edges.js';
+import { handleLoopResourcesGet } from './loop-resources.js';
 import { handleFabricPlans, type FabricPlansRouteOpts } from './fabric-plans.js';
 import { dispatchPersonaRoute } from './personas.js';
 import { handleMe, operatorSignal } from './operator.js';
@@ -368,12 +371,12 @@ import {
 } from './workflows.js';
 import { handleTriggersSnapshot } from './triggers.js';
 import { handleWorkflowTemplatesList } from './workflow-templates.js';
-import { handleGraphVersionsGet, handleGraphsGet, handleGraphsMutation } from './graphs-api.js';
+import { graphAccessForRequest, handleGraphAccess, handleGraphAccessPut, handleGraphVersionsGet, handleGraphsGet, handleGraphsMutation } from './graphs-api.js';
 import { handleGraphKindsGet, handleGraphsValidatePost } from './graph-kinds.js';
-import { handleGraphWizardPost } from './graph-wizard-api.js';
+import { handleGraphWizardPost, handleGraphWizardPacksGet } from './graph-wizard-api.js';
 import { syncInstalledPluginNodes } from '../../graph-kinds/installed-plugin-nodes.js';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
-import { handlePluginsIndexGet, handlePluginsGet, handlePluginsMarketRefresh, handlePluginsInstall, handlePluginsRemove } from './plugins-market.js';
+import { handlePluginsIndexGet, handlePluginsGet, handlePluginsMarketRefresh, handlePluginsInstall, handlePluginsRemove, handlePluginWizardList, handlePluginWizardSave } from './plugins-market.js';
 import { handlePluginsCredentialsGet, handlePluginsCredentialsPut } from './plugins-credentials-api.js';
 import {
   handleWorkflowsList,
@@ -489,11 +492,15 @@ export interface NexusHttpServerOpts {
   fabricPlans?: FabricPlansRouteOpts;
   /** GRAPH-WIZARD 시험 주입(LLM·템플릿 뿌리). 운영은 비워 둔다. */
   graphWizard?: import('../../graph-wizard/generate.js').GraphWizardDeps;
+  /** Roots the remote folder picker may browse (default: the daemon user's home). Tests inject a temp root. */
+  projectFolderRoots?: string[];
   /** Optional installer state root for isolated API consumers and tests. */
   pluginStateRoot?: string;
   outputs?: OutputsDeps;
   /** Read-only grid measurement seam; omitted in production for live HQ and Pod pool reads. */
   grid?: GridDeps;
+  /** Resource observation seam; production reads the same ORCH traffic decision. */
+  loopResources?: Parameters<typeof handleLoopResourcesGet>[0];
   /** DRAFT-METRIC cached source seam; omitted in production for the process-wide TTL cache. */
   draftMetrics?: DraftMetricsSource;
   decisions?: Pick<DecisionsRouteDeps, 'ledger'>;
@@ -846,6 +853,55 @@ export function handleProjectsGet(): Response {
   return jsonResponse({ projects: listProjects() });
 }
 
+function isWithinRoot(path: string, root: string): boolean {
+  const rel = relative(root, path);
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+/**
+ * Remote folder picker: lists sub-folders under an allow-listed root only.
+ * Every path is resolved with realpath first, so `..` segments and symlinks cannot escape the roots;
+ * dot-folders are hidden and symlinked entries that point outside the roots are not listed.
+ */
+export function handleProjectFoldersGet(req: Request, roots: string[] = [homedir()]): Response {
+  const allowed: string[] = [];
+  for (const root of roots) {
+    try { allowed.push(realpathSync(root)); } catch { /* a missing root grants nothing */ }
+  }
+  if (allowed.length === 0) return jsonResponse({ error: 'folder_unavailable' }, 404);
+  const requested = new URL(req.url).searchParams.get('path') ?? allowed[0]!;
+  if (!isAbsolute(requested) || requested.includes('\0')) return jsonResponse({ error: 'invalid_folder' }, 400);
+  let path: string;
+  try { path = realpathSync(requested); }
+  catch {
+    debug.log('nexus.projects', 'folders-unavailable', { reason: 'missing' });
+    return jsonResponse({ error: 'folder_unavailable' }, 404);
+  }
+  if (!allowed.some(root => isWithinRoot(path, root))) {
+    debug.log('nexus.projects', 'folders-refused', { reason: 'outside-roots' });
+    return jsonResponse({ error: 'outside_allowed_roots' }, 403);
+  }
+  try {
+    if (!statSync(path).isDirectory()) return jsonResponse({ error: 'not_directory' }, 400);
+    const folders = readdirSync(path, { withFileTypes: true })
+      .filter(entry => {
+        if (entry.name.startsWith('.')) return false;
+        if (entry.isDirectory()) return true;
+        if (!entry.isSymbolicLink()) return false;
+        try {
+          const target = realpathSync(join(path, entry.name));
+          return statSync(target).isDirectory() && allowed.some(root => isWithinRoot(target, root));
+        } catch { return false; }
+      })
+      .map(entry => ({ name: entry.name, path: join(path, entry.name) }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+    const atRoot = allowed.includes(path);
+    return jsonResponse({ path, parent: atRoot ? null : dirname(path), folders });
+  } catch {
+    return jsonResponse({ error: 'folder_unavailable' }, 404);
+  }
+}
+
 export async function handleProjectsPost(req: Request): Promise<Response> {
   let body: unknown;
   try { body = await req.json(); }
@@ -996,7 +1052,9 @@ export async function routeRequest(
     const offered = req.headers.get('authorization');
     const fallbackAuthorized = fallbackToken !== undefined && offered?.startsWith('Bearer ') === true
       && compareTokenConstTime(offered.slice('Bearer '.length).trim(), fallbackToken);
-    if (!(opts.metaApi ? checkAuth(req, opts.metaApi) : fallbackAuthorized)) {
+    const graphPeerAuthorized = (method === 'GET' || method === 'PUT')
+      && graphAccessForRequest(pathname, method, offered?.startsWith('Bearer ') ? offered.slice(7).trim() : null);
+    if (!(opts.metaApi ? checkAuth(req, opts.metaApi) : fallbackAuthorized) && !graphPeerAuthorized) {
       const name = method === 'POST' && (pathname === '/v1/tasks' || pathname === '/v1/reports/ingest') && opts.metaApi
         ? matchIngestAuthorization(req)?.name
         : undefined;
@@ -1341,6 +1399,11 @@ export async function routeRequest(
 
   // Same owner auth as the neighbouring GETs (short-lived owner tokens · same-origin PWA); #23932 compared the admin
   // bearer only, so a PWA on a short-lived token got 401 and the loop map stayed empty.
+  if (pathname === '/v1/loops/resources' && method === 'GET') {
+    if (!opts.metaApi) return jsonResponse({ error: 'meta-api-runtime-not-wired' }, 503);
+    if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handleLoopResourcesGet(opts.loopResources);
+  }
   if (pathname === '/v1/loops/edges' && method === 'GET') {
     if (!opts.metaApi) return jsonResponse({ error: 'meta-api-runtime-not-wired' }, 503);
     if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -1407,7 +1470,12 @@ export async function routeRequest(
     return handleGraphsValidatePost(req, opts.metaApi);
   }
 
-  // GRAPH-WIZARD — 말 → 그래프 YAML(저장 안 함). 다른 /v1/graphs 쓰기와 같은 인증.
+  // GRAPH-WIZARD — 설치된 팩 목록과 말 → 그래프 YAML(저장 안 함). 같은 소유자 인증.
+  if (method === 'GET' && pathname === '/v1/graphs/wizard/packs') {
+    if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
+    if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handleGraphWizardPacksGet(opts.graphWizard);
+  }
   if (method === 'POST' && pathname === '/v1/graphs/wizard') {
     if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
     if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -1419,6 +1487,10 @@ export async function routeRequest(
     return handleFabricPlans(req, opts.fabricPlans);
   }
 
+  if (pathname === '/v1/projects/folders' && method === 'GET') {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handleProjectFoldersGet(req, opts.projectFolderRoots);
+  }
   if (pathname === '/v1/projects' && (method === 'GET' || method === 'POST')) {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
     return method === 'GET' ? handleProjectsGet() : handleProjectsPost(req);
@@ -1515,6 +1587,10 @@ export async function routeRequest(
         ...opts.decisions,
       });
     }
+    if (method === 'POST' && pathname === '/v1/plugins/wizard') {
+      if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handlePluginWizardSave(req, opts.metaApi, opts.pluginStateRoot);
+    }
     if (method === 'POST' && pathname === '/v1/plugins/install') {
       if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
       return handlePluginsInstall(req, opts.metaApi, opts.pluginStateRoot);
@@ -1534,10 +1610,19 @@ export async function routeRequest(
       if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
       return handlePluginsRemove(req, pluginRemove[1]!, opts.metaApi, opts.pluginStateRoot);
     }
+    if (method === 'PUT' && /^\/v1\/graphs\/[^/]+\/access$/.test(pathname)) {
+      if (!opts.metaApi || bearerCredential(req, opts.metaApi) === undefined) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handleGraphAccessPut(pathname, req);
+    }
     if ((method === 'PUT' || method === 'POST') && (pathname.startsWith('/v1/graphs/') || pathname === '/v1/graphs')) {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
-      if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
-      const mutated = await handleGraphsMutation(pathname, req);
+      const peerMayEdit = method === 'PUT' && graphAccessForRequest(pathname, method,
+        req.headers.get('authorization')?.startsWith('Bearer ') ? req.headers.get('authorization')!.slice(7).trim() : null);
+      const ownerAuthorized = checkAuth(req, opts.metaApi);
+      if (!ownerAuthorized && !peerMayEdit) return jsonResponse({ error: 'unauthorized' }, 401);
+      // A peer save is recorded on the graph so every run path refuses it until the owner approves (W9c run guard).
+      const mutated = await handleGraphsMutation(pathname, req, {}, ownerAuthorized ? null
+        : { peerToken: req.headers.get('authorization')!.slice(7).trim() });
       if (mutated) return mutated;
     }
     const cardClose = /^\/v1\/task-cards\/([^/]+)\/close$/.exec(pathname);
@@ -2829,6 +2914,10 @@ export async function routeRequest(
   // surface (`/v1/workflows` · `~/.elanous/workflows-runs/`) covers the same
   // user need.
 
+  if (method === 'GET' && pathname === '/v1/plugins/wizard') {
+    if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handlePluginWizardList(req, opts.metaApi, opts.pluginStateRoot);
+  }
   const pluginCredentialsGet = /^\/v1\/plugins\/([^/]+)\/credentials$/.exec(pathname);
   if (method === 'GET' && pluginCredentialsGet) {
     if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
@@ -2844,6 +2933,10 @@ export async function routeRequest(
     catch (error) { debug.log('graph.kinds', 'installed-sync-failed', { reason: String(error) }); }
     return handleGraphKindsGet(req, opts.metaApi);
   }
+  if (method === 'GET' && /^\/v1\/graphs\/[^/]+\/access$/.test(pathname)) {
+    if (!opts.metaApi || bearerCredential(req, opts.metaApi) === undefined) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handleGraphAccess(pathname, req);
+  }
   // F-M1 read + P-F1 raw YAML. Writes live in the mutation block and never touch core graphs/.
   if (method === 'GET' && (pathname === '/v1/graphs' || /^\/v1\/graphs\/[^/]+$/.test(pathname) || /^\/v1\/graphs\/[^/]+\/yaml$/.test(pathname))) {
     return handleGraphsGet(pathname);

package/src/nexus/api/loop-resources.ts

@@ -0,0 +1,42 @@
+import { defaultListHarnessProcesses } from '../../harness/harness-cli-command.js';
+import { devVersion, listChecklist } from '../../release-loop/checklist.js';
+import { listSchedules } from '../../release-loop/release-schedule.js';
+import { releaseLedgerRoot } from '../../instance/resolve.js';
+import { getUserConfig, ORCHESTRATOR_DEFAULTS } from '../../user-config.js';
+import { seatOfTree, trafficTick, TRAFFIC_SEATS, type TrafficCell, type TrafficResult } from '../../loops/orchestrator/traffic.js';
+import { finishAdvice, measureFinish } from '../../loops/orchestrator/finish-rate.js';
+import { jsonResponse } from './json-response.js';
+
+/** Read-only snapshot of the same ORCH traffic decision used by the scheduled tick. */
+export function observeLoopResources(deps: {
+  now?: Date;
+  processes?: ReturnType<typeof defaultListHarnessProcesses>;
+  version?: string;
+  openCells?: readonly TrafficCell[];
+  nextRound?: readonly TrafficCell[];
+  totalSlots?: number;
+} = {}): TrafficResult {
+  const now = deps.now ?? new Date();
+  const cfg = getUserConfig().loops?.orchestrator ?? ORCHESTRATOR_DEFAULTS;
+  const observation = deps.processes ?? defaultListHarnessProcesses();
+  if (observation.status !== 'ok') throw new Error(`process observation ${observation.status}`);
+  const version = deps.version ?? devVersion().replace(/-dev\.\d+$/, '');
+  const upcoming = deps.nextRound === undefined ? listSchedules(releaseLedgerRoot()).filter(row => Date.parse(row.cutAt) > now.getTime())
+    .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt)) : [];
+  const currentIndex = upcoming.findIndex(row => row.version === version);
+  const nextVersion = currentIndex < 0 ? upcoming[0]?.version : upcoming[currentIndex + 1]?.version;
+  const totalSlots = deps.totalSlots ?? finishAdvice(measureFinish({}, now),
+    TRAFFIC_SEATS.reduce((sum, seat) => sum + cfg.seatCaps[seat], 0)).launchSlots;
+  return trafficTick({
+    processes: observation.records.map(process => ({ ...process, seat: seatOfTree(process.cwdStatus === 'unknown' ? undefined : process.cwd, cfg) })),
+    now, caps: cfg.seatCaps, openCells: deps.openCells ?? listChecklist(version).items, totalSlots,
+    ...(deps.nextRound !== undefined ? { nextRound: deps.nextRound }
+      : nextVersion ? { nextRound: listChecklist(nextVersion).items } : {}),
+    retainQueuedCells: true,
+  });
+}
+
+export function handleLoopResourcesGet(observe: () => TrafficResult = observeLoopResources): Response {
+  try { return jsonResponse({ resource: observe() }); }
+  catch { return jsonResponse({ error: 'resource-unavailable' }, 503); }
+}