elanous 0.2.37 → 0.2.40

package/src/live-supply/collector.ts

@@ -0,0 +1,149 @@
+import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { SUPPLY_AXES, type LiveSupplySnapshot, type SupplyAxis, type SupplyEvent, type SupplyProbes, type SupplySourceState, type SupplyValues } from './snapshot.js';
+
+export interface SupplyCollectorOptions {
+  directory?: string;
+  now?: () => number;
+  intervalMs?: number;
+  probeTimeoutMs?: number;
+  setInterval?: typeof globalThis.setInterval;
+  clearInterval?: typeof globalThis.clearInterval;
+}
+
+function readLatest(path: string): LiveSupplySnapshot | null {
+  try {
+    const row = JSON.parse(readFileSync(path, 'utf8')) as LiveSupplySnapshot;
+    return row.version === 1 && Number.isSafeInteger(row.sequence) ? row : null;
+  } catch { return null; }
+}
+
+/** A failed source retains its last value only with a stale label. Each tick commits before it publishes events. */
+export class LiveSupplyCollector {
+  readonly directory: string;
+  private readonly now: () => number;
+  private readonly intervalMs: number;
+  private readonly probeTimeoutMs: number;
+  private readonly setInterval: typeof globalThis.setInterval;
+  private readonly clearInterval: typeof globalThis.clearInterval;
+  private latest: LiveSupplySnapshot | null;
+  private hasFreshTick = false;
+  private pending: Promise<LiveSupplySnapshot> | null = null;
+  private timer: ReturnType<typeof globalThis.setInterval> | null = null;
+
+  constructor(private readonly probes: SupplyProbes, options: SupplyCollectorOptions = {}) {
+    this.directory = options.directory ?? join(getElanousConfigDir(), 'live-supply');
+    this.now = options.now ?? Date.now;
+    this.intervalMs = options.intervalMs ?? 60_000;
+    this.probeTimeoutMs = options.probeTimeoutMs ?? 10_000;
+    this.setInterval = options.setInterval ?? globalThis.setInterval;
+    this.clearInterval = options.clearInterval ?? globalThis.clearInterval;
+    this.latest = readLatest(join(this.directory, 'latest.json'));
+  }
+
+  /** Disk cache is diagnostic until a fresh tick; a restart never silently blesses old measurements. */
+  read(): LiveSupplySnapshot | null {
+    if (!this.latest) return null;
+    if (this.hasFreshTick && Date.parse(this.latest.expiresAt) > this.now()) return this.latest;
+    return {
+      ...this.latest,
+      sources: Object.fromEntries(SUPPLY_AXES.map(axis => [axis, {
+        ...this.latest!.sources[axis],
+        status: this.latest!.sources[axis].status === 'measured' ? 'stale' : this.latest!.sources[axis].status,
+      }])) as LiveSupplySnapshot['sources'],
+    };
+  }
+
+  async start(): Promise<LiveSupplySnapshot> {
+    const first = await this.tick();
+    if (this.timer === null) this.timer = this.setInterval(() => { void this.tick().catch(() => {}); }, this.intervalMs);
+    return first;
+  }
+
+  stop(): void {
+    if (this.timer !== null) this.clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  tick(): Promise<LiveSupplySnapshot> {
+    if (this.pending) return this.pending;
+    const work = this.collect();
+    this.pending = work;
+    void work.finally(() => { if (this.pending === work) this.pending = null; }).catch(() => {});
+    return work;
+  }
+
+  private async collect(): Promise<LiveSupplySnapshot> {
+    const previous = this.latest;
+    const at = new Date(this.now()).toISOString();
+    const sources = {} as LiveSupplySnapshot['sources'];
+    const values: Partial<SupplyValues> = {};
+    const results = await Promise.all(SUPPLY_AXES.map(async axis => {
+      try { return { axis, value: await this.withTimeout(this.probes[axis]()), error: null }; }
+      catch (error) { return { axis, value: null, error: error instanceof Error ? error.message : 'probe-failed' }; }
+    }));
+    for (const result of results) {
+      const axis = result.axis;
+      if (result.error === null && result.value !== null) {
+        (values as Record<SupplyAxis, unknown>)[axis] = result.value;
+        sources[axis] = { status: 'measured', observedAt: at, reason: null };
+      } else {
+        const oldValue = previous?.values[axis];
+        if (oldValue !== undefined) (values as Record<SupplyAxis, unknown>)[axis] = oldValue;
+        const oldAt = previous?.sources[axis]?.observedAt ?? null;
+        sources[axis] = { status: oldValue === undefined ? 'unknown' : 'stale', observedAt: oldAt, reason: this.safeReason(result.error) };
+      }
+    }
+    const snapshot: LiveSupplySnapshot = {
+      version: 1, sequence: (previous?.sequence ?? 0) + 1, observedAt: at,
+      expiresAt: new Date(this.now() + this.intervalMs).toISOString(), sources, values,
+    };
+    const events = this.events(previous, snapshot);
+    mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+    const latestPath = join(this.directory, 'latest.json');
+    const tempPath = join(this.directory, `.latest.${process.pid}.${snapshot.sequence}.tmp`);
+    try {
+      appendFileSync(join(this.directory, 'snapshots.jsonl'), `${JSON.stringify(snapshot)}\n`, { mode: 0o600 });
+      writeFileSync(tempPath, JSON.stringify(snapshot), { mode: 0o600 });
+      renameSync(tempPath, latestPath);
+      this.latest = snapshot;
+      this.hasFreshTick = true;
+    } catch (error) {
+      // The pointer must never claim freshness after an unsuccessful commit.
+      this.latest = previous;
+      throw error;
+    }
+    if (events.length) appendFileSync(join(this.directory, 'events.jsonl'), events.map(event => JSON.stringify(event)).join('\n') + '\n', { mode: 0o600 });
+    return snapshot;
+  }
+
+  private withTimeout<T>(value: Promise<T> | T): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const timer = globalThis.setTimeout(() => reject(new Error('probe-timeout')), this.probeTimeoutMs);
+      Promise.resolve(value).then(
+        result => { globalThis.clearTimeout(timer); resolve(result); },
+        error => { globalThis.clearTimeout(timer); reject(error); },
+      );
+    });
+  }
+
+  private safeReason(reason: string | null): string {
+    if (reason === 'probe-timeout') return reason;
+    return reason === null ? 'probe-unmeasured' : 'probe-failed';
+  }
+
+  private events(previous: LiveSupplySnapshot | null, next: LiveSupplySnapshot): SupplyEvent[] {
+    const rows: SupplyEvent[] = [];
+    for (const axis of SUPPLY_AXES) {
+      const before = previous?.sources[axis] as SupplySourceState | undefined;
+      const after = next.sources[axis];
+      if (after.status !== 'measured' && (before?.status !== after.status || before?.reason !== after.reason)) {
+        rows.push({ kind: 'supply.unmeasured', sequence: next.sequence, axis, from: before?.status ?? 'unknown', to: after.status, reason: after.reason, observedAt: next.observedAt });
+      } else if (before && (before.status !== after.status || JSON.stringify(previous?.values[axis]) !== JSON.stringify(next.values[axis]))) {
+        rows.push({ kind: 'supply.changed', sequence: next.sequence, axis, from: before.status, to: after.status, reason: null, observedAt: next.observedAt });
+      }
+    }
+    return rows;
+  }
+}

