@10et/cli 1.0.0

package/packages/pi/extensions/startup-briefing.ts

@@ -0,0 +1,482 @@
+/**
+ * Startup Briefing
+ *
+ * Gathers real data from synopsis, HUD, journal, git, and GitHub PRs
+ * to build a rich steer message on session start. The model uses this
+ * to produce a concise "here's where things stand" greeting.
+ *
+ * @purpose Startup steer message with real project data — synopsis, PRs, team activity
+ */
+
+import { existsSync, readFileSync, readdirSync } from "fs"
+import { join } from "path"
+import { execSync } from "child_process"
+import type { PiContext, JflConfig } from "./types.js"
+import { getHudForSteer } from "./hud-tool.js"
+
+// ─── Data gatherers (all async-safe, fail gracefully) ────────────────────────
+
+function getSynopsis(root: string, hours: number = 24): string {
+  try {
+    const result = execSync(`jfl synopsis ${hours}`, {
+      cwd: root,
+      timeout: 10000,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+    })
+    return result.trim()
+  } catch {
+    return ""
+  }
+}
+
+function getRecentJournalEntries(root: string, count: number = 8): Array<{
+  title: string
+  type: string
+  ts: string
+  session: string
+  summary?: string
+  files?: string[]
+  next?: string
+}> {
+  const journalDir = join(root, ".jfl", "journal")
+  if (!existsSync(journalDir)) return []
+
+  try {
+    const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort()
+    const entries: Array<{ title: string; type: string; ts: string; session: string; summary?: string; files?: string[]; next?: string }> = []
+    const seenTitles = new Set<string>()
+
+    for (let i = files.length - 1; i >= 0 && entries.length < count * 3; i--) {
+      try {
+        const lines = readFileSync(join(journalDir, files[i]), "utf-8").trim().split("\n").filter(Boolean)
+        for (let j = lines.length - 1; j >= 0 && entries.length < count * 3; j--) {
+          try {
+            const e = JSON.parse(lines[j])
+            if (e.title && e.type !== "pivot") {
+              // Deduplicate entries with the same title (e.g. repeated "Layer 3" decisions)
+              const dedupeKey = `${e.type}:${e.title}`
+              if (seenTitles.has(dedupeKey)) continue
+              seenTitles.add(dedupeKey)
+
+              entries.push({
+                title: e.title,
+                type: e.type ?? "note",
+                ts: e.ts ?? "",
+                session: e.session ?? files[i].replace(".jsonl", ""),
+                summary: e.summary,
+                files: e.files,
+                next: e.next,
+              })
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+
+    return entries.slice(0, count)
+  } catch {
+    return []
+  }
+}
+
+function getTeamActivity(root: string, hours: number = 48): string[] {
+  const activity: string[] = []
+
+  // Git commits by others (non-goose authors in last 48h)
+  try {
+    const log = execSync(
+      `git log --oneline --since="${hours} hours ago" --format="%an|||%s" --all`,
+      { cwd: root, timeout: 5000, encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    )
+    const lines = log.trim().split("\n").filter(Boolean)
+    const byAuthor = new Map<string, string[]>()
+
+    for (const line of lines) {
+      const [author, ...msgParts] = line.split("|||")
+      const msg = msgParts.join("|||")
+      if (!author || !msg) continue
+      // Skip auto-save commits
+      if (msg.startsWith("auto:")) continue
+      const list = byAuthor.get(author) || []
+      list.push(msg)
+      byAuthor.set(author, list)
+    }
+
+    for (const [author, commits] of byAuthor) {
+      if (commits.length <= 2) {
+        activity.push(`${author}: ${commits.join("; ")}`)
+      } else {
+        activity.push(`${author}: ${commits.length} commits — ${commits.slice(0, 3).join("; ")}`)
+      }
+    }
+  } catch {}
+
+  return activity
+}
+
+interface PullRequest {
+  number: number
+  title: string
+  author: string
+  state: string
+  createdAt?: string
+}
+
+function getOpenPRs(root: string): PullRequest[] {
+  try {
+    const result = execSync(
+      "gh pr list --limit 10 --json number,title,author,state,createdAt",
+      { cwd: root, timeout: 10000, encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }
+    )
+    const prs = JSON.parse(result) as Array<{
+      number: number
+      title: string
+      author: { login: string; name?: string }
+      state: string
+      createdAt?: string
+    }>
+    return prs.map(pr => ({
+      number: pr.number,
+      title: pr.title.length > 80 ? pr.title.slice(0, 77) + "…" : pr.title,
+      author: pr.author.name || pr.author.login,
+      state: pr.state,
+      createdAt: pr.createdAt,
+    }))
+  } catch {
+    return []
+  }
+}
+
+function getNextActions(root: string): string[] {
+  const actions: string[] = []
+
+  // Check journal "next" fields from recent entries
+  const journalDir = join(root, ".jfl", "journal")
+  if (existsSync(journalDir)) {
+    try {
+      const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort()
+      for (let i = files.length - 1; i >= 0 && actions.length < 3; i--) {
+        try {
+          const lines = readFileSync(join(journalDir, files[i]), "utf-8").trim().split("\n").filter(Boolean)
+          for (let j = lines.length - 1; j >= 0 && actions.length < 3; j--) {
+            try {
+              const e = JSON.parse(lines[j])
+              if (e.next && typeof e.next === "string" && e.next.trim()) {
+                actions.push(e.next.trim())
+              } else if (Array.isArray(e.incomplete) && e.incomplete.length > 0) {
+                actions.push(`Incomplete: ${e.incomplete.slice(0, 2).join(", ")}`)
+              }
+            } catch {}
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  return actions
+}
+
+// ─── Cross-repo awareness ────────────────────────────────────────────────────
+
+function getRegisteredServices(root: string): Array<{ name: string; path: string }> {
+  const configPath = join(root, ".jfl", "config.json")
+  if (!existsSync(configPath)) return []
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"))
+    return (config.registered_services || [])
+      .filter((s: any) => s.path && existsSync(s.path))
+      .map((s: any) => ({ name: s.name, path: s.path }))
+  } catch {
+    return []
+  }
+}
+
+function getCrossRepoPRs(root: string): PullRequest[] {
+  const services = getRegisteredServices(root)
+  const allPRs: PullRequest[] = []
+
+  for (const svc of services) {
+    try {
+      const prs = getOpenPRs(svc.path)
+      for (const pr of prs) {
+        allPRs.push({ ...pr, title: `[${svc.name}] ${pr.title}` })
+      }
+    } catch {}
+  }
+
+  return allPRs
+}
+
+// ─── Hub state — live context from the Hub API ──────────────────────────────
+
+function getHubState(root: string): { activeSessions: string[]; evalSummary: string | null; recentFiles: string[] } {
+  const result = { activeSessions: [] as string[], evalSummary: null as string | null, recentFiles: [] as string[] }
+
+  // Active sessions from .jfl directory
+  try {
+    const sessionFile = join(root, ".jfl", "current-session-branch.txt")
+    if (existsSync(sessionFile)) {
+      const current = readFileSync(sessionFile, "utf-8").trim()
+      if (current) result.activeSessions.push(current)
+    }
+  } catch {}
+
+  // Latest eval scores
+  try {
+    const evalPath = join(root, ".jfl", "eval.jsonl")
+    if (existsSync(evalPath)) {
+      const lines = readFileSync(evalPath, "utf-8").trim().split("\n").filter(Boolean)
+      // Get last eval entry
+      if (lines.length > 0) {
+        const last = JSON.parse(lines[lines.length - 1])
+        if (last.scores) {
+          const parts: string[] = []
+          for (const [key, val] of Object.entries(last.scores)) {
+            if (typeof val === "number") parts.push(`${key}: ${(val as number).toFixed(2)}`)
+          }
+          if (parts.length > 0) result.evalSummary = parts.join(", ")
+        }
+      }
+    }
+  } catch {}
+
+  // Recently modified files (last 24h, non-.jfl)
+  try {
+    const gitFiles = execSync(
+      'git diff --name-only HEAD~10 HEAD 2>/dev/null | grep -v "^.jfl/" | head -15',
+      { cwd: root, encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim()
+    if (gitFiles) result.recentFiles = gitFiles.split("\n").filter(Boolean)
+  } catch {}
+
+  return result
+}
+
+// ─── Last session summary — what was the previous session actually doing? ────
+
+function getLastSessionSummary(root: string): string | null {
+  const journalDir = join(root, ".jfl", "journal")
+  if (!existsSync(journalDir)) return null
+
+  try {
+    const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort()
+    // Walk backwards through recent journal files looking for pivot/session-end entries
+    for (let i = files.length - 1; i >= Math.max(0, files.length - 5); i--) {
+      const lines = readFileSync(join(journalDir, files[i]), "utf-8").trim().split("\n").filter(Boolean)
+      for (let j = lines.length - 1; j >= 0; j--) {
+        try {
+          const e = JSON.parse(lines[j])
+          if (e.type === "pivot" && e.summary) {
+            return e.summary
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  return null
+}
+
+// ─── Build the briefing ──────────────────────────────────────────────────────
+
+// ─── Scorecard reader — pulls live metrics + sprint progress ─────────────────
+function getScorecard(root: string): string | null {
+  const scorecardPath = join(root, "SCORECARD.md")
+  if (!existsSync(scorecardPath)) return null
+
+  try {
+    const content = readFileSync(scorecardPath, "utf-8")
+    const lines = content.split("\n")
+    const output: string[] = []
+
+    // Extract sprint/phase line
+    const sprintLine = lines.find(l => l.startsWith("**Sprint:"))
+    if (sprintLine) output.push(sprintLine)
+
+    const daysLine = lines.find(l => l.includes("Days since first PR"))
+    if (daysLine) output.push(daysLine)
+
+    // Extract core metrics table (find table after "Core Product Metrics")
+    const metricsStart = lines.findIndex(l => l.includes("Core Product Metrics"))
+    if (metricsStart > -1) {
+      for (let i = metricsStart + 1; i < lines.length && i < metricsStart + 12; i++) {
+        if (lines[i].startsWith("|") && !lines[i].includes("---")) {
+          output.push(lines[i])
+        }
+      }
+    }
+
+    // Extract pipeline metrics (key ones only)
+    const pipeStart = lines.findIndex(l => l.includes("Pipeline Metrics"))
+    if (pipeStart > -1) {
+      for (let i = pipeStart + 1; i < lines.length && i < pipeStart + 12; i++) {
+        const line = lines[i]
+        if (line.startsWith("|") && !line.includes("---") && !line.includes("Metric")) {
+          // Only include critical metrics
+          if (line.includes("PRs Auto") || line.includes("Keep Rate") || line.includes("Time to First")) {
+            output.push(line)
+          }
+        }
+      }
+    }
+
+    // Extract sprint checklist (incomplete items only)
+    const checklistStart = lines.findIndex(l => l.includes("Sprint") && l.includes("Checklist"))
+    if (checklistStart > -1) {
+      const incomplete: string[] = []
+      for (let i = checklistStart + 1; i < lines.length; i++) {
+        const line = lines[i]
+        if (line.startsWith("- [ ]")) incomplete.push(line.replace("- [ ] ", "  ○ "))
+        if (line.startsWith("##")) break // next section
+      }
+      if (incomplete.length > 0) {
+        output.push("")
+        output.push(`Sprint tasks remaining (${incomplete.length}):`)
+        output.push(...incomplete.slice(0, 5))
+      }
+    }
+
+    return output.length > 0 ? output.join("\n") : null
+  } catch {
+    return null
+  }
+}
+
+export async function buildStartupBriefing(ctx: PiContext, config: JflConfig): Promise<string> {
+  const root = ctx.session.projectRoot
+  const sections: string[] = []
+
+  // 0. Scorecard — sprint progress + live metrics (FIRST — this is what matters)
+  const scorecard = getScorecard(root)
+  if (scorecard) {
+    sections.push("## Scorecard\n" + scorecard)
+  }
+
+  // 1. HUD — compact project status
+  const hud = getHudForSteer()
+  if (hud) {
+    sections.push("## Project Dashboard\n" + hud)
+  }
+
+  // 1.5. Last session — what was the previous session actually working on?
+  const lastSession = getLastSessionSummary(root)
+  if (lastSession) {
+    // Truncate to 300 chars for briefing
+    const truncated = lastSession.length > 300 ? lastSession.slice(0, 297) + "…" : lastSession
+    sections.push("## Last Session\n" + truncated)
+  }
+
+  // 2. Synopsis — recent work summary
+  const synopsis = getSynopsis(root, 48)
+  if (synopsis) {
+    sections.push("## Recent Work (48h)\n" + synopsis)
+  } else {
+    // Fallback to journal entries
+    const entries = getRecentJournalEntries(root, 6)
+    if (entries.length > 0) {
+      const entryLines = entries.map(e => {
+        const timeAgo = getTimeAgo(e.ts)
+        return `- [${e.type}] ${e.title}${timeAgo ? ` (${timeAgo})` : ""}${e.summary ? ` — ${e.summary}` : ""}`
+      })
+      sections.push("## Recent Work\n" + entryLines.join("\n"))
+    }
+  }
+
+  // 2.5. Hub state — eval scores, recently changed files
+  const hubState = getHubState(root)
+  if (hubState.evalSummary || hubState.recentFiles.length > 0) {
+    const parts: string[] = []
+    if (hubState.evalSummary) parts.push(`Latest evals: ${hubState.evalSummary}`)
+    if (hubState.recentFiles.length > 0) {
+      parts.push(`Recently changed files: ${hubState.recentFiles.slice(0, 10).join(", ")}`)
+    }
+    sections.push("## Hub State\n" + parts.join("\n"))
+  }
+
+  // 3. Team activity — commits by other authors
+  const teamActivity = getTeamActivity(root, 48)
+  if (teamActivity.length > 0) {
+    sections.push("## Team Activity (48h)\n" + teamActivity.map(a => `- ${a}`).join("\n"))
+  }
+
+  // 4. Open PRs — this repo + registered services
+  const localPRs = getOpenPRs(root)
+  const crossPRs = getCrossRepoPRs(root)
+  const allPRs = [...localPRs, ...crossPRs]
+  if (allPRs.length > 0) {
+    const prLines = allPRs.slice(0, 8).map(pr =>
+      `- #${pr.number} ${pr.title} (${pr.author})`
+    )
+    sections.push("## Open PRs\n" + prLines.join("\n"))
+  }
+
+  // 5. Next actions — from journal "next" fields + last session context
+  const nextActions = getNextActions(root)
+  if (nextActions.length > 0) {
+    const unique = [...new Set(nextActions)].slice(0, 3)
+    sections.push("## Suggested Next Actions\n" + unique.map(a => `- ${a}`).join("\n"))
+  }
+
+  return sections.join("\n\n")
+}
+
+function getTimeAgo(ts: string): string {
+  if (!ts) return ""
+  try {
+    const diff = Date.now() - new Date(ts).getTime()
+    const hours = Math.floor(diff / 3600000)
+    if (hours < 1) return "just now"
+    if (hours < 24) return `${hours}h ago`
+    const days = Math.floor(hours / 24)
+    return `${days}d ago`
+  } catch {
+    return ""
+  }
+}
+
+// ─── Fire the steer ──────────────────────────────────────────────────────────
+
+export async function fireStartupBriefing(ctx: PiContext, config: JflConfig): Promise<void> {
+  if (config.pi?.disable_briefing) return
+
+  try {
+    const briefingData = await buildStartupBriefing(ctx, config)
+    if (!briefingData) return
+
+    const projectName = config.name || ctx.session.projectRoot.split("/").pop() || "project"
+
+    const steerContent = [
+      `JFL session ready: "${projectName}" on branch ${ctx.session.branch}.`,
+      "",
+      "Here is the current project state. Use this to greet the user with a concise briefing:",
+      "",
+      briefingData,
+      "",
+      "---",
+      "INSTRUCTIONS: Give a concise briefing (5-10 lines). Include:",
+      "1. Current phase / what's hot right now",
+      "2. What the LAST SESSION was working on (from 'Last Session' section) — be specific about files, features, decisions",
+      "3. Key recent wins or changes (from synopsis/journal — deduplicated, not repeated entries)",
+      "4. What others on the team have been working on (if any team activity)",
+      "5. Open PRs that need attention (if any)",
+      "6. A concrete suggested next action based on journal 'next' fields AND what the last session was doing",
+      "",
+      "End with: What do you want to hit?",
+      "",
+      "Be direct and useful. No setup noise. No tool calls needed — everything is above.",
+      "When suggesting next actions, be SPECIFIC — name the file, the function, the metric. Not vague strategy.",
+    ].join("\n")
+
+    // Fire immediately — called after onboarding overlay has already dismissed
+    ctx.pi.sendMessage(
+      {
+        customType: "jfl-startup-briefing",
+        content: steerContent,
+        display: false,
+      },
+      { triggerTurn: true, deliverAs: "steer" }
+    )
+  } catch (err) {
+    ctx.log(`Startup briefing failed: ${err}`, "debug")
+  }
+}

package/packages/pi/extensions/stratus-bridge.ts

@@ -0,0 +1,116 @@
+/**
+ * Stratus Bridge Extension
+ *
+ * Wires the RL prediction loop: predict before agent starts, resolve after,
+ * emit training tuples, and buffer for nightly policy head training.
+ *
+ * @purpose RL flywheel — predict/resolve per agent turn, emit training tuples to Stratus
+ */
+
+import { existsSync, appendFileSync, mkdirSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import type { PiContext, AgentStartEvent, AgentEndEvent } from "./types.js"
+import { jflImport } from "./jfl-resolve.js"
+import { emitCustomEvent } from "./map-bridge.js"
+
+const TRAINING_BUFFER = join(homedir(), ".jfl", "training-buffer.jsonl")
+
+let projectRoot = ""
+const sessionPredictions = new Map<string, string>()
+// Store current prediction per session (replaces ctx.session.custom)
+let currentPredictionId: string | undefined
+let currentPredictionKey: string | undefined
+
+function getTrainingBufferPath(): string {
+  const dir = join(homedir(), ".jfl")
+  mkdirSync(dir, { recursive: true })
+  return TRAINING_BUFFER
+}
+
+async function getPredictor(root: string) {
+  try {
+    // @ts-ignore — resolved from jfl package at runtime
+    const { Predictor } = await jflImport("predictor")
+    return new Predictor(root)
+  } catch {
+    return null
+  }
+}
+
+function buildProposal(event: AgentStartEvent) {
+  return {
+    description: event.prompt?.slice(0, 200) ?? "agent task",
+    change_type: "feature" as const,
+    scope: "medium" as const,
+  }
+}
+
+export async function onAgentStart(ctx: PiContext, event: AgentStartEvent): Promise<void> {
+  if (!projectRoot) return
+
+  const predictor = await getPredictor(projectRoot)
+  if (!predictor) return
+
+  try {
+    const prediction = await predictor.predict({
+      proposal: buildProposal(event),
+      current_score: 0,
+      goal: "improve project quality",
+      recent_trajectory: [],
+    })
+
+    const key = `${ctx.session.id}:${Date.now()}`
+    sessionPredictions.set(key, prediction.prediction_id)
+    currentPredictionId = prediction.prediction_id
+    currentPredictionKey = key
+
+    ctx.log(`Stratus prediction: ${prediction.recommendation} (Δ${prediction.predicted_delta.toFixed(3)})`, "debug")
+  } catch (err) {
+    ctx.log(`Stratus predict failed: ${err}`, "debug")
+  }
+}
+
+export async function onAgentEnd(ctx: PiContext, event: AgentEndEvent): Promise<void> {
+  if (!projectRoot) return
+
+  const predictionId = currentPredictionId
+  if (!predictionId) return
+
+  const predictor = await getPredictor(projectRoot)
+  if (!predictor) return
+
+  try {
+    const actualDelta = event.exitReason === "success" ? 0.05 : 0.0
+    await predictor.resolve(predictionId, actualDelta, {
+      eval_run_id: ctx.session.id,
+      resolved_at: new Date().toISOString(),
+    })
+
+    const tuple = {
+      ts: new Date().toISOString(),
+      session_id: ctx.session.id,
+      prediction_id: predictionId,
+      actual_delta: actualDelta,
+      turn_count: event.turnCount ?? 0,
+      model: event.model,
+      exit_reason: event.exitReason,
+    }
+
+    appendFileSync(getTrainingBufferPath(), JSON.stringify(tuple) + "\n")
+    await emitCustomEvent(ctx, "training:tuple:added", tuple)
+
+    currentPredictionId = undefined
+    currentPredictionKey = undefined
+  } catch (err) {
+    ctx.log(`Stratus resolve failed: ${err}`, "debug")
+  }
+}
+
+export function setProjectRoot(root: string): void {
+  projectRoot = root
+}
+
+export function initStratusBridge(root: string): void {
+  projectRoot = root
+}