@agent-finops/core 0.8.0 → 0.9.0

package/dist/glance.js

@@ -3,6 +3,7 @@ import { canPriceTokenUsageAtScope, estimateTokenCostUsd, PRICING_TABLE_AS_OF }
 import { subscriptionPlans } from "./planMath.js";
 import { buildContextHealth } from "./contextHealth.js";
 import { localAgentFormatDescriptors, localAgentFormatSupports } from "./localAgentFormats/registry.js";
+import { aibillImproveCommandV0 } from "./runtimeCommands.js";
 const HOUR_MS = 60 * 60 * 1_000;
 const DAY_MS = 24 * HOUR_MS;
 /**
@@ -45,7 +46,7 @@ export function buildUsageGlance(calls, options = {}) {
         : null;
     const limitCalls = sanitizeStringMetadata(options.limitCalls ?? safeCalls)
         .filter((call) => localAgentFormatSupports(call.agent, "rateLimits"));
-    const limits = latestLimits(limitCalls, now).map(({ agent, window, observedAt }) => toGlanceLimit(agent, window, observedAt));
+    const limits = latestLimits(limitCalls, now).map(({ agent, window, observedAt }) => toGlanceLimit(agent, window, observedAt, now));
     const windowStart = now.getTime() - focusWindowDays * DAY_MS;
     const windowCalls = safeCalls.filter((call) => Date.parse(call.timestamp) >= windowStart);
     const windowSessions = groupSessions(windowCalls);
@@ -55,20 +56,41 @@ export function buildUsageGlance(calls, options = {}) {
     const focusSessions = latest?.project && !isGenericProject(latest.project)
         ? windowSessions.filter((session) => session.project === latest.project)
         : windowSessions;
-    const focus = buildMainFocus(focusSessions, focusWindowDays, now);
-    const sessionHealth = suppliedContextHealth ?? buildContextHealth({ calls: safeCalls, now });
-    const anomaly = anomalyFromContextHealth(sessionHealth);
-    const primaryAction = buildPrimaryAction({
-        currentSession,
-        focus,
-        limits,
-        sessionHealth,
-        generatedAt: now.toISOString(),
-        filesParsed: options.filesParsed ?? 0
-    });
+    const qualitativeCoverage = options.qualitativeCoverage ?? {
+        status: "complete",
+        selectedFiles: options.filesParsed ?? 0,
+        readCompletely: options.filesParsed ?? 0,
+        skippedForBudget: 0
+    };
+    const qualitativeComplete = qualitativeCoverage.status === "complete";
+    const focus = qualitativeComplete
+        ? buildMainFocus(focusSessions, focusWindowDays, now)
+        : null;
+    const baseSessionHealth = suppliedContextHealth ?? buildContextHealth({ calls: safeCalls, now });
+    const sessionHealth = {
+        ...baseSessionHealth,
+        qualitativeCoverage
+    };
+    const anomaly = qualitativeComplete ? anomalyFromContextHealth(sessionHealth) : null;
+    const primaryAction = qualitativeComplete
+        ? buildPrimaryAction({
+            currentSession,
+            focus,
+            limits,
+            sessionHealth,
+            generatedAt: now.toISOString(),
+            filesParsed: options.filesParsed ?? 0
+        })
+        : buildCoverageLimitedPrimaryAction({
+            currentSession,
+            sessionHealth,
+            coverage: qualitativeCoverage
+        });
+    const tokenExperiment = sanitizeActionVerificationProjection(options.actionVerificationProjection);
     const detectedAgents = (options.detectedAgents ?? uniqueAgents(safeCalls))
         .filter((agent) => localAgentFormatSupports(agent, "glance"));
-    const agentsWithLimits = new Set(limits.map((limit) => limit.agent));
+    const agentsWithCurrentLimits = new Set(limits.filter((limit) => limit.freshness === "current").map((limit) => limit.agent));
+    const agentsWithStaleLimits = new Set(limits.filter((limit) => limit.freshness === "stale").map((limit) => limit.agent));
     const limitAgents = uniqueAgents(limitCalls.filter((call) => call.rateLimits));
     const reportedWindows = (agent) => ([...new Set(limits
             .filter((limit) => limit.agent === agent)
@@ -77,22 +99,30 @@ export function buildUsageGlance(calls, options = {}) {
         "Session value is an API-equivalent estimate from transcript token counts, not an invoice or subscription charge.",
         "A detected monthly subscription changes the interpretation, not the token math: the API-equivalent amount is usage priced at list rates, not incremental spend or business outcome value.",
         "Exhaustion time is a pace projection; remaining percentage and reset time are provider-reported only when embedded in a transcript.",
+        "A five-hour percentage is current for at most five hours after observation; a weekly percentage is current for at most 24 hours. Older transcript evidence is labeled stale and never drives an action.",
         "Main focus is a local summary of observed human prompts and tool activity, not elapsed time or spend; raw prompts are not returned.",
         "The primary action combines Context Health, Main focus, and reported runway locally. It only provides a copyable handoff prompt and never runs an agent automatically.",
+        "A token-test percentage compares matched local session cohorts guarded by explicit quality evidence; it is not certified savings, verified outcome ROI, or a provider bill.",
         "Claude Code transcripts do not report plan headroom. Missing limits remain unavailable instead of being inferred.",
-        "Cursor and GitHub Copilot require their provider connections because their local chat stores are not treated as authoritative billing transcripts."
+        "Cursor and GitHub Copilot require their provider connections because their local chat stores are not treated as authoritative billing transcripts.",
+        ...(qualitativeComplete ? [] : [
+            "Main focus, anomaly, and context-change handoff are unavailable because the bounded qualitative index is incomplete; no global driver was inferred from a selected subset."
+        ])
     ];
     return {
         dataMode: "local_transcripts",
         generatedAt: now.toISOString(),
         coverage: {
             filesParsed: options.filesParsed ?? 0,
+            qualitative: qualitativeCoverage,
             supportedTranscriptAgents: supportedFormats.map((descriptor) => descriptor.id),
             detectedAgents,
             rateLimitMetadata: supportedFormats.map((descriptor) => ({
                 agent: descriptor.id,
                 status: descriptor.capabilities.rateLimits
-                    ? agentsWithLimits.has(descriptor.id) ? "reported" : "not_seen"
+                    ? agentsWithCurrentLimits.has(descriptor.id)
+                        ? "reported"
+                        : agentsWithStaleLimits.has(descriptor.id) ? "stale" : "not_seen"
                     : "not_reported_by_transcript",
                 windowsReported: reportedWindows(descriptor.id)
             })),
@@ -142,6 +172,14 @@ export function buildUsageGlance(calls, options = {}) {
                 execution: "copy_prompt",
                 automaticExecution: false
             },
+            tokenExperiment: {
+                source: tokenExperiment
+                    ? "canonical_action_verification_projection"
+                    : "not_available",
+                calculation: "core_experiment_evaluator",
+                cohort: "matched_local_sessions",
+                automaticExecution: false
+            },
             network: {
                 uploaded: false
             }
@@ -153,9 +191,114 @@ export function buildUsageGlance(calls, options = {}) {
         anomaly,
         sessionHealth,
         primaryAction,
+        ...(tokenExperiment ? { tokenExperiment } : {}),
         caveats
     };
 }
+function buildCoverageLimitedPrimaryAction(input) {
+    const project = safeActionMetadata(input.currentSession?.project, 80);
+    const status = input.coverage.status === "partial" ? "partial" : "not available";
+    return {
+        kind: "session_handoff",
+        intent: "inspect_current_work",
+        label: project ? `Refresh evidence · ${project}` : "Refresh evidence",
+        detail: `Main focus unavailable · qualitative index ${status}`,
+        ...(project ? { project } : {}),
+        agentPrompt: [
+            "aibill's bounded qualitative evidence is incomplete.",
+            "Do not infer a global main focus, waste cause, or context change from the selected subset.",
+            `Run \`${aibillImproveCommandV0()}\` from the exact project root to refresh the private index, then review the new evidence before editing.`
+        ].join("\n"),
+        source: "context_health_focus_and_reported_runway",
+        confidence: "low",
+        execution: "copy_prompt",
+        requiresUserConfirmation: true,
+        evidenceWindowDays: input.sessionHealth.deadContext.windowDays
+    };
+}
+const actionVerificationStates = new Set([
+    "collect_baseline",
+    "approve_one_change",
+    "collect_post_change",
+    "review_measured_result",
+    "rollback",
+    "resolve_evidence",
+    "rolled_back",
+    "cancelled"
+]);
+const actionVerificationTones = new Set([
+    "neutral",
+    "attention",
+    "positive",
+    "negative"
+]);
+const actionVerificationEvidenceLabels = new Set([
+    "calculated",
+    "missing"
+]);
+const actionVerificationQualityLabels = new Set([
+    "held",
+    "regressed",
+    "insufficient"
+]);
+const actionVerificationQualityEvidence = new Set([
+    "verified",
+    "observed",
+    "user_declared",
+    "missing"
+]);
+const experimentIdPattern = /^tre_v0_[a-f0-9]{64}$/;
+const findingIdPattern = /^wf_v0_[a-f0-9]{64}$/;
+const candidateKeyPattern = /^wfc_v0_[a-f0-9]{64}$/;
+/**
+ * Treat the optional adapter input as untrusted at runtime. A malformed or
+ * internally inconsistent projection is omitted instead of becoming a stale
+ * or invented Glance claim. This function deliberately does not derive any
+ * experiment result.
+ */
+function sanitizeActionVerificationProjection(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const safe = sanitizeStringMetadata(input);
+    if (safe.schemaVersion !== 0 ||
+        !experimentIdPattern.test(safe.experimentId) ||
+        !findingIdPattern.test(safe.findingId) ||
+        !candidateKeyPattern.test(safe.candidateKey) ||
+        !actionVerificationStates.has(safe.state) ||
+        !actionVerificationTones.has(safe.tone) ||
+        !actionVerificationEvidenceLabels.has(safe.evidenceLabel) ||
+        !actionVerificationQualityLabels.has(safe.qualityLabel) ||
+        !actionVerificationQualityEvidence.has(safe.qualityEvidence) ||
+        !isSafeExperimentCount(safe.baselineSessions) ||
+        !isSafeExperimentCount(safe.postChangeSessions) ||
+        !isSafeExperimentCount(safe.minimumSessions) ||
+        safe.minimumSessions < 1 ||
+        (safe.reductionPercent !== null && (!Number.isFinite(safe.reductionPercent) ||
+            safe.reductionPercent > 100 ||
+            safe.reductionPercent < -1_000_000))) {
+        return undefined;
+    }
+    const measured = safe.state === "review_measured_result";
+    const claimQualityEvidence = safe.qualityEvidence === "verified" ||
+        safe.qualityEvidence === "observed" ||
+        safe.qualityEvidence === "user_declared";
+    if (safe.reductionPercent !== null) {
+        const claimEvidenceIsComplete = safe.evidenceLabel === "calculated" &&
+            safe.qualityLabel === "held" &&
+            claimQualityEvidence;
+        const signMatchesState = (measured && safe.reductionPercent >= 0) ||
+            (safe.state === "rollback" && safe.reductionPercent < 0);
+        if (!claimEvidenceIsComplete || !signMatchesState)
+            return undefined;
+    }
+    else if (measured) {
+        return undefined;
+    }
+    return safe;
+}
+function isSafeExperimentCount(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
 function toGlancePlan(agent, detectedPlans) {
     const detected = detectedPlans.find((plan) => plan.agent === agent);
     if (!detected)
@@ -267,8 +410,11 @@ function latestLimits(calls, now) {
     return [...byWindow.values()].sort((left, right) => (order[left.window.kind] - order[right.window.kind] ||
         left.agent.localeCompare(right.agent)));
 }
-function toGlanceLimit(agent, window, observedAt) {
-    const projection = projectExhaustion(window, observedAt);
+function toGlanceLimit(agent, window, observedAt, now) {
+    const freshness = limitEvidenceFreshness(window, observedAt, now);
+    const projection = freshness === "current"
+        ? projectExhaustion(window, observedAt, now)
+        : { at: null, beforeReset: false };
     return {
         agent,
         kind: window.kind,
@@ -279,12 +425,13 @@ function toGlanceLimit(agent, window, observedAt) {
         observedAt,
         resetsAt: window.resetsAt,
         source: "transcript_reported",
+        freshness,
         projectedExhaustionAt: projection.at,
         projectedToExhaustBeforeReset: projection.beforeReset,
         projectionConfidence: "estimated"
     };
 }
-function projectExhaustion(window, observedAt) {
+function projectExhaustion(window, observedAt, now) {
     const observedMs = Date.parse(observedAt);
     const resetMs = Date.parse(window.resetsAt);
     const windowStartMs = resetMs - window.windowMinutes * 60_000;
@@ -296,15 +443,27 @@ function projectExhaustion(window, observedAt) {
         window.usedPercent <= 0) {
         return { at: null, beforeReset: false };
     }
-    if (window.usedPercent >= 100) {
-        return { at: observedAt, beforeReset: true };
-    }
+    // A current report at the limit is an observed exhausted state, not a
+    // forecast. Keep the projection empty so downstream copy cannot describe an
+    // already-exhausted window as something that merely "may" exhaust.
+    if (window.usedPercent >= 100)
+        return { at: null, beforeReset: false };
     const remainingMs = elapsedMs * ((100 - window.usedPercent) / window.usedPercent);
     const exhaustionMs = observedMs + remainingMs;
-    return exhaustionMs < resetMs
+    return exhaustionMs > now.getTime() && exhaustionMs < resetMs
         ? { at: new Date(exhaustionMs).toISOString(), beforeReset: true }
         : { at: null, beforeReset: false };
 }
+function limitEvidenceFreshness(window, observedAt, now) {
+    const observedMs = Date.parse(observedAt);
+    const ageMs = now.getTime() - observedMs;
+    const windowMs = window.windowMinutes * 60_000;
+    const maximumAgeMs = Math.min(windowMs, DAY_MS);
+    return Number.isFinite(observedMs) && Number.isFinite(windowMs) && windowMs > 0 &&
+        ageMs >= 0 && ageMs <= maximumAgeMs
+        ? "current"
+        : "stale";
+}
 function buildMainFocus(sessions, windowDays, now) {
     const candidates = sessions.map((session) => {
         const rawActivity = session.activity ?? fallbackActivity(session);
@@ -449,8 +608,17 @@ function buildPrimaryAction(input) {
     const project = safeActionMetadata(preferredProject, 80);
     const focus = safeActionMetadata(input.focus?.summary, 120);
     const focalFile = safeActionMetadata(input.focus?.file, 100);
+    const generatedAtMs = Date.parse(input.generatedAt);
+    const exhaustedLimit = input.limits
+        .filter((limit) => (limit.freshness === "current" &&
+        limit.usedPercent >= 100 &&
+        Date.parse(limit.resetsAt) > generatedAtMs))
+        .sort((left, right) => Date.parse(left.resetsAt) - Date.parse(right.resetsAt))[0];
     const urgentLimit = input.limits
-        .filter((limit) => limit.projectedToExhaustBeforeReset)
+        .filter((limit) => (limit.freshness === "current" &&
+        limit.projectedToExhaustBeforeReset &&
+        limit.projectedExhaustionAt !== null &&
+        Date.parse(limit.projectedExhaustionAt) > Date.parse(input.generatedAt)))
         .sort((left, right) => left.remainingPercent - right.remainingPercent)[0];
     const projectSuffix = project ? ` · ${project}` : "";
     let intent;
@@ -458,68 +626,81 @@ function buildPrimaryAction(input) {
     let detail;
     let instruction;
     let confidence = input.sessionHealth.confidence;
-    switch (input.sessionHealth.recommendation) {
-        case "start_fresh":
-            intent = "start_fresh";
-            label = `Start fresh${projectSuffix}`;
-            detail = focus
-                ? `Carry “${focus}” into a clean session`
-                : "Carry only the concrete state you still need";
-            instruction = "Start a clean session and continue the observed focus after verifying the current repository state.";
-            break;
-        case "review_hooks":
-            intent = "review_context";
-            label = `Review context${projectSuffix}`;
-            detail = focus
-                ? `Protect “${focus}” from unnecessary hook context`
-                : "Inspect configured hooks before removing anything";
-            instruction = "Review installed hook sources that affect this work. Do not remove or edit configuration without explicit user approval.";
-            break;
-        case "trim_dead_context":
-            intent = "trim_context";
-            label = `Trim context${projectSuffix}`;
-            detail = focus
-                ? `Keep only context useful to “${focus}”`
-                : "Inspect unused loaded context before changing it";
-            instruction = "Identify loaded context that is unrelated to the observed focus. Recommend scoped changes, but do not remove anything without explicit user approval.";
-            break;
-        default:
-            if (urgentLimit) {
-                intent = "protect_runway";
-                label = `Checkpoint${projectSuffix}`;
-                detail = `${limitActionName(urgentLimit)} may exhaust before reset`;
-                instruction = "Create a concise checkpoint for the observed focus and prioritize the smallest verifiable next step before the reported plan window may be exhausted.";
-                confidence = "medium";
-            }
-            else if (focus &&
-                input.focus?.confidence !== "low" &&
-                input.currentSession?.status === "active") {
-                intent = "continue_focus";
-                label = `Continue${projectSuffix}`;
-                detail = focus;
-                instruction = "Continue the observed focus with the smallest verifiable next step.";
-                confidence = input.focus?.confidence ?? input.sessionHealth.confidence;
-            }
-            else if (focus && input.focus?.confidence !== "low") {
-                intent = "resume_focus";
-                label = `Resume${projectSuffix}`;
-                detail = focus;
-                instruction = "Resume the observed focus after checking what changed since the last local activity.";
-                confidence = input.focus?.confidence ?? input.sessionHealth.confidence;
-            }
-            else {
-                intent = "inspect_current_work";
-                label = `Inspect current work${projectSuffix}`;
-                detail = "Verify the active task before making changes";
-                instruction = "Inspect the current repository and ask for the intended task if it cannot be established from local evidence.";
-                confidence = "low";
-            }
+    if (exhaustedLimit) {
+        intent = "protect_runway";
+        label = `Checkpoint${projectSuffix}`;
+        detail = `${limitActionName(exhaustedLimit)} is exhausted until reset`;
+        instruction = "Create a concise checkpoint for the observed focus and wait for the provider-reported reset before resuming work that requires this plan window.";
+        confidence = "high";
+    }
+    else {
+        switch (input.sessionHealth.recommendation) {
+            case "start_fresh":
+                intent = "start_fresh";
+                label = `Start fresh${projectSuffix}`;
+                detail = focus
+                    ? `Carry “${focus}” into a clean session`
+                    : "Carry only the concrete state you still need";
+                instruction = "Start a clean session and continue the observed focus after verifying the current repository state.";
+                break;
+            case "review_hooks":
+                intent = "review_context";
+                label = `Review context${projectSuffix}`;
+                detail = focus
+                    ? `Protect “${focus}” from unnecessary hook context`
+                    : "Inspect configured hooks before removing anything";
+                instruction = "Review installed hook sources that affect this work. Do not remove or edit configuration without explicit user approval.";
+                break;
+            case "trim_dead_context":
+                intent = "trim_context";
+                label = `Trim context${projectSuffix}`;
+                detail = focus
+                    ? `Keep only context useful to “${focus}”`
+                    : "Inspect unused loaded context before changing it";
+                instruction = "Identify loaded context that is unrelated to the observed focus. Recommend scoped changes, but do not remove anything without explicit user approval.";
+                break;
+            default:
+                if (urgentLimit) {
+                    intent = "protect_runway";
+                    label = `Checkpoint${projectSuffix}`;
+                    detail = `${limitActionName(urgentLimit)} may exhaust before reset`;
+                    instruction = "Create a concise checkpoint for the observed focus and prioritize the smallest verifiable next step before the reported plan window may be exhausted.";
+                    confidence = "medium";
+                }
+                else if (focus &&
+                    input.focus?.confidence !== "low" &&
+                    input.currentSession?.status === "active") {
+                    intent = "continue_focus";
+                    label = `Continue${projectSuffix}`;
+                    detail = focus;
+                    instruction = "Continue the observed focus with the smallest verifiable next step.";
+                    confidence = input.focus?.confidence ?? input.sessionHealth.confidence;
+                }
+                else if (focus && input.focus?.confidence !== "low") {
+                    intent = "resume_focus";
+                    label = `Resume${projectSuffix}`;
+                    detail = focus;
+                    instruction = "Resume the observed focus after checking what changed since the last local activity.";
+                    confidence = input.focus?.confidence ?? input.sessionHealth.confidence;
+                }
+                else {
+                    intent = "inspect_current_work";
+                    label = `Inspect current work${projectSuffix}`;
+                    detail = "Verify the active task before making changes";
+                    instruction = "Inspect the current repository and ask for the intended task if it cannot be established from local evidence.";
+                    confidence = "low";
+                }
+        }
     }
-    const runway = urgentLimit
-        ? `${limitActionName(urgentLimit)}: ${roundPercent(urgentLimit.remainingPercent)}% remaining; locally projected exhaustion=${urgentLimit.projectedExhaustionAt ?? "unavailable"}; provider-reported reset=${urgentLimit.resetsAt}.`
-        : input.limits.length > 0
-            ? "No transcript-reported plan window is currently projected to exhaust before reset."
-            : "Not available; no plan window was reported in the local transcript.";
+    const runway = exhaustedLimit
+        ? `${limitActionName(exhaustedLimit)}: exhausted (0% remaining); provider-reported reset=${exhaustedLimit.resetsAt}; observed=${exhaustedLimit.observedAt}.`
+        : urgentLimit
+            ? `${limitActionName(urgentLimit)}: ${roundPercent(urgentLimit.remainingPercent)}% remaining; locally projected exhaustion=${urgentLimit.projectedExhaustionAt ?? "unavailable"}; provider-reported reset=${urgentLimit.resetsAt}.`
+            : input.limits.some((limit) => limit.freshness === "current")
+                ? "No transcript-reported plan window is currently projected to exhaust before reset."
+                : input.limits.some((limit) => limit.freshness === "stale")
+                    ? "Stale; the last transcript-reported plan window is too old to use as current runway. Refresh the agent limit before acting."
+                    : "Not available; no plan window was reported in the local transcript.";
     const reportedTotalEvidence = input.currentSession?.reportedTotalTokens === undefined
         ? ""
         : `; provider-reported total tokens=${input.currentSession.reportedTotalTokens.toLocaleString("en-US")}; input/output breakdown unavailable`;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./analyze.js";
+export * from "./actionPlanner.js";
+export * from "./actionVerification.js";
 export * from "./agentInventory.js";
 export * from "./agentEconomicsReceipt.js";
 export * from "./activitySnapshot.js";
@@ -12,16 +14,23 @@ export * from "./discovery.js";
 export * from "./glance.js";
 export * from "./toolInvocations.js";
 export * from "./insights.js";
-export { aggregateCalls, dedupeCumulativeSessionCalls, latestObservedWorkingDirectory, loadLocalAgentFinancialUsage, loadLocalAgentUsage, parseClaudeCodeTranscript, parseCodexRollout, sanitizeLocalActivityText } from "./localAgentLogs.js";
-export type { LocalAgentActivity, LocalAgentCall, LocalAgentFinancialLogOptions, LocalAgentLogDiagnostic, LocalAgentLogDiagnosticCode, LocalAgentLogOptions, LocalAgentLogResult, LocalAgentRateLimitSnapshot, LocalAgentRateLimitWindow, LocalAgentSourceScan, LocalAgentTurnUsage } from "./localAgentLogs.js";
+export { aggregateCalls, codexHeaderProbesPerScan, dedupeCumulativeSessionCalls, defaultStreamedBytesPerRun, hasCompleteQualitativeCoverage, hasExactSelectedQualitativeEvidence, latestObservedWorkingDirectory, loadLocalAgentActionEvidence, loadLocalAgentFinancialUsage, loadLocalAgentUsage, localAgentQualitativeParserVersion, parseClaudeCodeTranscript, parseCodexRollout, SAFE_QUALITATIVE_SCAN_POLICY, sanitizeLocalActivityText } from "./localAgentLogs.js";
+export type { LocalAgentActivity, LocalAgentCall, LocalAgentCompletionEvidence, LocalAgentFinancialLogOptions, LocalAgentOwnershipIndexAdapter, LocalAgentOwnershipRecord, LocalAgentQualitativeIndexAdapter, LocalAgentQualitativeIndexKey, LocalAgentQualitativeIndexValue, LocalAgentQualitativeScanPolicy, LocalAgentStreamCheckpointAdapter, LocalAgentStreamCheckpointRecord, LocalAgentLogDiagnostic, LocalAgentLogDiagnosticCode, LocalAgentLogOptions, LocalAgentLogResult, LocalAgentRateLimitSnapshot, LocalAgentRateLimitWindow, LocalAgentSourceScan, LocalAgentTokenComponentEvidence, LocalAgentTurnUsage } from "./localAgentLogs.js";
 export * from "./localAgentFormats/registry.js";
 export type * from "./localAgentFormats/types.js";
 export * from "./modelPricing.js";
 export * from "./planDetection.js";
 export * from "./planMath.js";
+export * from "./projectEconomics.js";
+export * from "./resultCard.js";
+export * from "./projectEconomicsBuilder.js";
+export * from "./qualitativeIndexCache.js";
+export * from "./projectIndexStore.js";
+export * from "./runtimeCommands.js";
 export * from "./sampleData.js";
 export * from "./scanGuard.js";
 export * from "./schema.js";
+export * from "./sessionVitals.js";
 export * from "./sourceRegistry.js";
 export * from "./sourceStatus.js";
 export * from "./stateTrust.js";

package/dist/index.js

@@ -1,4 +1,6 @@
 export * from "./analyze.js";
+export * from "./actionPlanner.js";
+export * from "./actionVerification.js";
 export * from "./agentInventory.js";
 export * from "./agentEconomicsReceipt.js";
 export * from "./activitySnapshot.js";
@@ -12,14 +14,21 @@ export * from "./discovery.js";
 export * from "./glance.js";
 export * from "./toolInvocations.js";
 export * from "./insights.js";
-export { aggregateCalls, dedupeCumulativeSessionCalls, latestObservedWorkingDirectory, loadLocalAgentFinancialUsage, loadLocalAgentUsage, parseClaudeCodeTranscript, parseCodexRollout, sanitizeLocalActivityText } from "./localAgentLogs.js";
+export { aggregateCalls, codexHeaderProbesPerScan, dedupeCumulativeSessionCalls, defaultStreamedBytesPerRun, hasCompleteQualitativeCoverage, hasExactSelectedQualitativeEvidence, latestObservedWorkingDirectory, loadLocalAgentActionEvidence, loadLocalAgentFinancialUsage, loadLocalAgentUsage, localAgentQualitativeParserVersion, parseClaudeCodeTranscript, parseCodexRollout, SAFE_QUALITATIVE_SCAN_POLICY, sanitizeLocalActivityText } from "./localAgentLogs.js";
 export * from "./localAgentFormats/registry.js";
 export * from "./modelPricing.js";
 export * from "./planDetection.js";
 export * from "./planMath.js";
+export * from "./projectEconomics.js";
+export * from "./resultCard.js";
+export * from "./projectEconomicsBuilder.js";
+export * from "./qualitativeIndexCache.js";
+export * from "./projectIndexStore.js";
+export * from "./runtimeCommands.js";
 export * from "./sampleData.js";
 export * from "./scanGuard.js";
 export * from "./schema.js";
+export * from "./sessionVitals.js";
 export * from "./sourceRegistry.js";
 export * from "./sourceStatus.js";
 export * from "./stateTrust.js";

package/dist/insights.js

@@ -178,6 +178,8 @@ function combinedConfidence(confidences) {
     return confidences.reduce((lowest, current) => confidenceRank[current] > confidenceRank[lowest] ? current : lowest);
 }
 function formatUsd(value) {
+    if (value > 0 && value < 0.01)
+        return "<$0.01";
     return `$${value.toFixed(2)}`;
 }
 function formatMultiplier(value) {
@@ -201,6 +203,6 @@ function stableSuffix(value) {
     return (hash >>> 0).toString(36);
 }
 function roundMoney(value) {
-    return Math.round(value * 100) / 100;
+    return Math.round(value * 10_000) / 10_000;
 }
 //# sourceMappingURL=insights.js.map

package/dist/localAgentFormats/gemini.js

@@ -176,8 +176,8 @@ function processMessage(message, state) {
         state.diagnostics.add("missing_timestamp");
         return;
     }
-    if (state.sinceMs !== undefined && Date.parse(timestamp) < state.sinceMs)
-        return;
+    // Window-blind on purpose (financial cache correctness): the loader's
+    // final timestamp filter performs all narrowing.
     const parsedTokens = parseTokens(message.tokens);
     const metadata = mergeMetadata(state.metadata, message);
     const attribution = explicitAttribution(message, metadata) ??

package/dist/localAgentFormats/registry.js

@@ -46,6 +46,7 @@ const descriptors = [
             fieldsRead: [
                 "timestamp, model, and token-usage components",
                 "session and working-directory metadata for local deduplication and attribution",
+                "explicit system/turn_duration work-unit completion markers and transcript version strings when present",
                 "human-prompt and tool metadata for privacy-reduced local activity summaries"
             ],
             verified: [
@@ -65,7 +66,8 @@ const descriptors = [
             ],
             limitations: [
                 "Malformed lines are skipped and reported.",
-                "Incomplete token shapes remain unpriced with missing financial evidence instead of becoming $0."
+                "Incomplete token shapes remain unpriced with missing financial evidence instead of becoming $0.",
+                "A system/turn_duration marker proves only that the latest observed turn completed; it does not prove permanent transcript closure, and missing or inconsistent completion evidence stays ineligible for automatic before/after cohorts."
             ]
         },
         fixtures: ["claude-code-v1"]
@@ -115,6 +117,7 @@ const descriptors = [
             ],
             fieldsRead: [
                 "session metadata, timestamps, model, and cumulative/last-turn token usage",
+                "explicit event_msg/task_complete work-unit completion markers and session_meta cli_version strings when present",
                 "transcript-reported rate-limit windows when present",
                 "tool-call metadata for local attribution and optional privacy-safe invocation counts"
             ],
@@ -135,7 +138,8 @@ const descriptors = [
             ],
             limitations: [
                 "Only rollout-*.jsonl files are parsed as Codex sessions.",
-                "Incomplete, regressing, or total-only token shapes remain unpriced with missing financial evidence."
+                "Incomplete, regressing, or total-only token shapes remain unpriced with missing financial evidence.",
+                "An event_msg/task_complete marker proves only that the latest observed task completed; it does not prove permanent transcript closure, and missing or inconsistent completion evidence stays ineligible for automatic before/after cohorts."
             ]
         },
         fixtures: ["codex-v1"]

package/dist/localAgentFormats/runtimeRegistry.js

@@ -24,9 +24,12 @@ const runtimes = [
             const collector = collectInvocationEvidence
                 ? createCodexInvocationCollector(sinceMs)
                 : undefined;
+            const calls = parseCodexRollout(content, collector?.consume, onDiagnostic);
+            const invocationFile = collector?.finish();
             return {
-                calls: parseCodexRollout(content, collector?.consume, onDiagnostic),
-                ...(collector ? { invocationFile: collector.finish() } : {})
+                calls,
+                ...(invocationFile ? { invocationFile } : {}),
+                ...(collector ? { invocationWindowProof: collector.windowProof() } : {})
             };
         },
         parseFinancialFile: readCodexFinancialFileForRegistry

package/dist/localAgentFormats/types.d.ts

@@ -1,5 +1,5 @@
 import type { LocalAgentCall, LocalAgentLogDiagnostic, LocalAgentSourceScan } from "../localAgentLogs.js";
-import type { ParsedInvocationFile } from "../toolInvocations.js";
+import type { ParsedInvocationFile, ParsedInvocationWindowProof } from "../toolInvocations.js";
 /**
  * Public format identity contract. Add future parser IDs here as part of the
  * registry-owned change so existing exhaustive consumers do not see an
@@ -78,6 +78,7 @@ export type LocalAgentFormatParseContext = {
 export type LocalAgentFormatParseResult = {
     calls: LocalAgentCall[];
     invocationFile?: ParsedInvocationFile;
+    invocationWindowProof?: ParsedInvocationWindowProof;
 };
 export type LocalAgentFormatFinancialFileContext = {
     filePath: string;