package/src/live-supply/probes.ts

@@ -0,0 +1,52 @@
+import { inspectCodexRotation, readCachedGrokQuota } from '../oauth/codex-account-store.js';
+import { readParentHostCapacity, type ParentHostConfig } from '../task-agent/parent-host.js';
+import { measureMemberOccupancy, parsePodPool } from '../task-orchestrator/surfaces/pod-pool.js';
+import type { SupplyProbes, SupplyValues } from './snapshot.js';
+
+/** Host credential and cost transports are caller-owned: this module never transfers secret material. */
+export interface SupplyProbeDependencies {
+  podPoolSpec: () => string | null;
+  parentHosts: () => readonly ParentHostConfig[];
+  readCost: () => Promise<SupplyValues['cost']> | SupplyValues['cost'];
+  readHostCredentials: () => Promise<SupplyValues['hostCredentials']> | SupplyValues['hostCredentials'];
+  inspectCodex?: typeof inspectCodexRotation;
+  grokQuota?: typeof readCachedGrokQuota;
+  occupancy?: typeof measureMemberOccupancy;
+  parentCapacity?: typeof readParentHostCapacity;
+}
+
+/** Existing provider and pool readers are projected to the no-secret supply contract. */
+export function createSupplyProbes(deps: SupplyProbeDependencies): SupplyProbes {
+  return {
+    codex: () => {
+      const state = (deps.inspectCodex ?? inspectCodexRotation)();
+      return { accounts: state.candidates.map(candidate => ({
+        name: candidate.name,
+        usedPercent: candidate.usedPercent ?? null,
+        signalAt: state.observedAtByHome[candidate.home] === undefined ? null : new Date(state.observedAtByHome[candidate.home]).toISOString(),
+        available: state.freshByHome[candidate.home] !== true ? null : candidate.reached === true ? false : null,
+      })) };
+    },
+    grok: () => ({ quota: (deps.grokQuota ?? readCachedGrokQuota)(), observedAt: null }),
+    cost: deps.readCost,
+    pool: () => {
+      const spec = deps.podPoolSpec();
+      if (!spec) throw new Error('pool-unconfigured');
+      const members = parsePodPool(spec);
+      const measured = (deps.occupancy ?? measureMemberOccupancy)(members);
+      return { members: members.map(member => ({
+        context: member.context, occupied: measured[member.context]?.occupied ?? null, capacity: member.capacity,
+      })) };
+    },
+    hostCredentials: deps.readHostCredentials,
+    parentHosts: () => ({ hosts: deps.parentHosts().map(host => {
+      const measurement = (deps.parentCapacity ?? readParentHostCapacity)(host);
+      return {
+        host: host.host,
+        approvalCapacity: host.approvalCapacity ?? 1,
+        active: measurement?.active ?? null,
+        headroom: measurement?.approvalHeadroom ?? null,
+      };
+    }) }),
+  };
+}

