elanous 0.2.43 → 0.2.44

package/src/cli/setup-keys.ts

@@ -12,6 +12,12 @@ export interface SetupKeysIO {
   print(message: string): void;
 }
 
+export type SetupKeyProvider = Extract<(typeof SERVICE_KEY_CATALOG)[number], { kind: 'api-key' }>['id'];
+export type SetupKeyValidationResult =
+  | { success: true; verification: 'verified' | 'unsupported' }
+  | { success: false; reason: 'invalid' | 'rate-limited' | 'unavailable'; httpStatus?: number };
+export type SetupKeyVerifier = (input: { provider: SetupKeyProvider; apiKey: string }) => Promise<SetupKeyValidationResult>;
+
 export interface SetupKeysOptions {
   config: UserConfig;
   env?: NodeJS.ProcessEnv;
@@ -19,6 +25,8 @@ export interface SetupKeysOptions {
   includeOptional?: boolean;
   /** Existing OAuth fetch injection used by deterministic login simulation. */
   loginWithCodex?: typeof loginWithCodex;
+  /** Verification seam for deterministic setup simulations; the production default remains verifyServiceKey. */
+  verifier?: SetupKeyVerifier;
 }
 
 function providerForService(id: string): string | undefined {
@@ -80,20 +88,24 @@ export async function importServiceKeys(values: ParsedServiceKeyEnv, io: Pick<Se
     const item = SERVICE_KEY_CATALOG.find(candidate => candidate.kind === 'api-key' && candidate.envNames.includes(name));
     if (!item) { rejected.push(name); continue; }
     if (env[name]?.trim() === value) io.print(`${name}: 환경에서 이미 제공됨 · 캐시에도 저장합니다 · 값 출력 0`);
-    const verification = await verifyServiceKey(item.id, value, {
-      env,
-      cacheDir: options.cacheDir,
-      baseUrl: providerBaseUrl(options.config, item.id),
-    });
-    if (verification.result === 'verified') accepted.set(name, value);
-    else if (verification.result === 'unsupported') {
+    const verification = options.verifier
+      ? await options.verifier({ provider: item.id as SetupKeyProvider, apiKey: value })
+      : await verifyServiceKey(item.id, value, {
+        env,
+        cacheDir: options.cacheDir,
+        baseUrl: providerBaseUrl(options.config, item.id),
+      }).then(({ result, httpStatus }): SetupKeyValidationResult => result === 'verified' || result === 'unsupported'
+        ? { success: true, verification: result }
+        : { success: false, reason: result, ...(httpStatus === undefined ? {} : { httpStatus }) });
+    if (verification.success && verification.verification === 'verified') accepted.set(name, value);
+    else if (verification.success && verification.verification === 'unsupported') {
       accepted.set(name, value);
       unverified.push(name);
       io.print(`${item.label}: 최소 확인을 지원하지 않아 검증 없이 저장합니다 · 값 출력 0`);
     }
     else {
       rejected.push(name);
-      io.print(`${item.label}: 검증 ${verification.result}${verification.httpStatus ? ` (HTTP ${verification.httpStatus})` : ''} · 저장 안 함`);
+      io.print(`${item.label}: 검증 ${verification.reason}${verification.httpStatus ? ` (HTTP ${verification.httpStatus})` : ''} · 저장 안 함`);
     }
   }
   const saved = accepted.size ? storeServiceKeys(accepted, { env, cacheDir: options.cacheDir }) : { stored: [] };

package/src/cli/tui-test-cli.ts

@@ -38,8 +38,12 @@ export function pwaBuildDecision(pwaDir: string, withPwaBuild = false): 'build'
   return withPwaBuild ? 'build' : 'skip';
 }
 
-export function buildHeldTuiArgs(entry: string, tuiStateDir: string, readyTimeoutMs: number, cwd: string): string[] {
-  return [entry, '--test', 'dev', '--elanous', '--hold', '--json', '--isolated-root', tuiStateDir, '--ready-timeout-ms', String(readyTimeoutMs), '--cwd', cwd];
+export function buildHeldTuiArgs(entry: string, testStateDir: string, readyTimeoutMs: number, cwd: string): string[] {
+  return [entry, '--test', 'dev', '--elanous', '--hold', '--json', '--isolated-root', testStateDir, '--ready-timeout-ms', String(readyTimeoutMs), '--cwd', cwd];
+}
+
+export function buildHeldTuiLaunch(entry: string, testStateDir: string, readyTimeoutMs: number, cwd: string): { args: string[]; stateDir: string } {
+  return { args: buildHeldTuiArgs(entry, testStateDir, readyTimeoutMs, cwd).slice(1), stateDir: testStateDir };
 }
 
 export function parseReadyHeldPty(output: string): { id: string; runId: string } | undefined {
@@ -77,9 +81,10 @@ function launchHeldTui(entry: string, cwd: string, env: NodeJS.ProcessEnv, state
   const logFd = openSync(logPath, 'a', 0o600);
   let child: ChildProcess;
   try {
-    child = spawnElanous(buildHeldTuiArgs(entry, join(stateDir, '..', '.elanous-test-tui'), Math.max(1, deadline - Date.now()), cwd).slice(1), {
+    const launch = buildHeldTuiLaunch(entry, stateDir, Math.max(1, deadline - Date.now()), cwd);
+    child = spawnElanous(launch.args, {
       bin: entry,
-      stateDir: join(stateDir, '..', '.elanous-test-tui'),
+      stateDir: launch.stateDir,
       cwd, env, detached: true, stdio: ['ignore', logFd, logFd],
     });
   } finally {
@@ -142,7 +147,6 @@ export async function runTuiTestUniverse(options: { readyTimeoutMs?: number; wit
 
   const entry = join(worktree, 'bin/elanous.mjs');
   const testStateDir = join(worktree, '.elanous-test');
-  const tuiStateDir = join(worktree, '.elanous-test-tui');
   const testEnv = { ...process.env };
   delete testEnv.ELANOUS_STATE_DIR;
   delete testEnv.ELANOUS_CONFIG_DIR;

package/src/control-plane/ledger.ts

@@ -20,7 +20,7 @@ export interface ResourceRecord {
 export type ResourceView = ResourceRecord & { ageMs: number; expired: boolean };
 
 export interface PodWorkerKey { context: string; imageDigest: string; lockHash: string; architecture: string }
-type PodWorkerState = 'idle' | 'leased' | 'sanitizing' | 'timeout-fenced' | 'quarantined';
+type PodWorkerState = 'idle' | 'leased' | 'sanitizing' | 'timeout-fenced' | 'quarantined' | 'reaping';
 interface PodWorkerLeaseAttrs {
   key: PodWorkerKey;
   podUid: string;
@@ -35,6 +35,8 @@ interface PodWorkerLeaseAttrs {
   timeoutFenceUntil?: number;
   timeoutRunId?: string;
   timeoutAttemptId?: string;
+  timeoutPreviousObservedAt?: number;
+  timeoutPreviousTtlMs?: number;
   runId?: string;
   attemptId?: string;
   reason?: string;
@@ -216,6 +218,13 @@ export class ResourceLedger {
     now ??= Date.now();
     const rows = this.read();
     const id = `pod-worker-lease:${request.workerId}`;
+    if (rows.some(row => {
+      if (row.kind !== 'pod-worker-lease' || row.name === request.workerId) return false;
+      const attrs = workerAttrs(row);
+      return attrs.podUid === request.podUid
+        && (attrs.state === 'quarantined' || attrs.state === 'timeout-fenced' || attrs.state === 'reaping');
+    }))
+      throw new ResourceLedgerError(409, 'pod-uid-already-registered');
     const index = rows.findIndex(row => row.id === id);
     const previous = index < 0 ? undefined : rows[index]!;
     if (previous && previous.kind !== 'pod-worker-lease') throw new ResourceLedgerError(409, 'worker-id-conflict');
@@ -244,8 +253,10 @@ export class ResourceLedger {
       const idleAttrs: PodWorkerLeaseAttrs = { ...candidateAttrs, state: 'idle' };
       delete idleAttrs.leaseId; delete idleAttrs.leaseOwner; delete idleAttrs.runId; delete idleAttrs.attemptId;
       delete idleAttrs.timeoutFenceUntil; delete idleAttrs.timeoutRunId; delete idleAttrs.timeoutAttemptId;
-      rows[rowIndex] = { ...candidate, attrs: idleAttrs as unknown as Record<string, unknown>, observedAt: at,
-        ttlMs: candidateAttrs.idleTtlMs };
+      const observedAt = candidateAttrs.timeoutPreviousObservedAt ?? at;
+      const ttlMs = candidateAttrs.timeoutPreviousTtlMs ?? candidateAttrs.idleTtlMs;
+      delete idleAttrs.timeoutPreviousObservedAt; delete idleAttrs.timeoutPreviousTtlMs;
+      rows[rowIndex] = { ...candidate, attrs: idleAttrs as unknown as Record<string, unknown>, observedAt, ttlMs };
       expiredFenceChanged = true;
     }
     const index = rows.findIndex(row => row.kind === 'pod-worker-lease' && (!request.machine || row.machine === request.machine)
@@ -283,12 +294,16 @@ export class ResourceLedger {
         && attrs.timeoutAttemptId === request.attemptId;
       const sameLease = attrs.state === 'leased' && attrs.leaseOwner === request.owner
         && attrs.runId === request.runId && attrs.attemptId === request.attemptId;
-      const available = attrs.state === 'idle';
+      const available = attrs.state === 'idle' && Math.max(0, at - row.observedAt) < row.ttlMs;
       if (!request.owner || !request.runId || !request.attemptId || !Number.isSafeInteger(request.fenceMs)
         || request.fenceMs < 1 || !(sameFence || sameLease || available))
         throw new ResourceLedgerError(409, 'stale-timeout-fence');
       const nextAttrs: PodWorkerLeaseAttrs = { ...attrs, state: 'timeout-fenced',
         timeoutFenceUntil: at + request.fenceMs, timeoutRunId: request.runId, timeoutAttemptId: request.attemptId };
+      if (available) {
+        nextAttrs.timeoutPreviousObservedAt = row.observedAt;
+        nextAttrs.timeoutPreviousTtlMs = row.ttlMs;
+      }
       const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>, observedAt: at };
       rows[index] = next;
       this.write(rows);
@@ -296,6 +311,29 @@ export class ResourceLedger {
     });
   }
 
+  /** Atomically reserves a fenced Pod UID so a timeout-fence expiry cannot make it leasable during deletion. */
+  reservePodWorkerReap(id: string, request: { machine: string; podUid: string }, now?: number): ResourceRecord {
+    return this.mutate(() => {
+      now ??= Date.now();
+      const rows = this.read();
+      const index = rows.findIndex(row => row.id === id && row.kind === 'pod-worker-lease');
+      if (index < 0) throw new ResourceLedgerError(404, 'not-found');
+      const row = rows[index]!;
+      const attrs = workerAttrs(row);
+      if (row.machine !== request.machine || attrs.podUid !== request.podUid || attrs.leaseId
+        || !['quarantined', 'timeout-fenced', 'reaping'].includes(attrs.state))
+        throw new ResourceLedgerError(409, 'pod-worker-reap-not-eligible');
+      if (rows.some((other, otherIndex) => otherIndex !== index && other.kind === 'pod-worker-lease'
+        && workerAttrs(other).podUid === request.podUid))
+        throw new ResourceLedgerError(409, 'pod-worker-uid-has-other-lease');
+      const next: ResourceRecord = { ...row,
+        attrs: { ...attrs, state: 'reaping' } as unknown as Record<string, unknown>, observedAt: now };
+      rows[index] = next;
+      this.write(rows);
+      return next;
+    });
+  }
+
   transitionPodWorker(id: string, request: { owner: string; leaseId: string; generation: number; action: 'renew' | 'release' | 'sanitize' | 'quarantine'; ttlMs?: number; reason?: string }, now?: number): ResourceRecord {
     return this.mutate(() => {
     now ??= Date.now();

package/src/control-plane/member-tokens.ts

@@ -1,6 +1,6 @@
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import { chmodSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, fsyncSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 
 interface MemberTokenEntry { sha256: string; issuedAt: string }
@@ -65,6 +65,29 @@ export function issueMemberToken(machine: string, root: string = effectiveInstan
   return token;
 }
 
+/** Issue a member credential into a new private file without sending the value to stdout. */
+export function issueMemberTokenToFile(machine: string, tokenFile: string, root: string = effectiveInstanceRoot()): void {
+  checkMachine(machine);
+  if (!isAbsolute(tokenFile)) throw new Error('token file path must be absolute');
+  const token = randomBytes(32).toString('hex');
+  mkdirSync(dirname(tokenFile), { recursive: true, mode: 0o700 });
+  let outputCreated = false;
+  try {
+    const fd = openSync(tokenFile, 'wx', 0o600);
+    outputCreated = true;
+    try {
+      writeFileSync(fd, `${token}\n`, 'utf8');
+      fsyncSync(fd);
+    } finally { closeSync(fd); }
+    const entries = readStore(root);
+    entries[machine] = { sha256: createHash('sha256').update(token).digest('hex'), issuedAt: new Date().toISOString() };
+    writeStore(root, entries);
+  } catch (error) {
+    if (outputCreated) try { unlinkSync(tokenFile); } catch { /* retain the original failure */ }
+    throw error;
+  }
+}
+
 export function revokeMemberToken(machine: string, root: string = effectiveInstanceRoot()): void {
   checkMachine(machine);
   const entries = readStore(root);

package/src/control-plane/ports.ts

@@ -1,9 +1,12 @@
 import { ResourceLedger, ResourceLedgerError, type ResourceRecord } from './ledger.js';
 import { DEFAULT_NEXUS_HTTP_PORT } from '../nexus/default-port.js';
 
-/** Inclusive port bands; only the test band is allocated by the coordinator. */
+/** Release PWA bind configured by OP; isolated test leases must never claim it. */
+export const RELEASE_PWA_FIXED_HTTP_PORT = 31453;
+
+/** Inclusive port bands. Fixed release PWA ports are reserved from every isolated test allocator. */
 export const PORT_BANDS = {
-  reserved: [31413, DEFAULT_NEXUS_HTTP_PORT, 31420],
+  reserved: [31413, DEFAULT_NEXUS_HTTP_PORT, 31420, RELEASE_PWA_FIXED_HTTP_PORT],
   test: { start: 31450, end: 31499 },
   offline: { start: 31500, end: 31509 },
 } as const;
@@ -36,5 +39,7 @@ export function leasePort(request: PortLeaseRequest, ledger: ResourceLedger, now
     throw new ResourceLedgerError(400, 'invalid-port-lease');
   }
   const owner = request.owner ?? machine;
-  return ledger.leaseTestPort({ machine, purpose, ttlMs: Math.min(ttlMs, MAX_PORT_LEASE_TTL_MS), owner }, PORT_BANDS.test, now, request.excluded);
+  const reservedTestPorts = PORT_BANDS.reserved.filter(port => port >= PORT_BANDS.test.start && port <= PORT_BANDS.test.end);
+  const excluded = [...new Set([...(request.excluded ?? []), ...reservedTestPorts])];
+  return ledger.leaseTestPort({ machine, purpose, ttlMs: Math.min(ttlMs, MAX_PORT_LEASE_TTL_MS), owner }, PORT_BANDS.test, now, excluded);
 }

package/src/control-plane/server.ts

@@ -12,12 +12,17 @@ export const CONTROL_HOSTNAME = '127.0.0.1';
 const MAX_POD_WORKER_TTL_MS = 24 * 60 * 60 * 1000;
 const POD_WORKER_TIMEOUT_FENCE_MS = 150_000;
 
-export function allowedControlHostname(hostname: string): boolean {
+function controlHostnameAllowed(hostname: string, allowClusterBind: boolean): boolean {
+  // Cluster-facing binds require an explicit opt-in; wildcard exposure is never inferred from the address.
+  if (hostname === '0.0.0.0') return allowClusterBind;
   if (hostname === '127.0.0.1' || hostname === '::1') return true;
   const parts = hostname.split('.');
   if (parts.length !== 4 || !parts.every(part => /^(0|[1-9]\d{0,2})$/.test(part) && Number(part) <= 255)) return false;
   return parts[0] === '100' && Number(parts[1]) >= 64 && Number(parts[1]) <= 127;
 }
+export function allowedControlHostname(hostname: string): boolean {
+  return controlHostnameAllowed(hostname, false);
+}
 export type ControlScope = 'admin' | 'member' | 'query';
 export type ControlTokens = Record<ControlScope, string>;
 
@@ -89,6 +94,7 @@ export interface ControlServerOptions {
   root?: string;
   port?: number;
   hostname?: string;
+  allowClusterBind?: boolean;
   leaseView?: LeaseHolderView;
   requireKnownLeaseForWrites?: boolean;
 }
@@ -99,7 +105,7 @@ export function startControlServer(opts: ControlServerOptions = {}): {
   stop(): void;
 } {
   const hostname = opts.hostname ?? CONTROL_HOSTNAME;
-  if (!allowedControlHostname(hostname)) throw new Error('invalid control hostname');
+  if (!controlHostnameAllowed(hostname, opts.allowClusterBind ?? false)) throw new Error('invalid control hostname');
   const root = opts.root ?? effectiveInstanceRoot();
   const tokens = ensureControlTokens(root);
   const ledger = new ResourceLedger(root);
@@ -127,7 +133,7 @@ export function startControlServer(opts: ControlServerOptions = {}): {
         const leaseRenewal = /^\/v1\/leases\/port\/([^/]+)\/heartbeat$/.exec(path);
         const workerRegister = path === '/v1/workers/pod' && method === 'POST';
         const workerAcquire = path === '/v1/leases/pod-worker' && method === 'POST';
-        const workerTransition = /^\/v1\/leases\/pod-worker\/([^/]+)\/(renew|release|sanitize|quarantine|timeout)$/.exec(path);
+        const workerTransition = /^\/v1\/leases\/pod-worker\/([^/]+)\/(renew|release|sanitize|quarantine|timeout|reap)$/.exec(path);
         if (!resourcePath && !registerPath && !leaseRequest && !workerRegister && !workerAcquire && !(workerTransition && method === 'POST') && !(leaseDeletion && method === 'DELETE') && !(leaseRenewal && method === 'POST') && !(heartbeat && method === 'POST') && !(deletion && method === 'DELETE')) {
           return json({ error: 'not-found' }, 404);
         }
@@ -177,10 +183,13 @@ export function startControlServer(opts: ControlServerOptions = {}): {
               () => ledger.registerPodWorker({ workerId, machine: workerMachine, podUid, key: podWorkerKey(key), ttlMs, owner })));
           }
           if (workerAcquire) {
-            if (scope !== 'member') throw new ResourceLedgerError(403, 'worker-consumer-required');
+            // A host-scoped provider may acquire only its own worker lease. Global consumers
+            // retain the member scope; a machine credential can never select another host.
+            if (scope !== 'member' && !machine) throw new ResourceLedgerError(403, 'worker-consumer-required');
             const body = podWorkerBody(await req.json());
             const { machine: workerMachine, key, runId, attemptId, ttlMs } = body;
             if (workerMachine !== undefined && (typeof workerMachine !== 'string' || !workerMachine.trim())) throw new ResourceLedgerError(400, 'invalid-pod-worker-lease');
+            if (machine && workerMachine !== machine) throw new ResourceLedgerError(403, 'machine-scope');
             if (typeof runId !== 'string' || !runId.trim() || typeof attemptId !== 'string' || !attemptId.trim()
               || typeof ttlMs !== 'number' || !Number.isSafeInteger(ttlMs) || ttlMs <= 0 || ttlMs > MAX_POD_WORKER_TTL_MS) throw new ResourceLedgerError(400, 'invalid-pod-worker-lease');
             const stale = await currentWorkerPrimary();
@@ -192,7 +201,19 @@ export function startControlServer(opts: ControlServerOptions = {}): {
           if (workerTransition) {
             const workerId = decodeURIComponent(workerTransition[1]!);
             if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,95}$/.test(workerId)) throw new ResourceLedgerError(400, 'invalid-worker-id');
-            const action = workerTransition[2] as 'renew' | 'release' | 'sanitize' | 'quarantine' | 'timeout';
+            const action = workerTransition[2] as 'renew' | 'release' | 'sanitize' | 'quarantine' | 'timeout' | 'reap';
+            if (action === 'reap') {
+              if (!machine) throw new ResourceLedgerError(403, 'worker-reap-host-required');
+              const body = podWorkerBody(await req.json());
+              const podUid = body.podUid;
+              if (typeof podUid !== 'string' || !podUid.trim()) throw new ResourceLedgerError(400, 'invalid-pod-worker-reap');
+              const id = `pod-worker-lease:${workerId}`;
+              requireTarget(id);
+              const stale = await currentWorkerPrimary();
+              if (stale) return stale;
+              return json(await ledger.withGuardedWorkerMutation(async () => !(await currentWorkerPrimary()),
+                () => ledger.reservePodWorkerReap(id, { machine, podUid })));
+            }
             if (action === 'timeout') {
               if (scope !== 'member') throw new ResourceLedgerError(403, 'worker-timeout-scope');
               const body = podWorkerBody(await req.json());

package/src/core-turn/research-policy.ts

@@ -1,12 +1,18 @@
 /** Shared guardrails for every core-turn research surface. */
 export const RESEARCH_TURN_MAX_TOOL_TURNS = 20;
 export const RESEARCH_TURN_FIRST_REPLY_BUDGET_MS = 15_000;
-export const RESEARCH_TURN_DEEP_BUDGET_MS = 3 * 60_000;
+/** Research returns its best partial evidence before the parent has to abort the turn. */
+export const RESEARCH_TURN_FINAL_ANSWER_DEADLINE_MS = 8 * 60_000;
+export const RESEARCH_TURN_DEEP_BUDGET_MS = 9 * 60_000;
+export const RESEARCH_TURN_SHALLOW_BUDGET_MS = 3 * 60_000;
+/** Leave time for shallow partial-answer synthesis before the unchanged parent timeout. */
+export const RESEARCH_TURN_SHALLOW_FINAL_ANSWER_DEADLINE_MS = RESEARCH_TURN_SHALLOW_BUDGET_MS - 10_000;
 export const RESEARCH_TURN_DEADLINE_STOP_ERROR = 'research stopped by its deadline';
 
 /** Research turns only receive these tools; unrelated writers are never implicit. */
 export const RESEARCH_TOOL_ALLOWLIST = [
   'OmniSearch',
+  'WebSearch',
   'WebFetch',
   'Agent',
   'Read',