nemoris 0.1.0

package/src/runtime/pilot-status.js

@@ -0,0 +1,108 @@
+function isProviderBackedRun(run) {
+  if (!run) return false;
+  return run.mode === "provider" || (run.mode === "live" && Boolean(run.providerId));
+}
+
+function isHealthyProviderRun(run) {
+  if (!isProviderBackedRun(run)) return false;
+  if (run.deliveryUncertain || run.fallbackAttempted) return false;
+
+  const yielded = run.yielded === true;
+  const followUpHealthy = !yielded || run.followUpConsumed === true;
+  const handoffRequired = run.interaction?.handoff?.required === true;
+  const handoffHealthy = !handoffRequired || run.handoffDelivered === true;
+  const deliveryEvidenceRequired = run.deliveryEvidenceRequired === true;
+  const deliveryEvidenceHealthy = !deliveryEvidenceRequired || run.deliveryEvidenceHealthy === true;
+  const completionHealthy = run.interaction?.completion?.required !== true || run.completionQueued === true;
+  const ackHealthy = run.interaction?.ack?.required !== true || run.ackQueued === true;
+
+  return followUpHealthy && handoffHealthy && deliveryEvidenceHealthy && completionHealthy && ackHealthy;
+}
+
+function countRecentHealthyProviders(runs) {
+  return runs.filter((run) => isHealthyProviderRun(run)).length;
+}
+
+function buildRecommendation({ readinessTier, blockers, healthyProviderRuns }) {
+  if (readinessTier === "ready_for_pilot" && healthyProviderRuns >= 2) {
+    return "candidate_for_daily_driver";
+  }
+  if (readinessTier === "ready_for_pilot" || readinessTier === "close") {
+    return "continue_provider_pilot";
+  }
+  if (blockers.includes("provider_unreachable")) {
+    return "fix_provider_first";
+  }
+  if (blockers.includes("retrieval_is_degraded_or_falling_back")) {
+    return "fix_retrieval_health_first";
+  }
+  if (blockers.includes("output_contract_not_consistently_satisfied")) {
+    return "improve_report_quality_first";
+  }
+  if (blockers.includes("interaction_lifecycle_has_blocking_issues")) {
+    return "fix_interaction_contract_first";
+  }
+  return "not_ready_for_pilot";
+}
+
+export function buildPilotStatus({ jobId, readiness, evaluation, runs = [], dependencyHealth = null, reportFallback = null } = {}) {
+  const laneRuns = runs.filter((run) => run.jobId === jobId);
+  const providerRuns = laneRuns.filter((run) => isProviderBackedRun(run));
+  const latestRun = laneRuns[0] || null;
+  const latestProviderRun = providerRuns[0] || null;
+  const healthyProviderRuns = countRecentHealthyProviders(providerRuns);
+  const readinessTier = readiness?.readinessTier || "not_ready";
+  const blockers = readiness?.blockers || [];
+  const recommendation = buildRecommendation({
+    readinessTier,
+    blockers,
+    healthyProviderRuns
+  });
+
+  return {
+    jobId,
+    readinessTier,
+    recommendation,
+    blockers,
+    providerRunsObserved: providerRuns.length,
+    healthyProviderRuns,
+    latestRun: latestRun
+      ? {
+          filePath: latestRun.filePath,
+          timestamp: latestRun.timestamp,
+          mode: latestRun.mode,
+          providerId: latestRun.providerId,
+          modelId: latestRun.modelId,
+          followUpConsumed: latestRun.followUpConsumed,
+          handoffDelivered: latestRun.handoffDelivered,
+          deliveryEvidenceHealthy: latestRun.deliveryEvidenceHealthy,
+          deliveryUncertain: latestRun.deliveryUncertain,
+          fallbackAttempted: latestRun.fallbackAttempted
+        }
+      : null,
+    latestProviderRun: latestProviderRun
+      ? {
+          filePath: latestProviderRun.filePath,
+          timestamp: latestProviderRun.timestamp,
+          providerId: latestProviderRun.providerId,
+          modelId: latestProviderRun.modelId,
+          followUpConsumed: latestProviderRun.followUpConsumed,
+          handoffDelivered: latestProviderRun.handoffDelivered,
+          deliveryEvidenceHealthy: latestProviderRun.deliveryEvidenceHealthy,
+          deliveryUncertain: latestProviderRun.deliveryUncertain,
+          fallbackAttempted: latestProviderRun.fallbackAttempted
+        }
+      : null,
+    evaluation: evaluation
+      ? {
+          filePath: evaluation.filePath,
+          overallScore: evaluation.rubric?.overallScore ?? null,
+          contractSatisfiedRatio: evaluation.contractCheck?.satisfiedRatio ?? null,
+          interaction: evaluation.interaction || null,
+          retrieval: evaluation.retrieval || null
+        }
+      : null,
+    dependencyHealth,
+    reportFallback
+  };
+}