package/src/live-supply/snapshot.ts

@@ -0,0 +1,40 @@
+/** Runtime resource facts shared by later harness decisions. No credential values enter this ledger. */
+export const SUPPLY_AXES = ['codex', 'grok', 'cost', 'pool', 'hostCredentials', 'parentHosts'] as const;
+export type SupplyAxis = typeof SUPPLY_AXES[number];
+
+export interface SupplyValues {
+  codex: { accounts: Array<{ name: string; usedPercent: number | null; signalAt: string | null; available: boolean | null }> };
+  grok: { quota: 'usable' | 'exhausted' | 'unknown'; observedAt: string | null };
+  cost: { used: number | null; limit: number | null; currency: string | null };
+  pool: { members: Array<{ context: string; occupied: number | null; capacity: number | null }> };
+  hostCredentials: { hosts: Array<{ host: string; grokExpiry: 'healthy' | 'expiring' | 'unknown'; grokExpiresAt: string | null; claude5hUsed: number | null; claude7dUsed: number | null; claude5hResetAt: string | null; claude7dResetAt: string | null }> };
+  parentHosts: { hosts: Array<{ host: string; approvalCapacity: number | null; active: number | null; headroom: number | null }> };
+}
+
+export type SupplySourceStatus = 'measured' | 'stale' | 'unknown';
+export interface SupplySourceState {
+  status: SupplySourceStatus;
+  observedAt: string | null;
+  reason: string | null;
+}
+
+export interface LiveSupplySnapshot {
+  version: 1;
+  sequence: number;
+  observedAt: string;
+  expiresAt: string;
+  sources: Record<SupplyAxis, SupplySourceState>;
+  values: Partial<SupplyValues>;
+}
+
+export interface SupplyEvent {
+  kind: 'supply.changed' | 'supply.unmeasured';
+  sequence: number;
+  axis: SupplyAxis;
+  from: SupplySourceStatus | string;
+  to: SupplySourceStatus | string;
+  reason: string | null;
+  observedAt: string;
+}
+
+export type SupplyProbes = { [K in SupplyAxis]: () => Promise<SupplyValues[K]> | SupplyValues[K] };

