elanous 0.2.38 → 0.2.41

package/src/lessons/friction-ledger.ts

@@ -0,0 +1,154 @@
+import { Database } from 'bun:sqlite';
+import { chmodSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
+import type { LessonLedgerOptions } from './lesson-ledger.js';
+
+export type FrictionActor = 'OP' | 'TC' | 'MK' | 'UX' | 'ceo' | 'person';
+export type FrictionKind = 'hand-step' | 'ceo-correction' | 'repeat-question';
+
+export const FRICTION_ACTORS: readonly FrictionActor[] = ['OP', 'TC', 'MK', 'UX', 'ceo', 'person'];
+export const FRICTION_KINDS: readonly FrictionKind[] = ['hand-step', 'ceo-correction', 'repeat-question'];
+export const FRICTION_CANDIDATE_MIN = 3;
+
+export interface FrictionRecordInput {
+  actor: FrictionActor;
+  kind: FrictionKind;
+  signature: string;
+  note?: string;
+  ref: string;
+}
+
+export interface FrictionRow {
+  id: number;
+  actor: FrictionActor;
+  kind: FrictionKind;
+  signature: string;
+  note: string;
+  ref: string;
+  recorded_at: string;
+}
+
+export interface FrictionCandidate {
+  kind: FrictionKind;
+  signature: string;
+  count: number;
+  firstAt: string;
+  lastAt: string;
+  refs: string[];
+}
+
+export class FrictionInputError extends Error {
+  override name = 'FrictionInputError';
+}
+
+/** Secret-shaped note bodies are never persisted: a token or key would be copied into the ledger. */
+const SECRET_PATTERNS: readonly RegExp[] = [
+  /sk-[A-Za-z0-9_-]{8,}/u,
+  /(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{8,}/u,
+  /AKIA[0-9A-Z]{12,}/u,
+  /xox[bapr]-[A-Za-z0-9-]{8,}/u,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/u,
+  /\b[0-9a-f]{32,}\b/u,
+  /\b[A-Za-z0-9+/=_-]{40,}\b/u,
+  /(?:api[_-]?key|access[_-]?key|token|secret|password)\s*[:=]\s*\S{8,}/iu,
+];
+
+function required(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new FrictionInputError(`${field} is required`);
+  return value.trim();
+}
+
+function checkActor(value: FrictionActor): FrictionActor {
+  if (!FRICTION_ACTORS.includes(value)) throw new FrictionInputError(`actor must be one of ${FRICTION_ACTORS.join(', ')}`);
+  return value;
+}
+
+function checkKind(value: FrictionKind): FrictionKind {
+  if (!FRICTION_KINDS.includes(value)) throw new FrictionInputError(`kind must be one of ${FRICTION_KINDS.join(', ')}`);
+  return value;
+}
+
+/** Same hand step spelled differently is the same hand step: lower case, whitespace runs folded to one space. */
+function normalizeSignature(value: unknown): string {
+  const signature = required(value, 'signature').replace(/\s+/gu, ' ').toLowerCase();
+  if (!signature) throw new FrictionInputError('signature is required');
+  return signature;
+}
+
+export function frictionActor(name: string): FrictionActor {
+  const key = name.trim().toLowerCase();
+  return FRICTION_ACTORS.find(actor => actor.toLowerCase() === key) ?? 'person';
+}
+
+function secretFreeNote(note: unknown): string {
+  const text = note === undefined || note === null ? '' : String(note);
+  if (SECRET_PATTERNS.some(pattern => pattern.test(text))) throw new FrictionInputError('note looks like a secret (token or key)');
+  return text;
+}
+
+export class FrictionLedger {
+  readonly path: string;
+  private readonly now: () => Date;
+
+  constructor(options: LessonLedgerOptions = {}) {
+    this.path = join(options.stateDir ?? elanousStateRoot(), 'lessons', 'friction.sqlite');
+    this.now = options.now ?? (() => new Date());
+  }
+
+  private open(): Database {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const db = new Database(this.path, { create: true, strict: true });
+    try {
+      chmodSync(this.path, 0o600);
+      db.exec('PRAGMA busy_timeout = 10000');
+      db.exec('PRAGMA journal_mode = WAL');
+      db.exec(`CREATE TABLE IF NOT EXISTS friction (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        actor TEXT NOT NULL CHECK(actor IN ('OP','TC','MK','UX','ceo','person')),
+        kind TEXT NOT NULL CHECK(kind IN ('hand-step','ceo-correction','repeat-question')),
+        signature TEXT NOT NULL, note TEXT NOT NULL DEFAULT '', ref TEXT NOT NULL, recorded_at TEXT NOT NULL);
+        CREATE INDEX IF NOT EXISTS friction_group ON friction (kind, signature);`);
+      return db;
+    } catch (error) { db.close(); throw error; }
+  }
+
+  private using<T>(work: (db: Database) => T): T {
+    const db = this.open();
+    try { return work(db); } finally { db.close(); }
+  }
+
+  record(input: FrictionRecordInput): FrictionRow {
+    const actor = checkActor(input.actor);
+    const kind = checkKind(input.kind);
+    const signature = normalizeSignature(input.signature);
+    const note = secretFreeNote(input.note);
+    const ref = required(input.ref, 'ref');
+    return this.using(db => {
+      const at = this.now().toISOString();
+      const inserted = db.query('INSERT INTO friction (actor, kind, signature, note, ref, recorded_at) VALUES (?, ?, ?, ?, ?, ?)')
+        .run(actor, kind, signature, note, ref, at);
+      const row = db.query('SELECT id, actor, kind, signature, note, ref, recorded_at FROM friction WHERE id = ?')
+        .get(Number(inserted.lastInsertRowid)) as FrictionRow | null;
+      if (!row) throw new FrictionInputError('friction row was not stored');
+      debug.log('lessons.friction', 'record', { id: row.id, kind: row.kind, actor: row.actor });
+      return row;
+    });
+  }
+
+  /** Same hand step three times is a proposal candidate (§4⑤ SELF-PROPOSE-BASE), not one-off noise. */
+  candidates(min: number = FRICTION_CANDIDATE_MIN): FrictionCandidate[] {
+    if (!Number.isInteger(min) || min < 1) throw new FrictionInputError('min must be a positive integer');
+    return this.using(db => {
+      const groups = db.query(`SELECT kind, signature, count(*) AS count, min(recorded_at) AS firstAt, max(recorded_at) AS lastAt
+        FROM friction GROUP BY kind, signature HAVING count(*) >= ?
+        ORDER BY count DESC, lastAt DESC, kind, signature`).all(min) as Omit<FrictionCandidate, 'refs'>[];
+      return groups.map(group => ({
+        ...group,
+        refs: (db.query('SELECT ref FROM friction WHERE kind = ? AND signature = ? ORDER BY id')
+          .all(group.kind, group.signature) as { ref: string }[]).map(row => row.ref),
+      }));
+    });
+  }
+}

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/model-defaults.ts

@@ -49,12 +49,12 @@ export function setAutoProviderDecisionForTest(fn: (() => LLMProviderName | unde
 /** config/tier 해석이 «실패»했을 때만 타는 최후 폴백. 티어 사다리가 안 읽히는
  *  상황(부팅 초기·손상된 config)에서도 지점이 «성능 등급에 맞는» 모델을 얻게 한다. */
 const LEGACY_TIER_FALLBACK: Readonly<Record<ModelTier, string>> = {
-  // 🩸 2026-09-23 — 이 폴백이 GPT-6 이관 뒤에도 gpt-5.6-* 였다(결정 지적 · GPT-6 에는 terra 가 없다).
+  // Keep the fallback aligned with the GPT-6.1 Codex ladder if config/tier lookup fails.
   //   사다리가 안 읽힐 때만 쓰이므로 codex 사다리의 «현재 값»과 같게 둔다(시험이 사다리와 대조한다).
   budget: 'gpt-6-luna',
-  balanced: 'gpt-6-sol',
-  better: 'gpt-6-sol',
-  best: 'gpt-6-sol',
+  balanced: 'gpt-6.1-terra',
+  better: 'gpt-6.1-terra',
+  best: 'gpt-6.1-sol',
   loaded: 'gpt-6-astra',
 };