elanous 0.2.41 → 0.2.43

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' | 'quarantined';
+type PodWorkerState = 'idle' | 'leased' | 'sanitizing' | 'timeout-fenced' | 'quarantined';
 interface PodWorkerLeaseAttrs {
   key: PodWorkerKey;
   podUid: string;
@@ -32,6 +32,9 @@ interface PodWorkerLeaseAttrs {
   /** The just-sanitized generation remains fenceable until the next acquisition. */
   lastLeaseId?: string;
   lastLeaseOwner?: string;
+  timeoutFenceUntil?: number;
+  timeoutRunId?: string;
+  timeoutAttemptId?: string;
   runId?: string;
   attemptId?: string;
   reason?: string;
@@ -231,17 +234,35 @@ export class ResourceLedger {
     return this.mutate(() => {
     const at = now ?? Date.now();
     const rows = this.read();
+    let expiredFenceChanged = false;
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+      const candidate = rows[rowIndex]!;
+      if (candidate.kind !== 'pod-worker-lease') continue;
+      const candidateAttrs = workerAttrs(candidate);
+      if (candidateAttrs.state !== 'timeout-fenced' || candidateAttrs.timeoutFenceUntil === undefined
+        || candidateAttrs.timeoutFenceUntil > at || candidateAttrs.leaseId) continue;
+      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 };
+      expiredFenceChanged = true;
+    }
     const index = rows.findIndex(row => row.kind === 'pod-worker-lease' && (!request.machine || row.machine === request.machine)
       && Math.max(0, at - row.observedAt) < row.ttlMs && workerAttrs(row).state === 'idle'
       && typeof workerAttrs(row).podUid === 'string' && workerAttrs(row).podUid.trim().length > 0
       && sameWorkerKey(workerAttrs(row).key, request.key));
-    if (index < 0) throw new ResourceLedgerError(409, 'no-warm-worker');
+    if (index < 0) {
+      if (expiredFenceChanged) this.write(rows);
+      throw new ResourceLedgerError(409, 'no-warm-worker');
+    }
     const row = rows[index]!;
     const attrs = workerAttrs(row);
     const nextAttrs: PodWorkerLeaseAttrs = { ...attrs, state: 'leased', generation: attrs.generation + 1,
       leaseId: randomUUID(), leaseOwner: request.owner, runId: request.runId, attemptId: request.attemptId };
     delete nextAttrs.lastLeaseId;
     delete nextAttrs.lastLeaseOwner;
+    delete nextAttrs.timeoutFenceUntil; delete nextAttrs.timeoutRunId; delete nextAttrs.timeoutAttemptId;
     const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>,
       observedAt: at, ttlMs: request.ttlMs };
     rows[index] = next;
@@ -250,6 +271,31 @@ export class ResourceLedger {
     });
   }
 
+  fenceTimedOutPodWorker(id: string, request: { owner: string; runId: string; attemptId: string; fenceMs: number }, now?: number): ResourceRecord {
+    return this.mutate(() => {
+      const at = 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);
+      const sameFence = attrs.state === 'timeout-fenced' && attrs.timeoutRunId === request.runId
+        && 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';
+      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 };
+      const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>, observedAt: at };
+      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();
@@ -260,11 +306,14 @@ export class ResourceLedger {
     const attrs = workerAttrs(row);
     const lateIdleQuarantine = request.action === 'quarantine' && attrs.state === 'idle'
       && attrs.lastLeaseId === request.leaseId && attrs.generation === request.generation;
+    const timeoutFencedQuarantine = request.action === 'quarantine' && attrs.state === 'timeout-fenced'
+      && attrs.leaseId === request.leaseId && attrs.generation === request.generation;
     if (!request.leaseId || (attrs.leaseId !== request.leaseId && !lateIdleQuarantine)
       || attrs.generation !== request.generation) throw new ResourceLedgerError(409, 'stale-worker-lease');
     const permitted = request.action === 'sanitize' ? row.owner === request.owner
       : request.action === 'quarantine' ? row.owner === request.owner || attrs.leaseOwner === request.owner
         || (lateIdleQuarantine && attrs.lastLeaseOwner === request.owner)
+        || (timeoutFencedQuarantine && attrs.leaseOwner === request.owner)
       : attrs.leaseOwner === request.owner;
     if (!permitted) {
       throw new ResourceLedgerError(403, 'not-owner');
@@ -283,6 +332,7 @@ export class ResourceLedger {
     } else if (state === 'quarantined') {
       delete nextAttrs.lastLeaseId;
       delete nextAttrs.lastLeaseOwner;
+      delete nextAttrs.timeoutFenceUntil; delete nextAttrs.timeoutRunId; delete nextAttrs.timeoutAttemptId;
     }
     const ttlMs = state === 'idle' ? attrs.idleTtlMs : request.ttlMs ?? row.ttlMs;
     const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>, observedAt: now, ttlMs };

package/src/control-plane/server.ts

@@ -10,6 +10,7 @@ import type { LeaseHolderView } from './lease-holder.js';
 export const DEFAULT_CONTROL_PORT = PORT_BANDS.reserved[0];
 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 {
   if (hostname === '127.0.0.1' || hostname === '::1') return true;
@@ -126,7 +127,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)$/.exec(path);
+        const workerTransition = /^\/v1\/leases\/pod-worker\/([^/]+)\/(renew|release|sanitize|quarantine|timeout)$/.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);
         }