package/src/llm/provider-credentials.ts

@@ -209,7 +209,7 @@ export function resolveProviderCredential(input: ResolveCredentialInput): Resolv
   // 목표 provider 의 엔드포인트 — 키와 **같은 규율**로 rotation 에서만 가져온다(10R).
   //   전환이면 옛 baseUrl 은 틀린 주소이므로, rotation 에 명시가 없으면 undefined(provider 기본).
   // ⛔⭐ local 은 «런 단위 env»(`LOCAL_LLM_URL`)가 config rotation 을 이긴다 — `ELANOUS_LLM_PROVIDER` 가 config 를 이기는 것과 같은 규칙(BACKLOG B13).
-  //   🩸 2026-09-25: 부모에 `LOCAL_LLM_URL=<node-b 경유>` 를 줬는데 rotation 의 `local → localhost:1234` 가 이겨 자식이 «호스트»
+  //   🩸 2026-09-25: 부모에 `LOCAL_LLM_URL=<원격 프록시>` 를 줬는데 rotation 의 `local → localhost:1234` 가 이겨 자식이 «호스트»
   //     LM Studio 로 갔다. Pod(config 없음)에선 안 드러났다.
   const envEndpoint = provider === 'local' ? env.LOCAL_LLM_URL?.trim() : undefined;
   const endpoint = envEndpoint || rotation?.find((r) => r.provider === provider && typeof r.baseUrl === 'string' && r.baseUrl.trim().length > 0)?.baseUrl?.trim();

package/src/llm-tool-schema.ts

@@ -27,6 +27,26 @@ export function sanitizeToolSchemaForGrok(schema: unknown): unknown {
   return output;
 }
 
+/** Anthropic-backed Claude APIs reject top-level JSON Schema composition on tool inputs.
+ * Check every tool before serialization so a newly introduced tool cannot turn a whole
+ * Claude request into a 400 and trigger an unnoticed provider fallback. Nested schemas
+ * remain valid and are deliberately not inspected here. */
+export function assertNoTopLevelToolSchemaCombinators(
+  tools: readonly { name: string; parameters: unknown }[] | undefined,
+): void {
+  if (!tools?.length) return;
+  const combinators = ['anyOf', 'oneOf', 'allOf'] as const;
+  const invalid = tools.flatMap((tool) => {
+    if (!tool.parameters || typeof tool.parameters !== 'object' || Array.isArray(tool.parameters)) return [];
+    const schema = tool.parameters as Record<string, unknown>;
+    const found = combinators.filter((key) => Object.prototype.hasOwnProperty.call(schema, key));
+    return found.length ? [`${tool.name} (${found.join(', ')})`] : [];
+  });
+  if (invalid.length) {
+    throw new Error(`Claude tool schema has unsupported top-level composition: ${invalid.join('; ')}`);
+  }
+}
+
 /** OpenRouter model ids may include the provider prefix; callers can pass
  * either the catalog id or the already-normalized wire id. */
 export function isOpenRouterGrokModel(model: string): boolean {