package/src/runtime/prompt-builder.js

@@ -0,0 +1,261 @@
+import { createHash, randomUUID } from "node:crypto";
+import { canonicalJson } from "../utils/canonical-json.js";
+
+/**
+ * PromptBuilder — deterministic, token-budgeted context assembler (Phase 3).
+ */
+
+export function reduceEvent(prevState, event) {
+  const state = prevState ? { ...prevState } : {
+    goal: null,
+    last_actions: [],
+    failures: [],
+    open_questions: []
+  };
+
+  const payload = typeof event.payload_json === "string" 
+    ? JSON.parse(event.payload_json) 
+    : event.payload_json;
+
+  switch (event.kind) {
+    case "message_in":
+      if (!state.goal && payload.text) {
+        state.goal = payload.text.slice(0, 120);
+      }
+      state.last_actions.push({
+        ts: event.ts,
+        text: `User: ${payload.text || ""}`,
+        event_id: event.id
+      });
+      break;
+
+    case "message_out":
+      state.last_actions.push({
+        ts: event.ts,
+        text: `Assistant: ${payload.text || ""}`,
+        event_id: event.id
+      });
+      break;
+
+    case "tool_call":
+      state.last_actions.push({
+        ts: event.ts,
+        text: `Tool call: ${payload.name || payload.tool_name || "unknown"}`,
+        event_id: event.id
+      });
+      break;
+
+    case "tool_result": {
+      const toolName = payload.name || payload.tool_name || "unknown";
+      const ok = payload.ok !== false;
+      if (!ok) {
+        state.failures.push({
+          ts: event.ts,
+          summary: `Tool failed: ${toolName}`,
+          event_id: event.id
+        });
+      }
+      state.last_actions.push({
+        ts: event.ts,
+        text: `Tool result: ${toolName} ${ok ? "ok" : "failed"}`,
+        event_id: event.id
+      });
+      break;
+    }
+
+    case "state_patch":
+      if (payload.patch) {
+        Object.assign(state, payload.patch);
+      }
+      break;
+  }
+
+  // Cap arrays
+  if (state.last_actions.length > 20) state.last_actions = state.last_actions.slice(-20);
+  if (state.failures.length > 10) state.failures = state.failures.slice(-10);
+  if (state.open_questions.length > 5) state.open_questions = state.open_questions.slice(-5);
+
+  return state;
+}
+
+export class PromptBuilder {
+  constructor({ contextLedger } = {}) {
+    this.contextLedger = contextLedger;
+  }
+
+  buildContextItems(events, workingState) {
+    const items = [];
+
+    // 1. Working state item
+    const wsText = [
+      `Goal: ${workingState.goal || "None"}`,
+      `Recent Actions:\n${workingState.last_actions.slice(-5).map(a => `- ${a.text}`).join("\n")}`,
+      workingState.failures.length > 0 ? `Failures:\n${workingState.failures.map(f => `- ${f.summary}`).join("\n")}` : null
+    ].filter(Boolean).join("\n\n");
+
+    items.push({
+      kind: "working_state",
+      text: wsText,
+      estTokens: Math.ceil(wsText.length / 4),
+      utilityScore: 1.0
+    });
+
+    // 2. Recent turns (last 10 message_in/message_out)
+    const turnEvents = events
+      .filter(e => e.kind === "message_in" || e.kind === "message_out")
+      .slice(-10);
+    
+    turnEvents.forEach((e, idx) => {
+      const payload = typeof e.payload_json === "string" ? JSON.parse(e.payload_json) : e.payload_json;
+      const text = payload.text || "";
+      items.push({
+        kind: "recent_turn",
+        id: e.id,
+        role: e.kind === "message_in" ? "user" : "assistant",
+        text,
+        estTokens: Math.ceil(text.length / 4),
+        utilityScore: 0.5 + (idx / turnEvents.length) * 0.4, // Newer = higher score
+        ts: e.ts
+      });
+    });
+
+    // 3. Tool briefs (last 5 tool_result)
+    const toolEvents = events
+      .filter(e => e.kind === "tool_result")
+      .slice(-5);
+
+    toolEvents.forEach((e, idx) => {
+      const payload = typeof e.payload_json === "string" ? JSON.parse(e.payload_json) : e.payload_json;
+      let brief = payload.brief || (typeof payload.result === "string" ? payload.result : JSON.stringify(payload.result || payload));
+      if (brief.length > 300) brief = brief.slice(0, 300) + "...";
+      
+      items.push({
+        kind: "tool_brief",
+        id: e.id,
+        text: `Tool result (${payload.name || "unknown"}): ${brief}`,
+        estTokens: Math.ceil(brief.length / 4),
+        utilityScore: 0.3 + (idx / toolEvents.length) * 0.2,
+        ts: e.ts
+      });
+    });
+
+    return items;
+  }
+
+  async buildPrompt({ sessionId, events, snapshot, systemText, tools, tokenBudgetTotal }) {
+    // 1. Reduce working state
+    let workingState = snapshot ? JSON.parse(snapshot.state_json) : null;
+    for (const event of events) {
+      workingState = reduceEvent(workingState, event);
+    }
+    if (!workingState) workingState = reduceEvent(null, {});
+
+    // 2. Build context items
+    const allItems = this.buildContextItems(events, workingState);
+
+    // 3. Token allocations
+    const systemTokens = Math.ceil(systemText.length / 4);
+    const wsItem = allItems.find(i => i.kind === "working_state");
+    const wsTokens = wsItem ? wsItem.estTokens : 0;
+    
+    let remainingBudget = tokenBudgetTotal - systemTokens - wsTokens;
+    if (remainingBudget < 0) remainingBudget = 0;
+
+    const recentTurnsBudget = Math.floor(remainingBudget * 0.4);
+    const toolBriefsBudget = Math.floor(remainingBudget * 0.2);
+
+    // 4 & 5. Fill budgets
+    const chosenItems = [];
+    if (wsItem) chosenItems.push(wsItem);
+
+    // Fill recent turns (descending recency)
+    const recentTurns = allItems.filter(i => i.kind === "recent_turn").sort((a, b) => b.ts - a.ts);
+    let turnsUsed = 0;
+    for (const turn of recentTurns) {
+      if (turnsUsed + turn.estTokens <= recentTurnsBudget) {
+        chosenItems.push(turn);
+        turnsUsed += turn.estTokens;
+      }
+    }
+
+    // Fill tool briefs (descending recency)
+    const toolBriefs = allItems.filter(i => i.kind === "tool_brief").sort((a, b) => b.ts - a.ts);
+    let toolsUsed = 0;
+    for (const brief of toolBriefs) {
+      if (toolsUsed + brief.estTokens <= toolBriefsBudget) {
+        chosenItems.push(brief);
+        toolsUsed += brief.estTokens;
+      }
+    }
+
+    // 6. Assemble final messages array
+    const messages = [];
+    
+    // System message
+    messages.push({
+      role: "system",
+      content: `${systemText}\n\n${wsItem ? wsItem.text : ""}`.trim()
+    });
+
+    // Recent turns (must be in original order)
+    const sortedTurns = chosenItems
+      .filter(i => i.kind === "recent_turn")
+      .sort((a, b) => a.ts - b.ts);
+    
+    for (const turn of sortedTurns) {
+      messages.push({ role: turn.role, content: turn.text });
+    }
+
+    // Tool briefs (append to last user message or as new user message)
+    const briefsText = chosenItems
+      .filter(i => i.kind === "tool_brief")
+      .sort((a, b) => a.ts - b.ts)
+      .map(i => i.text)
+      .join("\n\n");
+
+    if (briefsText) {
+      const lastUserMsg = [...messages].reverse().find(m => m.role === "user");
+      if (lastUserMsg) {
+        lastUserMsg.content += `\n\nRecent tool results:\n${briefsText}`;
+      } else {
+        messages.push({ role: "user", content: `Recent tool results:\n${briefsText}` });
+      }
+    }
+
+    // Prefix hash
+    const toolsJson = canonicalJson((tools || []).map(t => t.name).sort());
+    const prefixSource = systemText + toolsJson;
+    const prefixHash = createHash("sha256").update(prefixSource).digest("hex");
+
+    const totalTokensEst = systemTokens + wsTokens + turnsUsed + toolsUsed;
+
+    // 7. Log to prompt_builds
+    if (this.contextLedger && sessionId) {
+      try {
+        const buildId = randomUUID();
+        const chosenKinds = chosenItems.map(i => i.kind);
+        this.contextLedger.db.prepare(`
+          insert into prompt_builds (id, session_id, ts, token_budget, chosen_item_ids_json, total_tokens_est, prefix_hash)
+          values (?, ?, ?, ?, ?, ?, ?)
+        `).run(
+          buildId,
+          sessionId,
+          Date.now(),
+          tokenBudgetTotal,
+          JSON.stringify(chosenKinds),
+          totalTokensEst,
+          prefixHash
+        );
+      } catch (err) {
+        // Logging failure must never break a turn
+      }
+    }
+
+    return {
+      messages,
+      workingState,
+      tokenEstimate: totalTokensEst,
+      prefixHash
+    };
+  }
+}