agentera 3.0.0-dev.6 → 3.0.0-dev.69

package/dist/state/startupAnalysis/metrics.js

@@ -13,10 +13,11 @@ function mergeTokenEstimates(counter, value) {
 }
 function sequenceCount(sequence, eventClass) {
     const counts = sequence.counts;
-    if (counts && typeof counts === "object" && typeof counts[eventClass] === "number") {
+    if (counts && typeof counts === "object" && !Array.isArray(counts) && typeof counts[eventClass] === "number") {
         return counts[eventClass];
     }
-    return (sequence.events ?? []).filter((event) => event && typeof event === "object" && event.event_class === eventClass).length;
+    const events = Array.isArray(sequence.events) ? sequence.events : [];
+    return events.filter((event) => Boolean(event && typeof event === "object" && !Array.isArray(event) && event.event_class === eventClass)).length;
 }
 function distribution(values) {
     if (values.length === 0) {
@@ -84,7 +85,7 @@ function deriveStateThresholds(args) {
     let broadTrigger = null;
     if (credibleDistribution) {
         for (const [label, item] of Object.entries(redundantArtifacts)) {
-            if (item.count >= redundantSequenceThreshold && item.capability_count >= 2) {
+            if (safeInt(item.count) >= redundantSequenceThreshold && safeInt(item.capability_count) >= 2) {
                 broadTrigger = {
                     event_class: "raw_artifact_access",
                     artifact_label: label,
@@ -178,8 +179,10 @@ export function aggregateStartupMetrics(intermediateInput) {
     const rawAfterCliPerSequence = [];
     const redundantRawPerSequence = [];
     for (const item of degradations) {
-        if (item && typeof item === "object" && typeof item.reason === "string") {
-            inc(degradationCounts, item.reason);
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+            const reason = item.reason;
+            if (typeof reason === "string")
+                inc(degradationCounts, reason);
         }
     }
     for (const sequence of sequences) {
@@ -201,8 +204,10 @@ export function aggregateStartupMetrics(intermediateInput) {
         const cc = perCapability[capability];
         cc.state_sequences += 1;
         const cliCount = sequenceCount(sequence, "cli_state_call");
-        const rawCount = (sequence.raw_artifact_labels_after_cli ?? []).length;
-        const redundantCount = (sequence.redundant_raw_artifact_labels ?? []).length;
+        const rawList = Array.isArray(sequence.raw_artifact_labels_after_cli) ? sequence.raw_artifact_labels_after_cli : [];
+        const redundantList = Array.isArray(sequence.redundant_raw_artifact_labels) ? sequence.redundant_raw_artifact_labels : [];
+        const rawCount = rawList.length;
+        const redundantCount = redundantList.length;
         const proseCount = sequenceCount(sequence, "capability_prose_read");
         const implCount = sequenceCount(sequence, "implementation_boundary");
         cc.cli_state_call += cliCount;
@@ -216,8 +221,8 @@ export function aggregateStartupMetrics(intermediateInput) {
         redundantRawPerSequence.push(redundantCount);
         mergeTokenEstimates(rawAfterCliTokenEstimates, sequence.estimated_raw_after_cli_tokens_by_artifact);
         mergeTokenEstimates(redundantRawTokenEstimates, sequence.estimated_redundant_raw_tokens_by_artifact);
-        for (const event of sequence.events ?? []) {
-            if (!event || typeof event !== "object")
+        for (const event of Array.isArray(sequence.events) ? sequence.events : []) {
+            if (!event || typeof event !== "object" || Array.isArray(event))
                 continue;
             const stateCommand = event.state_command;
             if (event.event_class === "cli_state_call" && typeof stateCommand === "string") {
@@ -234,25 +239,25 @@ export function aggregateStartupMetrics(intermediateInput) {
                 }
             }
         }
-        for (const reason of sequence.degradation_reasons ?? []) {
+        for (const reason of Array.isArray(sequence.degradation_reasons) ? sequence.degradation_reasons : []) {
             if (typeof reason === "string")
                 inc(degradationCounts, reason);
         }
     }
-    const totalSequences = sequences.filter((s) => s && typeof s === "object" && !Array.isArray(s)).length;
-    let runtimeCoverage = Array.isArray(intermediate.runtime_coverage) ? intermediate.runtime_coverage : [];
-    runtimeCoverage = runtimeCoverage
-        .filter((s) => s && typeof s === "object" && !Array.isArray(s))
+    const totalSequences = sequences.filter((s) => Boolean(s && typeof s === "object" && !Array.isArray(s))).length;
+    const runtimeCoverage = (Array.isArray(intermediate.runtime_coverage) ? intermediate.runtime_coverage : [])
+        .filter((s) => Boolean(s && typeof s === "object" && !Array.isArray(s)))
         .map((s) => boundedRuntimeStatus(s));
     const runtimeStatusCounts = {};
     for (const status of runtimeCoverage) {
-        if (status && typeof status === "object" && typeof status.status === "string")
-            inc(runtimeStatusCounts, status.status);
+        const st = status.status;
+        if (typeof st === "string")
+            inc(runtimeStatusCounts, st);
     }
     const confidenceCaveats = [];
     if (totalSequences === 0)
         confidenceCaveats.push("insufficient_post_2_3_state_sequences");
-    if (runtimeCoverage.some((s) => s && typeof s === "object" && ["missing", "sparse", "degraded", "skipped"].includes(s.status))) {
+    if (runtimeCoverage.some((s) => typeof s.status === "string" && ["missing", "sparse", "degraded", "skipped"].includes(s.status))) {
         confidenceCaveats.push("runtime_coverage_incomplete_or_degraded");
     }
     if (Object.keys(degradationCounts).length > 0)
@@ -268,7 +273,9 @@ export function aggregateStartupMetrics(intermediateInput) {
     });
     const sequencesWithRaw = rawAfterCliPerSequence.filter((v) => v > 0).length;
     const sequencesWithRedundant = redundantRawPerSequence.filter((v) => v > 0).length;
-    const recommendation = thresholdDerivation.recommendation;
+    const recommendation = thresholdDerivation.recommendation && typeof thresholdDerivation.recommendation === "object" && !Array.isArray(thresholdDerivation.recommendation)
+        ? thresholdDerivation.recommendation
+        : {};
     const sortedPerCapability = {};
     for (const key of Object.keys(perCapability).sort())
         sortedPerCapability[key] = perCapability[key];
@@ -331,4 +338,3 @@ export function aggregateStartupMetrics(intermediateInput) {
     }
     return result;
 }
-//# sourceMappingURL=metrics.js.map

package/dist/state/startupAnalysis/records.js

@@ -8,7 +8,8 @@ function hasTranscriptBearingField(record) {
     return Boolean(data && typeof data === "object" && !Array.isArray(data) && "transcript" in data);
 }
 function boundedReason(reason, contract) {
-    const allowed = new Set([...(contract.degradation_reasons ?? []), ...BOUNDARY_DEGRADATION_REASONS]);
+    const reasons = Array.isArray(contract.degradation_reasons) ? contract.degradation_reasons : [];
+    const allowed = new Set([...reasons, ...BOUNDARY_DEGRADATION_REASONS]);
     return allowed.has(reason) ? reason : "malformed_record";
 }
 function estimatedToolArgumentTokens(record) {
@@ -53,7 +54,8 @@ function eventOutput(record, opts) {
 export function classifyStartupRecords(corpus, opts) {
     const salt = opts.salt;
     const loaded = opts.contract ?? loadContract();
-    const boundary = timestampUtc((loaded.boundary ?? {}).committed_at);
+    const boundaryInfo = loaded.boundary && typeof loaded.boundary === "object" && !Array.isArray(loaded.boundary) ? loaded.boundary : {};
+    const boundary = timestampUtc(boundaryInfo.committed_at);
     const records = corpus && typeof corpus === "object" && !Array.isArray(corpus) ? (corpus.records ?? []) : [];
     const degradations = [];
     const groups = new Map();
@@ -142,6 +144,8 @@ export function classifyStartupRecords(corpus, opts) {
             }
             if (state.active === null)
                 continue;
+            // cast: state.active is built by newSequence with typed array/counter/estimate fields
+            const active = state.active;
             if (eventClass === "cli_state_call") {
                 for (const label of cliArtifactLabels)
                     state.cliArtifactsSeen.add(label);
@@ -150,8 +154,8 @@ export function classifyStartupRecords(corpus, opts) {
                 ? state.cliArtifactsSeen.has(artifactLabel)
                 : null;
             const phase = eventClass === "implementation_boundary" ? "implementation_boundary" : "state_gathering";
-            state.active.counts[eventClass] += 1;
-            state.active.events.push(eventOutput(record, {
+            active.counts[eventClass] += 1;
+            active.events.push(eventOutput(record, {
                 eventClass,
                 phase,
                 salt,
@@ -160,13 +164,13 @@ export function classifyStartupRecords(corpus, opts) {
                 redundantWithCli: redundant,
             }));
             if (eventClass === "raw_artifact_access" && artifactLabel) {
-                state.active.raw_artifact_labels_after_cli.push(artifactLabel);
+                active.raw_artifact_labels_after_cli.push(artifactLabel);
                 const estimatedTokens = estimatedToolArgumentTokens(record);
-                const rawEstimates = state.active.estimated_raw_after_cli_tokens_by_artifact;
+                const rawEstimates = active.estimated_raw_after_cli_tokens_by_artifact;
                 rawEstimates[artifactLabel] = (rawEstimates[artifactLabel] ?? 0) + estimatedTokens;
                 if (redundant) {
-                    state.active.redundant_raw_artifact_labels.push(artifactLabel);
-                    const redundantEstimates = state.active.estimated_redundant_raw_tokens_by_artifact;
+                    active.redundant_raw_artifact_labels.push(artifactLabel);
+                    const redundantEstimates = active.estimated_redundant_raw_tokens_by_artifact;
                     redundantEstimates[artifactLabel] = (redundantEstimates[artifactLabel] ?? 0) + estimatedTokens;
                 }
             }
@@ -187,9 +191,8 @@ export function classifyStartupRecords(corpus, opts) {
     }
     return {
         contract_version: loaded.version,
-        boundary_source: (loaded.boundary ?? {}).source,
+        boundary_source: boundaryInfo.source,
         state_gathering_sequences: sequences,
         degradations,
     };
 }
-//# sourceMappingURL=records.js.map

package/dist/state/startupAnalysis/report.js

@@ -1,38 +1,16 @@
 import fs from "node:fs";
 import path from "node:path";
-import { Flt, formatFloat, pyFmt, pyJsonDumps, pyJsonString } from "./helpers.js";
+import { pyJsonIndentSorted } from "../../core/pyjson.js";
+import { Flt, formatFloat, pyFmt, pyJsonDumps } from "./helpers.js";
 export const STARTUP_REPORT_MARKDOWN = "startup-overhead-report.md";
 export const STARTUP_REPORT_JSON = "startup-overhead-report.json";
-/** Python json.dumps(value, indent=2, sort_keys=True) — multiline, ensure_ascii, Flt-aware. */
-function pyJsonIndent(value, level = 0, indent = "  ") {
-    const pad = indent.repeat(level);
-    const childPad = indent.repeat(level + 1);
-    if (value === null || value === undefined)
-        return "null";
-    if (value === true)
-        return "true";
-    if (value === false)
-        return "false";
+function startupJsonScalar(value) {
     if (value instanceof Flt)
         return formatFloat(value.v);
-    if (typeof value === "number")
-        return String(value);
-    if (typeof value === "string")
-        return pyJsonString(value);
-    if (Array.isArray(value)) {
-        if (value.length === 0)
-            return "[]";
-        const items = value.map((v) => childPad + pyJsonIndent(v, level + 1, indent));
-        return "[\n" + items.join(",\n") + "\n" + pad + "]";
-    }
-    if (typeof value === "object") {
-        const keys = Object.keys(value).sort();
-        if (keys.length === 0)
-            return "{}";
-        const items = keys.map((k) => childPad + pyJsonString(k) + ": " + pyJsonIndent(value[k], level + 1, indent));
-        return "{\n" + items.join(",\n") + "\n" + pad + "}";
-    }
-    return "null";
+    return undefined;
+}
+function pyJsonIndent(value, level = 0, indent = "  ") {
+    return pyJsonIndentSorted(value, indent.length || 2, level, startupJsonScalar);
 }
 function markdownTable(headers, rows) {
     const lines = [
@@ -45,13 +23,24 @@ function markdownTable(headers, rows) {
     return [...lines, ...rows.map((row) => "| " + row.map((v) => pyFmt(v)).join(" | ") + " |")];
 }
 export function renderStartupReport(metrics) {
-    const threshold = (metrics.threshold_derivation ?? {}).action_thresholds ?? {};
-    const envelopeThreshold = threshold.startup_envelope ?? {};
-    const guidanceThreshold = threshold.targeted_guidance ?? {};
-    const recommendation = metrics.startup_recommendation ?? {};
-    const measuredDistribution = (metrics.threshold_derivation ?? {}).measured_distribution ?? {};
+    const thresholdDerivation = metrics.threshold_derivation && typeof metrics.threshold_derivation === "object" && !Array.isArray(metrics.threshold_derivation)
+        ? metrics.threshold_derivation
+        : {};
+    const threshold = thresholdDerivation.action_thresholds && typeof thresholdDerivation.action_thresholds === "object" && !Array.isArray(thresholdDerivation.action_thresholds)
+        ? thresholdDerivation.action_thresholds
+        : {};
+    const envelopeThreshold = threshold.startup_envelope && typeof threshold.startup_envelope === "object" && !Array.isArray(threshold.startup_envelope) ? threshold.startup_envelope : {};
+    const guidanceThreshold = threshold.targeted_guidance && typeof threshold.targeted_guidance === "object" && !Array.isArray(threshold.targeted_guidance) ? threshold.targeted_guidance : {};
+    const recommendation = metrics.startup_recommendation && typeof metrics.startup_recommendation === "object" && !Array.isArray(metrics.startup_recommendation)
+        ? metrics.startup_recommendation
+        : {};
+    const measuredDistribution = thresholdDerivation.measured_distribution && typeof thresholdDerivation.measured_distribution === "object" && !Array.isArray(thresholdDerivation.measured_distribution)
+        ? thresholdDerivation.measured_distribution
+        : {};
     const runtimeCoverage = Array.isArray(metrics.runtime_coverage) ? metrics.runtime_coverage : [];
-    const capabilityCounts = metrics.per_capability_state_counts ?? {};
+    const capabilityCounts = metrics.per_capability_state_counts && typeof metrics.per_capability_state_counts === "object" && !Array.isArray(metrics.per_capability_state_counts)
+        ? metrics.per_capability_state_counts
+        : {};
     const lines = [
         "# Agentera Startup State-Access Analysis",
         "",
@@ -83,12 +72,12 @@ export function renderStartupReport(metrics) {
                 status.status ?? "unknown",
                 status.reason ?? "unknown",
                 status.record_count ?? 0,
-                status.candidate_count ?? 0,
+                status.file_count ?? 0,
                 status.error_count ?? 0,
             ]);
         }
     }
-    lines.push(...markdownTable(["Runtime", "Status", "Reason", "Records", "Candidates", "Errors"], runtimeRows));
+    lines.push(...markdownTable(["Runtime", "Status", "Reason", "Records", "Files", "Errors"], runtimeRows));
     lines.push("", "## Metrics", "", `- Total state-gathering sequences: \`${pyFmt(metrics.total_state_sequences)}\``, `- Sequences with raw artifact access after CLI: \`${pyFmt(metrics.state_sequences_with_raw_after_cli)}\``, `- Sequences with redundant raw artifact access: \`${pyFmt(metrics.state_sequences_with_redundant_raw_access)}\``, `- Raw-after-CLI sequence rate: \`${pyFmt(metrics.raw_after_cli_sequence_rate)}\``, `- Redundant raw sequence rate: \`${pyFmt(metrics.redundant_raw_sequence_rate)}\``, `- CLI state command counts: \`${pyJsonDumps(metrics.cli_state_command_counts ?? {})}\``, `- Raw artifact access after CLI counts: \`${pyJsonDumps(metrics.raw_artifact_access_after_cli_counts ?? {})}\``, `- Redundant raw artifact access counts: \`${pyJsonDumps(metrics.redundant_raw_artifact_access_counts ?? {})}\``, "", "## Estimated Token Impact", "", `- Token estimator version: \`${pyFmt(metrics.token_estimator_version)}\``, `- Estimated raw-after-CLI tokens: \`${pyFmt(metrics.estimated_raw_after_cli_tokens)}\``, `- Estimated redundant raw tokens: \`${pyFmt(metrics.estimated_redundant_raw_tokens)}\``, `- Estimated raw-after-CLI tokens by artifact: \`${pyJsonDumps(metrics.estimated_raw_after_cli_tokens_by_artifact ?? {})}\``, `- Estimated redundant raw tokens by artifact: \`${pyJsonDumps(metrics.estimated_redundant_raw_tokens_by_artifact ?? {})}\``, `- Estimated tokens saved vs previous: \`${pyFmt(metrics.estimated_tokens_saved_vs_previous)}\``, `- Estimated tokens saved null reason: \`${pyFmt(metrics.estimated_tokens_saved_vs_previous_null_reason)}\``, "");
     const capabilityRows = [];
     for (const capability of Object.keys(capabilityCounts).sort()) {
@@ -120,4 +109,3 @@ export function writeStartupReports(metrics, outputDir) {
 // Slice 6: benchmark persistence + intermediate building + corpus-file extraction
 // (extract_*_from_runtime_stores depends on extract_corpus and lands in Phase 10)
 // ===========================================================================
-//# sourceMappingURL=report.js.map

package/dist/state/startupAnalysis/threshold.js

@@ -38,6 +38,14 @@ export const BOUNDED_RUNTIME_REASONS = new Set([
     "store_locked",
     "store_not_directory",
     "store_unreadable",
+    // Compatibility-state reasons projected from the evidence-tier authority
+    // contract. The local-corpus pseudo-runtime reports these when a tier
+    // compatibility state prevents analysis; they must survive normalization
+    // rather than collapsing to schema_divergent.
+    "no_evidence",
+    "legacy_monolithic_state",
+    "unreadable_or_schema_divergent",
+    "oversized",
 ]);
 export function boundedRuntimeStatus(status) {
     const runtime = String(status.runtime ?? "unknown");
@@ -48,7 +56,7 @@ export function boundedRuntimeStatus(status) {
         status: BOUNDED_RUNTIME_STATUSES.has(state) ? state : "degraded",
         reason: BOUNDED_RUNTIME_REASONS.has(reason) ? reason : "schema_divergent",
     };
-    for (const key of ["candidate_count", "record_count", "error_count"]) {
+    for (const key of ["file_count", "record_count", "error_count"]) {
         const value = status[key];
         if (typeof value === "number" && Number.isInteger(value))
             item[key] = value;
@@ -56,10 +64,15 @@ export function boundedRuntimeStatus(status) {
     if (Array.isArray(status.remediation_labels)) {
         item.remediation_labels = status.remediation_labels.map((l) => String(l));
     }
+    // Contract-projected recovery guidance for tier compatibility states. Passes
+    // through only when present; extraction-time runtime statuses omit it.
+    if (typeof status.recovery === "string" && status.recovery.length > 0) {
+        item.recovery = status.recovery;
+    }
     return item;
 }
 export const STATE_CLI_COMMANDS = new Set([
-    "hej",
+    "status",
     "prime",
     "plan",
     "progress",
@@ -147,8 +160,8 @@ export function classifyStartupEvent(record) {
 }
 function eventWarningKeys(event) {
     const keys = [];
-    for (const warning of event.warnings ?? []) {
-        if (!warning || typeof warning !== "object")
+    for (const warning of Array.isArray(event.warnings) ? event.warnings : []) {
+        if (!warning || typeof warning !== "object" || Array.isArray(warning))
             continue;
         const family = warning.family;
         const category = warning.category;
@@ -194,7 +207,7 @@ export function scanThresholdEvidence(corpus, opts) {
     if (!Array.isArray(runtimeStatuses))
         runtimeStatuses = [];
     const runtimeCoverage = runtimeStatuses
-        .filter((s) => s && typeof s === "object" && !Array.isArray(s))
+        .filter((s) => s !== null && typeof s === "object" && !Array.isArray(s))
         .map((s) => boundedRuntimeStatus(s));
     const coverageCaveats = [];
     if (runtimeCoverage.length === 0) {
@@ -484,7 +497,7 @@ export function classifyThresholdEvidence(scan) {
         counts: {
             by_classification: counterDict(classificationCounts),
             category_count: categories.length,
-            repeated_false_positive_categories: categories.filter((c) => c.classification === "likely_false_positive" && c.event_count >= 2).length,
+            repeated_false_positive_categories: categories.filter((c) => c.classification === "likely_false_positive" && Number(c.event_count) >= 2).length,
         },
         recommendation,
         coverage_caveats: coverageCaveats.map((c) => String(c)),
@@ -497,4 +510,3 @@ export function classifyThresholdEvidence(scan) {
 // ===========================================================================
 // Slice 3: startup record classification into state-gathering sequences
 // ===========================================================================
-//# sourceMappingURL=threshold.js.map

package/dist/state/startupAnalysis.js

@@ -1,3 +1,2 @@
 /** Barrel: stable import path for startup analysis (split across ./startupAnalysis/). */
 export * from "./startupAnalysis/index.js";
-//# sourceMappingURL=startupAnalysis.js.map