@@ -191,7 +192,20 @@ 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';
+            const action = workerTransition[2] as 'renew' | 'release' | 'sanitize' | 'quarantine' | 'timeout';
+            if (action === 'timeout') {
+              if (scope !== 'member') throw new ResourceLedgerError(403, 'worker-timeout-scope');
+              const body = podWorkerBody(await req.json());
+              const { runId, attemptId } = body;
+              if (typeof runId !== 'string' || !runId.trim() || typeof attemptId !== 'string' || !attemptId.trim())
+                throw new ResourceLedgerError(400, 'invalid-pod-worker-timeout');
+              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.fenceTimedOutPodWorker(id, { owner, runId, attemptId, fenceMs: POD_WORKER_TIMEOUT_FENCE_MS })));
+            }
             if (action === 'sanitize' ? !machine : (action === 'renew' || action === 'release') && scope !== 'member') {
               throw new ResourceLedgerError(403, 'worker-scope');
             }

package/src/core-turn/deep-turn-bloom.ts

@@ -0,0 +1,67 @@
+export type DeepBloomTrigger = 'research-intent' | 'deep-question' | 'high-reasoning-effort';
+
+export type DeepBloomDecision =
+  | { apply: true; reason: DeepBloomTrigger }
+  | { apply: false; reason: 'lightweight' | 'no-deep-signal' };
+
+export type DeepBloomInstruction = Extract<DeepBloomDecision, { apply: true }> & {
+  levels: readonly [4, 5];
+  questionCount: 3 | 4 | 5;
+  prompt?: string;
+  exemplarDomain?: string;
+  exemplarLevels?: number[];
+};
+
+const LIGHTWEIGHT_TEXT = /^(?:hi|hello|hey|thanks|thank you|good morning|good night|안녕(?:하세요)?|고마워(?:요)?|감사합니다|잘 자(?:요)?)[.!?\s]*$/iu;
+const LIGHTWEIGHT_FACT = /^(?:what(?:'s| is)\s+(?:the\s+)?(?:capital|time|date|meaning|definition)\b.*|who is\b.*|where is\b.*|몇 시(?:야|인가요)?|오늘 날짜(?:는|가)?|\S+의 뜻(?:은|이)?)[?？.!\s]*$/iu;
+const LIGHTWEIGHT_COMMAND = /^(?:please\s+)?(?:open|show|list|translate|convert|print|set|turn on|turn off)\b|^(?:열어(?:줘|주세요)|보여(?:줘|주세요)|나열해(?:줘|주세요)|번역해(?:줘|주세요)|계산해(?:줘|주세요)|켜(?:줘|주세요)|꺼(?:줘|주세요))\s*$/iu;
+const DEEP_QUESTION = /\b(?:analy[sz]e|analysis|evaluate|evaluation|compare|comparison|outlook|forecast|cause|causes|why|impact|trade-?offs?|pros and cons|design|strategy|scenario|counterargument|assess|judge)\b|분석|평가|비교|전망|예측|원인|영향|장단점|설계|전략|시나리오|반박|판단|어떻게 봐야|왜\b/iu;
+
+/** Lightweight turns have precedence so effort settings never inflate greetings, simple facts, or direct commands. */
+export function selectDeepBloom(
+  request: string | undefined,
+  options: { researchIntent?: boolean; reasoningEffort?: string } = {},
+): DeepBloomDecision {
+  const text = request?.trim() ?? '';
+  if (!text || LIGHTWEIGHT_TEXT.test(text) || LIGHTWEIGHT_FACT.test(text) || LIGHTWEIGHT_COMMAND.test(text))
+    return { apply: false, reason: 'lightweight' };
+  if (options.researchIntent) return { apply: true, reason: 'research-intent' };
+  if (options.reasoningEffort && ['high', 'xhigh', 'max'].includes(options.reasoningEffort))
+    return { apply: true, reason: 'high-reasoning-effort' };
+  if (DEEP_QUESTION.test(text)) return { apply: true, reason: 'deep-question' };
+  return { apply: false, reason: 'no-deep-signal' };
+}
+
+/** Build a hidden same-call analysis/evaluation instruction with the existing KGS Bloom cells and exemplar bank. */
+export async function buildDeepBloomInstruction(
+  request: string,
+  trigger: DeepBloomTrigger,
+): Promise<DeepBloomInstruction> {
+  const [{ BLOOM_2D_SCOPED }, { getBloomExemplarContext }] = await Promise.all([
+    import('../knowledge/kgs/types.js'), import('../research/bloom-exemplars.js'),
+  ]);
+  const analyze = BLOOM_2D_SCOPED.find((cell) => cell.cognitive === 'analyze')!;
+  const evaluate = BLOOM_2D_SCOPED.find((cell) => cell.cognitive === 'evaluate')!;
+  const exemplar = getBloomExemplarContext(request);
+  const prompt = [
+    'Before answering, silently ask yourself 3–5 short questions and answer them from the available context.',
+    `Analysis focus (${analyze.cognitive}/${analyze.knowledge}): break the subject into components, relationships, and causal mechanisms.`,
+    `Evaluation focus (${evaluate.cognitive}/${evaluate.knowledge}): set explicit criteria, compare alternatives or claims, and test at least one counterargument.`,
+    'Use those answers to produce a clear conclusion. Do not expose these internal labels or a checklist unless the user asks for the reasoning process.',
+    exemplar.context,
+  ].filter(Boolean).join('\n\n');
+  return { apply: true, reason: trigger, levels: [4, 5], questionCount: 4,
+    prompt, exemplarDomain: exemplar.domain, exemplarLevels: exemplar.levels };
+}
+
+/** Ensure the existing research ladder gives levels 4 and 5 distinct analysis/evaluation work. */
+export async function buildResearchBloom45Directive(): Promise<string> {
+  const { BLOOM_2D_SCOPED } = await import('../knowledge/kgs/types.js');
+  const analyze = BLOOM_2D_SCOPED.find((cell) => cell.cognitive === 'analyze')!;
+  const evaluate = BLOOM_2D_SCOPED.find((cell) => cell.cognitive === 'evaluate')!;
+  return [
+    `For Bloom level 4 (${analyze.cognitive}/${analyze.knowledge}), ask about components, relationships, and causal mechanisms.`,
+    `For Bloom level 5 (${evaluate.cognitive}/${evaluate.knowledge}), ask for criteria-based judgment across alternatives and a counterargument.`,
+    'Keep both questions request-specific and ensure each has search terms; do not duplicate level 3 or level 6 work.',
+  ].join('\n');
+}

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

@@ -0,0 +1,37 @@
+/** 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;
+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',
+  'WebFetch',
+  'Agent',
+  'Read',
+  // TUI quick-route contracts: every quick turn can recall memory, and the
+  // investigation route may list (but never mutate) the seat mailbox.
+  'memory_recall',
+  'MsgList',
+] as const;
+
+const RESEARCH_TOOL_NAMES: ReadonlySet<string> = new Set(RESEARCH_TOOL_ALLOWLIST);
+export const RESEARCH_DOCUMENT_WRITE_TOOLS = ['Edit', 'Write'] as const;
+
+/** A research turn may write only when the user explicitly asks for a document at a concrete path. */
+const DOCUMENT_OUTPUT_PATH = /(?:^|[\s"'\x60])(?:\.{1,2}\/)?(?:[\w.-]+\/)*[\w.-]+\.(?:md|mdx|txt|rst|adoc|html|json|ya?ml|csv)\b/i;
+const DOCUMENT_OUTPUT_PATH_GLOBAL = /(?:^|[\s"'\x60])(?:\.{1,2}\/)?(?:[\w.-]+\/)*[\w.-]+\.(?:md|mdx|txt|rst|adoc|html|json|ya?ml|csv)\b/gi;
+const POSITIVE_DOCUMENT_WRITE_INTENT = /\b(?:write|writes|writing|written|draft|drafts|drafting|create|creates|creating|author|authors|authoring|produce|produces|producing|save|saves|saving)\b|작성|초안|생성|기록/i;
+const NEGATED_DOCUMENT_WRITE_INTENT = /\b(?:do\s+not|don['’]?t|never|must\s+not|should\s+not|avoid)\s+(?:(?:be|to)\s+)*(?:write|writes|writing|written|draft|drafts|drafting|create|creates|creating|author|authors|authoring|produce|produces|producing|save|saves|saving)\b|(?:작성|초안|생성|기록)(?:\s*(?:을|를))?\s*(?:하지\s*마|하지\s*말|하지\s*않|금지)/i;
+
+/** A research turn may write only when the user explicitly asks for a document at a concrete path. */
+export function requestsResearchDocumentWrite(text: string | undefined): boolean {
+  if (!text || !DOCUMENT_OUTPUT_PATH.test(text)) return false;
+  const intentText = text.replace(DOCUMENT_OUTPUT_PATH_GLOBAL, ' ');
+  return POSITIVE_DOCUMENT_WRITE_INTENT.test(intentText)
+    && !NEGATED_DOCUMENT_WRITE_INTENT.test(intentText);
+}
+export function isResearchToolAllowed(name: string): boolean {
+  return RESEARCH_TOOL_NAMES.has(name);
+}