@leing2021/super-pi 0.23.1 → 0.23.3

package/extensions/ce-core/index.ts

@@ -310,6 +310,7 @@ const contextHandoffParams = Type.Object({
     Type.Literal("load"),
     Type.Literal("latest"),
     Type.Literal("status"),
+    Type.Literal("validate"),
   ], { description: "Handoff operation" }),
   repoRoot: Type.String({ description: "Repository root" }),
   currentStage: Type.Optional(Type.String({ description: "Current pipeline stage (e.g. 02-plan)" })),
@@ -326,6 +327,11 @@ const contextHandoffParams = Type.Object({
   artifacts: Type.Optional(Type.Record(Type.String(), Type.Optional(Type.String()), { description: "Artifact paths (requirements, plan, checkpoint, proof)" })),
   handoffMarkdown: Type.Optional(Type.String({ description: "Custom handoff markdown content" })),
   handoffPath: Type.Optional(Type.String({ description: "Specific handoff file path to load" })),
+  currentTruth: Type.Optional(Type.Array(Type.String(), { description: "Known true statements validated during session" })),
+  invalidatedAssumptions: Type.Optional(Type.Array(Type.String(), { description: "Assumptions proven wrong during session" })),
+  openDecisions: Type.Optional(Type.Array(Type.String(), { description: "Pending decisions that affect next steps" })),
+  recentlyAccessedFiles: Type.Optional(Type.Array(Type.String(), { description: "Files recently read or edited (defaults to activeFiles)" })),
+  compressionRisk: Type.Optional(Type.Array(Type.String(), { description: "Context compression risks to watch for" })),
 })
 
 const patternExtractorParams = Type.Object({
@@ -388,18 +394,21 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
     if (thinkingStrategy) {
       const targetThinking = thinkingStrategy[stageKey] ?? thinkingStrategy.default
       if (targetThinking) {
-        const levelMap: Record<string, "low" | "medium" | "high"> = {
+        const levelMap: Record<string, ReturnType<ExtensionAPI["getThinkingLevel"]>> = {
+          off: "off",
+          minimal: "minimal",
           low: "low",
           medium: "medium",
           high: "high",
+          xhigh: "xhigh",
           "0": "low",
           "1": "medium",
           "2": "high",
         }
         const normalized = levelMap[targetThinking.toLowerCase()] ?? "medium"
-        const currentLevel = ctx.getThinkingLevel?.() ?? "medium"
+        const currentLevel = pi.getThinkingLevel()
         if (currentLevel !== normalized) {
-          ctx.setThinkingLevel?.(normalized)
+          pi.setThinkingLevel(normalized)
           if (ctx.hasUI) {
             ctx.ui.notify(`Switched thinking level for ${stageKey}: ${normalized}`, "info")
           }
@@ -743,7 +752,7 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: contextHandoff.name,
     label: "Context Handoff",
-    description: "Manage cross-stage context handoffs with evidence-first templates. Supports save (write handoff + state), load (read handoff + state), latest (read latest dated handoff), and status (read current state).",
+    description: "Manage cross-stage context handoffs with evidence-first templates. Supports save (write handoff + state), load (read handoff + state), latest (read latest dated handoff), status (read current state), and validate (check continuation readiness with deterministic probes).",
     parameters: contextHandoffParams,
     async execute(_toolCallId, params) {
       const result = await contextHandoff.execute({
@@ -758,6 +767,11 @@ export default function ceCoreExtension(pi: ExtensionAPI) {
         artifacts: params.artifacts as Record<string, string | undefined> | undefined,
         handoffMarkdown: params.handoffMarkdown,
         handoffPath: params.handoffPath,
+        currentTruth: params.currentTruth,
+        invalidatedAssumptions: params.invalidatedAssumptions,
+        openDecisions: params.openDecisions,
+        recentlyAccessedFiles: params.recentlyAccessedFiles,
+        compressionRisk: params.compressionRisk,
       })
 
       return {

package/extensions/ce-core/tools/context-handoff.ts

@@ -5,8 +5,23 @@ import { normalizeSlug } from "../utils/name-utils"
 
 export type ContextHealth = "good" | "watch" | "heavy" | "critical"
 
+export type ContextHandoffRecommendedAction = "continue" | "save_handoff" | "fill_required_context"
+
+export interface ContextHandoffValidationCheck {
+  name: string
+  passed: boolean
+  reason: string
+}
+
+export interface ContextHandoffValidationProbes {
+  recall: boolean
+  continuation: boolean
+  artifact: boolean
+  decision: boolean
+}
+
 export interface ContextHandoffInput {
-  operation: "save" | "load" | "latest" | "status"
+  operation: "save" | "load" | "latest" | "status" | "validate"
   repoRoot: string
   currentStage?: string
   nextStage?: string
@@ -17,6 +32,11 @@ export interface ContextHandoffInput {
   artifacts?: Record<string, string | undefined>
   handoffMarkdown?: string
   handoffPath?: string
+  currentTruth?: string[]
+  invalidatedAssumptions?: string[]
+  openDecisions?: string[]
+  recentlyAccessedFiles?: string[]
+  compressionRisk?: string[]
 }
 
 export interface ContextStateEntry {
@@ -29,6 +49,11 @@ export interface ContextStateEntry {
   blocker?: string
   verification?: string
   artifacts: Record<string, string | undefined>
+  currentTruth: string[]
+  invalidatedAssumptions: string[]
+  openDecisions: string[]
+  recentlyAccessedFiles: string[]
+  compressionRisk: string[]
   recommendNewSession: boolean
   updatedAt: string
 }
@@ -47,7 +72,19 @@ export interface ContextHandoffResult {
   artifacts?: Record<string, string | undefined>
   recommendNewSession?: boolean
   handoffMarkdown?: string
+  currentTruth?: string[]
+  invalidatedAssumptions?: string[]
+  openDecisions?: string[]
+  recentlyAccessedFiles?: string[]
+  compressionRisk?: string[]
   updatedAt?: string
+  // Validation fields
+  ok?: boolean
+  probes?: ContextHandoffValidationProbes
+  checks?: ContextHandoffValidationCheck[]
+  missing?: string[]
+  warnings?: string[]
+  recommendedAction?: ContextHandoffRecommendedAction
 }
 
 function ceDir(repoRoot: string): string {
@@ -112,6 +149,11 @@ function buildDefaultHandoffMarkdown(input: {
   artifacts: Record<string, string | undefined>
   blocker?: string
   verification?: string
+  currentTruth: string[]
+  invalidatedAssumptions: string[]
+  openDecisions: string[]
+  recentlyAccessedFiles: string[]
+  compressionRisk: string[]
 }): string {
   const currentTask = input.nextStage
     ? `Continue from ${input.currentStage} to ${input.nextStage}.`
@@ -137,12 +179,24 @@ function buildDefaultHandoffMarkdown(input: {
     "## Hot Context",
     hotContext,
     "",
+    "## Current Truth",
+    formatBullets(input.currentTruth),
+    "",
     "## Verified Facts",
     verifiedFacts,
     "",
+    "## Invalidated Assumptions",
+    formatBullets(input.invalidatedAssumptions),
+    "",
+    "## Open Decisions",
+    formatBullets(input.openDecisions),
+    "",
     "## Active Files",
     activeFiles,
     "",
+    "## Recently Accessed Files",
+    formatBullets(input.recentlyAccessedFiles),
+    "",
     "## Artifacts",
     artifacts,
     "",
@@ -152,6 +206,9 @@ function buildDefaultHandoffMarkdown(input: {
     "## Verification",
     `- ${verification}`,
     "",
+    "## Compression Risk",
+    formatBullets(input.compressionRisk),
+    "",
     "## Do Not Repeat",
     "- Do not reload full history unless the handoff lacks required evidence.",
     "",
@@ -161,13 +218,54 @@ function buildDefaultHandoffMarkdown(input: {
   ].join("\n")
 }
 
+function toStringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+}
+
+function normalizeStateEntry(raw: unknown): ContextStateEntry | null {
+  if (!raw || typeof raw !== "object") return null
+
+  const state = raw as Record<string, unknown>
+  const activeFiles = toStringArray(state.activeFiles)
+
+  return {
+    currentStage: typeof state.currentStage === "string" ? state.currentStage : "unknown",
+    nextStage: typeof state.nextStage === "string" ? state.nextStage : undefined,
+    contextHealth: isContextHealth(state.contextHealth) ? state.contextHealth : "watch",
+    latestHandoffPath: typeof state.latestHandoffPath === "string" ? state.latestHandoffPath : undefined,
+    latestDatedHandoffPath: typeof state.latestDatedHandoffPath === "string" ? state.latestDatedHandoffPath : undefined,
+    activeFiles,
+    blocker: typeof state.blocker === "string" ? state.blocker : undefined,
+    verification: typeof state.verification === "string" ? state.verification : undefined,
+    artifacts: isStringRecord(state.artifacts) ? state.artifacts : {},
+    currentTruth: toStringArray(state.currentTruth),
+    invalidatedAssumptions: toStringArray(state.invalidatedAssumptions),
+    openDecisions: toStringArray(state.openDecisions),
+    recentlyAccessedFiles: toStringArray(state.recentlyAccessedFiles).length > 0
+      ? toStringArray(state.recentlyAccessedFiles)
+      : activeFiles.slice(0, 5),
+    compressionRisk: toStringArray(state.compressionRisk),
+    recommendNewSession: typeof state.recommendNewSession === "boolean" ? state.recommendNewSession : false,
+    updatedAt: typeof state.updatedAt === "string" ? state.updatedAt : new Date(0).toISOString(),
+  }
+}
+
+function isContextHealth(value: unknown): value is ContextHealth {
+  return value === "good" || value === "watch" || value === "heavy" || value === "critical"
+}
+
+function isStringRecord(value: unknown): value is Record<string, string | undefined> {
+  if (!value || typeof value !== "object") return false
+  return Object.values(value).every(item => item === undefined || typeof item === "string")
+}
+
 async function readState(repoRoot: string): Promise<ContextStateEntry | null> {
   const filePath = stateFilePath(repoRoot)
   if (!existsSync(filePath)) return null
 
   try {
     const content = await readFile(filePath, "utf8")
-    return JSON.parse(content) as ContextStateEntry
+    return normalizeStateEntry(JSON.parse(content))
   } catch {
     return null
   }
@@ -192,6 +290,8 @@ export function createContextHandoffTool() {
           return latest(input)
         case "status":
           return status(input)
+        case "validate":
+          return validate(input)
         default:
           throw new Error(`Unknown operation: ${input.operation}`)
       }
@@ -207,6 +307,14 @@ async function save(input: ContextHandoffInput): Promise<ContextHandoffResult> {
   const blocker = input.blocker
   const verification = input.verification
   const artifacts = input.artifacts ?? {}
+  const currentTruth = input.currentTruth ?? []
+  const invalidatedAssumptions = input.invalidatedAssumptions ?? []
+  const openDecisions = input.openDecisions ?? []
+  const recentlyAccessedFiles = input.recentlyAccessedFiles?.length
+    ? input.recentlyAccessedFiles
+    : activeFiles.slice(0, 5)
+  const compressionRisk = input.compressionRisk ?? []
+
   const handoffMarkdown = input.handoffMarkdown?.trim().length
     ? input.handoffMarkdown
     : buildDefaultHandoffMarkdown({
@@ -216,6 +324,11 @@ async function save(input: ContextHandoffInput): Promise<ContextHandoffResult> {
       artifacts,
       blocker,
       verification,
+      currentTruth,
+      invalidatedAssumptions,
+      openDecisions,
+      recentlyAccessedFiles,
+      compressionRisk,
     })
 
   const recommendNewSession = computeRecommendNewSession(currentStage, nextStage, contextHealth)
@@ -238,6 +351,11 @@ async function save(input: ContextHandoffInput): Promise<ContextHandoffResult> {
     blocker,
     verification,
     artifacts,
+    currentTruth,
+    invalidatedAssumptions,
+    openDecisions,
+    recentlyAccessedFiles,
+    compressionRisk,
     recommendNewSession,
     updatedAt: new Date().toISOString(),
   }
@@ -256,6 +374,11 @@ async function save(input: ContextHandoffInput): Promise<ContextHandoffResult> {
     blocker,
     verification,
     artifacts,
+    currentTruth,
+    invalidatedAssumptions,
+    openDecisions,
+    recentlyAccessedFiles,
+    compressionRisk,
     recommendNewSession,
     updatedAt: state.updatedAt,
   }
@@ -291,6 +414,11 @@ async function load(input: ContextHandoffInput): Promise<ContextHandoffResult> {
     blocker: state.blocker,
     verification: state.verification,
     artifacts: state.artifacts,
+    currentTruth: state.currentTruth,
+    invalidatedAssumptions: state.invalidatedAssumptions,
+    openDecisions: state.openDecisions,
+    recentlyAccessedFiles: state.recentlyAccessedFiles,
+    compressionRisk: state.compressionRisk,
     recommendNewSession: state.recommendNewSession,
     handoffMarkdown: markdown,
     updatedAt: state.updatedAt,
@@ -320,11 +448,282 @@ async function latest(input: ContextHandoffInput): Promise<ContextHandoffResult>
     blocker: state.blocker,
     verification: state.verification,
     artifacts: state.artifacts,
+    currentTruth: state.currentTruth,
+    invalidatedAssumptions: state.invalidatedAssumptions,
+    openDecisions: state.openDecisions,
+    recentlyAccessedFiles: state.recentlyAccessedFiles,
+    compressionRisk: state.compressionRisk,
     recommendNewSession: state.recommendNewSession,
     updatedAt: state.updatedAt,
   }
 }
 
+const PLACEHOLDER_VALUES = new Set(["n/a", "na", "not run", "none", "", "-"])
+const PLACEHOLDER_PREFIXES = ["- n/a", "- na", "- not run", "- none", "- "]
+
+function isPlaceholder(text: string): boolean {
+  const trimmed = text.trim().toLowerCase()
+  if (PLACEHOLDER_VALUES.has(trimmed)) return true
+  for (const prefix of PLACEHOLDER_PREFIXES) {
+    if (trimmed === prefix) return true
+  }
+  return false
+}
+
+function isMeaningfulText(value?: string): boolean {
+  return Boolean(value && !isPlaceholder(value))
+}
+
+function toPublicHandoffPath(repoRoot: string, filePath: string): string {
+  return path.isAbsolute(filePath) ? toRepoRelative(repoRoot, filePath) : filePath
+}
+
+function extractSection(markdown: string, heading: string): string {
+  const lines = markdown.split("\n")
+  const sectionLines: string[] = []
+  let inSection = false
+
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      if (inSection) break
+      if (line.slice(3).trim() === heading) {
+        inSection = true
+      }
+      continue
+    }
+    if (inSection) {
+      sectionLines.push(line)
+    }
+  }
+
+  return sectionLines.join("\n").trim()
+}
+
+function sectionHasMeaningfulContent(markdown: string, heading: string): boolean {
+  const section = extractSection(markdown, heading)
+  if (!section) return false
+
+  const lines = section.split("\n")
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    if (!isPlaceholder(trimmed)) return true
+  }
+  return false
+}
+
+function hasMeaningfulArray(arr: string[]): boolean {
+  return arr.some(item => isMeaningfulText(item))
+}
+
+function hasMeaningfulRecord(rec: Record<string, string | undefined>): boolean {
+  return Object.values(rec).some(isMeaningfulText)
+}
+
+function isMeaningfulStage(value?: string): boolean {
+  return Boolean(value && value.trim().length > 0 && value !== "unknown" && !isPlaceholder(value))
+}
+
+async function validate(input: ContextHandoffInput): Promise<ContextHandoffResult> {
+  const checks: ContextHandoffValidationCheck[] = []
+  const missing: string[] = []
+  const warnings: string[] = []
+
+  // Read state
+  const state = await readState(input.repoRoot)
+  const hasState = state !== null
+
+  // Read markdown
+  let markdown = ""
+  let hasMarkdown = false
+  let handoffFile = ""
+
+  if (input.handoffPath) {
+    const absolutePath = resolveRepoPath(input.repoRoot, input.handoffPath)
+    if (existsSync(absolutePath)) {
+      markdown = await readFile(absolutePath, "utf8")
+      hasMarkdown = markdown.trim().length > 0
+      handoffFile = toPublicHandoffPath(input.repoRoot, input.handoffPath)
+    }
+  }
+
+  if (!hasMarkdown && state?.latestHandoffPath) {
+    const absolutePath = resolveRepoPath(input.repoRoot, state.latestHandoffPath)
+    if (existsSync(absolutePath)) {
+      markdown = await readFile(absolutePath, "utf8")
+      hasMarkdown = markdown.trim().length > 0
+      handoffFile = toPublicHandoffPath(input.repoRoot, state.latestHandoffPath)
+    }
+  }
+
+  if (!hasMarkdown) {
+    const latestPath = latestHandoffPath(input.repoRoot)
+    if (existsSync(latestPath)) {
+      markdown = await readFile(latestPath, "utf8")
+      hasMarkdown = markdown.trim().length > 0
+      handoffFile = toRepoRelative(input.repoRoot, latestPath)
+    }
+  }
+
+  const found = hasState || hasMarkdown
+
+  checks.push({
+    name: "state_exists",
+    passed: hasState,
+    reason: hasState ? "Found context-state.json" : "No context-state.json found",
+  })
+
+  checks.push({
+    name: "handoff_exists",
+    passed: hasMarkdown,
+    reason: hasMarkdown ? "Found handoff markdown" : "No handoff markdown found",
+  })
+
+  // --- Recall probe ---
+  const hasCurrentTruth = state ? hasMeaningfulArray(state.currentTruth) : false
+  const hasCurrentStage = state ? isMeaningfulStage(state.currentStage) : false
+  const hasCurrentTaskSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Current Task")
+
+  const recallPass = hasCurrentTruth || (hasCurrentStage && (hasMarkdown || (state?.nextStage !== undefined))) || hasCurrentTaskSection
+
+  checks.push({
+    name: "recall_current_truth",
+    passed: hasCurrentTruth,
+    reason: hasCurrentTruth ? `Found ${state!.currentTruth.length} current truth entries` : "No current truth entries",
+  })
+
+  checks.push({
+    name: "recall_current_task",
+    passed: hasCurrentTaskSection,
+    reason: hasCurrentTaskSection ? "Current Task section has meaningful content" : "Current Task section is missing or placeholder",
+  })
+
+  checks.push({
+    name: "recall_current_stage",
+    passed: hasCurrentStage,
+    reason: hasCurrentStage ? `Current stage: ${state!.currentStage}` : "No meaningful current stage",
+  })
+
+  if (!recallPass) {
+    missing.push("recall: current task or goal evidence")
+  }
+
+  // --- Continuation probe ---
+  // Tightened: only actionable next-step evidence passes
+  const hasNextStage = state ? isMeaningfulStage(state.nextStage) : false
+  const hasNextMinimalStep = hasMarkdown && sectionHasMeaningfulContent(markdown, "Next Minimal Step")
+
+  const continuationPass = hasNextMinimalStep || hasNextStage
+
+  checks.push({
+    name: "continuation_next_stage",
+    passed: hasNextStage,
+    reason: hasNextStage ? `Next stage: ${state!.nextStage}` : "No meaningful next stage",
+  })
+
+  checks.push({
+    name: "continuation_next_minimal_step",
+    passed: hasNextMinimalStep,
+    reason: hasNextMinimalStep ? "Next Minimal Step has meaningful content" : "Next Minimal Step is missing or placeholder",
+  })
+
+  // Diagnostic checks (do not affect continuation pass)
+  const hasBlocker = state ? Boolean(state.blocker && !isPlaceholder(state.blocker)) : false
+  const hasVerification = state ? Boolean(state.verification && !isPlaceholder(state.verification)) : false
+  const hasVerificationSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Verification")
+
+  checks.push({
+    name: "continuation_blocker",
+    passed: hasBlocker,
+    reason: hasBlocker ? `Blocker: ${state!.blocker}` : "No blocker information",
+  })
+
+  checks.push({
+    name: "continuation_verification",
+    passed: hasVerification || hasVerificationSection,
+    reason: (hasVerification || hasVerificationSection) ? "Verification evidence present" : "No verification information",
+  })
+
+  if (!continuationPass) {
+    missing.push("continuation: next minimal step or next stage evidence")
+  }
+
+  // --- Artifact probe ---
+  const hasActiveFiles = state ? hasMeaningfulArray(state.activeFiles) : false
+  const hasRecentlyAccessed = state ? hasMeaningfulArray(state.recentlyAccessedFiles) : false
+  const hasArtifacts = state ? hasMeaningfulRecord(state.artifacts) : false
+  const hasActiveFilesSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Active Files")
+  const hasRecentlyAccessedSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Recently Accessed Files")
+  const hasArtifactsSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Artifacts")
+
+  const artifactPass = hasActiveFiles || hasRecentlyAccessed || hasArtifacts
+    || hasActiveFilesSection || hasRecentlyAccessedSection || hasArtifactsSection
+
+  checks.push({
+    name: "artifact_active_files",
+    passed: hasActiveFiles || hasActiveFilesSection,
+    reason: (hasActiveFiles || hasActiveFilesSection) ? "Active files present" : "No active files",
+  })
+
+  if (!artifactPass) {
+    warnings.push("artifact: active files or artifacts are missing")
+  }
+
+  // --- Decision probe ---
+  const hasOpenDecisions = state ? hasMeaningfulArray(state.openDecisions) : false
+  const hasInvalidatedAssumptions = state ? hasMeaningfulArray(state.invalidatedAssumptions) : false
+  const hasOpenDecisionsSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Open Decisions")
+  const hasInvalidatedSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Invalidated Assumptions")
+  const hasCurrentTruthSection = hasMarkdown && sectionHasMeaningfulContent(markdown, "Current Truth")
+
+  const decisionPass = hasOpenDecisions || hasInvalidatedAssumptions || hasCurrentTruth
+    || hasOpenDecisionsSection || hasInvalidatedSection || hasCurrentTruthSection
+
+  checks.push({
+    name: "decision_open_decisions",
+    passed: hasOpenDecisions || hasOpenDecisionsSection,
+    reason: (hasOpenDecisions || hasOpenDecisionsSection) ? "Open decisions present" : "No open decisions",
+  })
+
+  if (!decisionPass) {
+    warnings.push("decision: decisions or invalidated assumptions are missing")
+  }
+
+  // --- ok derivation ---
+  const ok = recallPass && continuationPass
+
+  // --- recommended action ---
+  let recommendedAction: ContextHandoffRecommendedAction
+  if (!found) {
+    recommendedAction = "save_handoff"
+  } else if (!ok) {
+    recommendedAction = "fill_required_context"
+  } else {
+    recommendedAction = "continue"
+  }
+
+  return {
+    operation: "validate",
+    found,
+    ok,
+    path: handoffFile || undefined,
+    probes: {
+      recall: recallPass,
+      continuation: continuationPass,
+      artifact: artifactPass,
+      decision: decisionPass,
+    },
+    checks,
+    missing,
+    warnings,
+    recommendedAction,
+    currentStage: state?.currentStage,
+    nextStage: state?.nextStage,
+    contextHealth: state?.contextHealth,
+    updatedAt: state?.updatedAt,
+  }
+}
+
 async function status(input: ContextHandoffInput): Promise<ContextHandoffResult> {
   const state = await readState(input.repoRoot)
 
@@ -351,6 +750,11 @@ async function status(input: ContextHandoffInput): Promise<ContextHandoffResult>
     blocker: state.blocker,
     verification: state.verification,
     artifacts: state.artifacts,
+    currentTruth: state.currentTruth,
+    invalidatedAssumptions: state.invalidatedAssumptions,
+    openDecisions: state.openDecisions,
+    recentlyAccessedFiles: state.recentlyAccessedFiles,
+    compressionRisk: state.compressionRisk,
     recommendNewSession: state.recommendNewSession,
     updatedAt: state.updatedAt,
   }

package/extensions/ce-core/tools/workflow-state.ts

@@ -1,4 +1,4 @@
-import { readdirSync, statSync, existsSync } from "node:fs"
+import { readdirSync, existsSync, readFileSync } from "node:fs"
 import path from "node:path"
 
 export interface WorkflowCategoryState {
@@ -6,6 +6,25 @@ export interface WorkflowCategoryState {
   latest: string | null
 }
 
+export interface WorkflowContextState {
+  found: boolean
+  currentStage?: string
+  nextStage?: string
+  contextHealth?: string
+  latestHandoffPath?: string
+  latestDatedHandoffPath?: string
+  activeFiles: string[]
+  recentlyAccessedFiles: string[]
+  blocker?: string
+  verification?: string
+  currentTruth: string[]
+  invalidatedAssumptions: string[]
+  openDecisions: string[]
+  compressionRisk: string[]
+  recommendNewSession?: boolean
+  updatedAt?: string
+}
+
 export interface WorkflowStateInput {
   repoRoot: string
 }
@@ -15,6 +34,7 @@ export interface WorkflowStateResult {
   plans: WorkflowCategoryState
   solutions: WorkflowCategoryState
   runs: WorkflowCategoryState
+  context: WorkflowContextState
 }
 
 function emptyCategory(): WorkflowCategoryState {
@@ -63,6 +83,52 @@ function collectFiles(dirPath: string): string[] {
   return results
 }
 
+function emptyContext(): WorkflowContextState {
+  return {
+    found: false,
+    activeFiles: [],
+    recentlyAccessedFiles: [],
+    currentTruth: [],
+    invalidatedAssumptions: [],
+    openDecisions: [],
+    compressionRisk: [],
+  }
+}
+
+function toStringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+}
+
+function readContextState(repoRoot: string): WorkflowContextState {
+  const statePath = path.join(repoRoot, ".context", "compound-engineering", "context-state.json")
+  if (!existsSync(statePath)) return emptyContext()
+
+  try {
+    const raw = readFileSync(statePath, "utf8")
+    const state = JSON.parse(raw) as Record<string, unknown>
+    return {
+      found: true,
+      currentStage: typeof state.currentStage === "string" ? state.currentStage : undefined,
+      nextStage: typeof state.nextStage === "string" ? state.nextStage : undefined,
+      contextHealth: typeof state.contextHealth === "string" ? state.contextHealth : undefined,
+      latestHandoffPath: typeof state.latestHandoffPath === "string" ? state.latestHandoffPath : undefined,
+      latestDatedHandoffPath: typeof state.latestDatedHandoffPath === "string" ? state.latestDatedHandoffPath : undefined,
+      activeFiles: toStringArray(state.activeFiles),
+      recentlyAccessedFiles: toStringArray(state.recentlyAccessedFiles),
+      blocker: typeof state.blocker === "string" ? state.blocker : undefined,
+      verification: typeof state.verification === "string" ? state.verification : undefined,
+      currentTruth: toStringArray(state.currentTruth),
+      invalidatedAssumptions: toStringArray(state.invalidatedAssumptions),
+      openDecisions: toStringArray(state.openDecisions),
+      compressionRisk: toStringArray(state.compressionRisk),
+      recommendNewSession: typeof state.recommendNewSession === "boolean" ? state.recommendNewSession : undefined,
+      updatedAt: typeof state.updatedAt === "string" ? state.updatedAt : undefined,
+    }
+  } catch {
+    return emptyContext()
+  }
+}
+
 export function createWorkflowStateTool() {
   return {
     name: "workflow_state",
@@ -74,6 +140,7 @@ export function createWorkflowStateTool() {
         plans: scanDir(path.join(repoRoot, "docs", "plans")),
         solutions: scanDir(path.join(repoRoot, "docs", "solutions")),
         runs: scanDir(path.join(repoRoot, ".context", "compound-engineering")),
+        context: readContextState(repoRoot),
       }
     },
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leing2021/super-pi",
-  "version": "0.23.1",
+  "version": "0.23.3",
   "private": false,
   "type": "module",
   "description": "Pi-native Compound Engineering package for iterative development workflows",

package/skills/references/pipeline-config.md

@@ -55,12 +55,24 @@ When a stage produces or updates handoff-lite, use this evidence-first structure
 ## Hot Context
 - 1-5 must-know facts for the next step
 
+## Current Truth
+- validated truths that must survive compression
+
 ## Verified Facts
 - already validated facts (do not re-prove)
 
+## Invalidated Assumptions
+- assumptions proven wrong this session
+
+## Open Decisions
+- pending decisions that affect next steps
+
 ## Active Files
 - 1-5 file paths only
 
+## Recently Accessed Files
+- files recently read or edited
+
 ## Artifacts
 - requirements: <path or N/A>
 - plan: <path or N/A>
@@ -73,6 +85,9 @@ When a stage produces or updates handoff-lite, use this evidence-first structure
 ## Verification
 - <latest command + result or Not run>
 
+## Compression Risk
+- context compression risks to watch for
+
 ## Do Not Repeat
 - what should not be re-read/re-run unless needed