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

package/dist/state/safeProjectFile.js

@@ -0,0 +1,155 @@
+import fs from "node:fs";
+import path from "node:path";
+import { assertValidatedProjectRoot } from "./projectRoot.js";
+function projectPathType(stat) {
+    if (stat.isFile())
+        return "file";
+    if (stat.isDirectory())
+        return "directory";
+    if (stat.isSymbolicLink())
+        return "symlink";
+    return "other";
+}
+function samePathIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && projectPathType(left) === projectPathType(right);
+}
+function sameFileSnapshot(left, right) {
+    return left.isFile()
+        && right.isFile()
+        && samePathIdentity(left, right)
+        && left.size === right.size
+        && left.mtimeNs === right.mtimeNs
+        && left.ctimeNs === right.ctimeNs;
+}
+export function snapshotProjectPath(root, relativePath, leafType) {
+    const targets = [root];
+    let absolute = root;
+    for (const segment of relativePath.split("/").filter(Boolean)) {
+        absolute = path.join(absolute, segment);
+        targets.push(absolute);
+    }
+    const identities = [];
+    let leaf;
+    for (const [index, target] of targets.entries()) {
+        let stat;
+        try {
+            stat = fs.lstatSync(target, { bigint: true });
+        }
+        catch (error) {
+            return error.code === "ENOENT"
+                ? { kind: "missing", absolute: target, reason: "missing" }
+                : { kind: "unsafe", absolute: target, reason: "unreadable" };
+        }
+        const type = projectPathType(stat);
+        if (type === "symlink")
+            return { kind: "unsafe", absolute: target, reason: "symlink" };
+        const expected = index === targets.length - 1 ? leafType : "directory";
+        if (type !== expected)
+            return { kind: "unsafe", absolute: target, reason: "type" };
+        identities.push({ absolute: target, dev: stat.dev, ino: stat.ino, type });
+        leaf = stat;
+    }
+    return { kind: "stable", absolute, identities, leaf: leaf };
+}
+export function projectPathIsStable(snapshot) {
+    return snapshot.identities.every((identity) => {
+        try {
+            const current = fs.lstatSync(identity.absolute, { bigint: true });
+            return current.dev === identity.dev
+                && current.ino === identity.ino
+                && projectPathType(current) === identity.type;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function containedBy(root, candidate) {
+    const relativePath = path.relative(root, candidate);
+    return relativePath !== ""
+        && !relativePath.startsWith(`..${path.sep}`)
+        && relativePath !== ".."
+        && !path.isAbsolute(relativePath);
+}
+export function resolveProjectDescriptorPath(descriptor) {
+    try {
+        return fs.realpathSync(`/proc/self/fd/${descriptor}`);
+    }
+    catch {
+        return null;
+    }
+}
+function descriptorMatchesPath(root, absolute, descriptorPath) {
+    try {
+        return containedBy(root, descriptorPath) && fs.realpathSync(absolute) === descriptorPath;
+    }
+    catch {
+        return false;
+    }
+}
+/** Pin one project file to a verified descriptor and return only stable in-project bytes. */
+export function readProjectFileSnapshot(projectRoot, relativePath, descriptorPathResolver = resolveProjectDescriptorPath, maxBytes = null) {
+    const root = typeof projectRoot === "string" ? projectRoot : projectRoot.path;
+    const verifyRoot = () => {
+        if (typeof projectRoot !== "string")
+            assertValidatedProjectRoot(projectRoot);
+    };
+    verifyRoot();
+    const pathSnapshot = snapshotProjectPath(root, relativePath, "file");
+    if (pathSnapshot.kind === "missing") {
+        verifyRoot();
+        return { bytes: null, kind: "missing", reason: "missing", absolute: pathSnapshot.absolute };
+    }
+    if (pathSnapshot.kind === "unsafe") {
+        verifyRoot();
+        return { bytes: null, kind: "unsafe", reason: pathSnapshot.reason };
+    }
+    let descriptor;
+    try {
+        const noFollow = fs.constants.O_NOFOLLOW ?? 0;
+        descriptor = fs.openSync(pathSnapshot.absolute, fs.constants.O_RDONLY | noFollow);
+        const opened = fs.fstatSync(descriptor, { bigint: true });
+        if (!opened.isFile() || !samePathIdentity(pathSnapshot.leaf, opened) || !projectPathIsStable(pathSnapshot)) {
+            return { bytes: null, kind: "unsafe", reason: "changed" };
+        }
+        if (maxBytes !== null && opened.size > BigInt(maxBytes)) {
+            return { bytes: null, kind: "unsafe", reason: "over_limit" };
+        }
+        let descriptorRealPath = null;
+        try {
+            descriptorRealPath = descriptorPathResolver(descriptor);
+        }
+        catch { /* Descriptor paths are optional strengthening. */ }
+        if (descriptorRealPath !== null && !descriptorMatchesPath(root, pathSnapshot.absolute, descriptorRealPath)) {
+            return { bytes: null, kind: "unsafe", reason: "changed" };
+        }
+        const bytes = fs.readFileSync(descriptor);
+        const after = fs.fstatSync(descriptor, { bigint: true });
+        if (!sameFileSnapshot(opened, after)
+            || BigInt(bytes.byteLength) !== opened.size
+            || !projectPathIsStable(pathSnapshot)
+            || (descriptorRealPath !== null && !descriptorMatchesPath(root, pathSnapshot.absolute, descriptorRealPath))) {
+            return { bytes: null, kind: "unsafe", reason: "changed" };
+        }
+        verifyRoot();
+        return {
+            bytes,
+            kind: "file",
+            dev: after.dev,
+            ino: after.ino,
+            type: "file",
+            mode: Number(after.mode & 4095n),
+        };
+    }
+    catch {
+        return { bytes: null, kind: "unsafe", reason: "changed" };
+    }
+    finally {
+        if (descriptor !== undefined) {
+            try {
+                fs.closeSync(descriptor);
+            }
+            catch { /* Failed close cannot make unverified bytes safe. */ }
+        }
+    }
+}

package/dist/state/startupAnalysis/benchmark.js

@@ -9,6 +9,7 @@ import { inc, counterDict, safeInt, pyJsonDumps } from "./helpers.js";
 import { boundedRuntimeStatus } from "./threshold.js";
 import { classifyStartupRecords } from "./records.js";
 import { renderStartupReport } from "./report.js";
+import { tiersDirForCorpusPath, assessTiers, readBoundedMetadata, iterBoundedRecords, legacyCorpusReadable, recoveryForState, } from "../../analytics/extractCorpus/index.js";
 export const STARTUP_INTERMEDIATE_ENVELOPE = "startup_state_analysis_v1";
 export const BENCHMARK_HISTORY_JSONL = "runs.jsonl";
 export const BENCHMARK_LATEST_REPORT_JSON = "latest-report.json";
@@ -38,8 +39,8 @@ function maxRecordTimestamp(records, after = null) {
 function artifactLabelCounts(sequences) {
     const counts = {};
     for (const sequence of sequences) {
-        for (const event of sequence.events ?? []) {
-            if (event && typeof event === "object" && typeof event.artifact_label === "string") {
+        for (const event of Array.isArray(sequence.events) ? sequence.events : []) {
+            if (event && typeof event === "object" && !Array.isArray(event) && typeof event.artifact_label === "string") {
                 inc(counts, event.artifact_label);
             }
         }
@@ -49,15 +50,17 @@ function artifactLabelCounts(sequences) {
 function runtimeRecordCounts(records) {
     const counts = {};
     for (const record of records) {
-        if (record && typeof record === "object" && typeof record.runtime === "string") {
-            inc(counts, record.runtime);
+        if (record && typeof record === "object") {
+            const runtime = record.runtime;
+            if (typeof runtime === "string")
+                inc(counts, runtime);
         }
     }
     return counterDict(counts);
 }
 function agenteraVersion(root = resolveSourceRoot()) {
     try {
-        const data = loadTomlFile(path.join(root, "pyproject.toml"));
+        const data = loadTomlFile(path.join(root, "pyproject.toml")); // cast: IO boundary — TOML parse of pyproject.toml
         const project = data.project;
         if (project && typeof project === "object" && typeof project.version === "string") {
             return project.version;
@@ -84,8 +87,8 @@ function runtimeScope(metrics, approvedScope = null) {
         return [...new Set(approvedScope.filter((l) => l).map((l) => String(l)))].sort();
     }
     const labels = new Set();
-    for (const item of metrics.runtime_coverage ?? []) {
-        if (item && typeof item === "object" && typeof item.runtime === "string")
+    for (const item of Array.isArray(metrics.runtime_coverage) ? metrics.runtime_coverage : []) {
+        if (item && typeof item === "object" && !Array.isArray(item) && typeof item.runtime === "string")
             labels.add(item.runtime);
     }
     const runtimeCounts = metrics.runtime_record_counts;
@@ -195,7 +198,7 @@ function withEstimatedTokensSaved(metrics, benchmarkDir, scope) {
     return enriched;
 }
 export function buildBenchmarkHistoryRow(metrics, scope = null) {
-    const recommendation = metrics && typeof metrics === "object" && metrics.startup_recommendation && typeof metrics.startup_recommendation === "object"
+    const recommendation = metrics && typeof metrics === "object" && metrics.startup_recommendation && typeof metrics.startup_recommendation === "object" && !Array.isArray(metrics.startup_recommendation)
         ? metrics.startup_recommendation
         : {};
     return {
@@ -287,21 +290,22 @@ export function buildStartupIntermediate(corpus, opts) {
     let runtimeStatuses = metadata.runtime_statuses;
     if (!Array.isArray(runtimeStatuses))
         runtimeStatuses = [];
-    const boundary = parseTimestamp((loaded.boundary ?? {}).committed_at);
+    const boundaryInfo = loaded.boundary && typeof loaded.boundary === "object" && !Array.isArray(loaded.boundary) ? loaded.boundary : {};
+    const boundary = parseTimestamp(boundaryInfo.committed_at);
     const windowStartedAfter = opts.benchmarkWindowStartedAfter ?? boundary;
     const watermarkAt = opts.benchmarkWatermarkAt ?? maxRecordTimestamp(records, windowStartedAfter);
     const classified = classifyStartupRecords(corpus, { salt, contract: loaded });
-    const sequences = classified.state_gathering_sequences;
+    const sequences = (Array.isArray(classified.state_gathering_sequences) ? classified.state_gathering_sequences : []);
     const degradations = classified.degradations;
     const runtimeCoverage = runtimeStatuses
-        .filter((s) => s && typeof s === "object" && !Array.isArray(s))
+        .filter((s) => Boolean(s && typeof s === "object" && !Array.isArray(s)))
         .map((s) => boundedRuntimeStatus(s));
     return {
         output_envelope: STARTUP_INTERMEDIATE_ENVELOPE,
         contract_version: loaded.version ?? null,
-        boundary_source: (loaded.boundary ?? {}).source ?? null,
-        boundary_commit: (loaded.boundary ?? {}).commit ?? null,
-        boundary_committed_at: (loaded.boundary ?? {}).committed_at ?? null,
+        boundary_source: boundaryInfo.source ?? null,
+        boundary_commit: boundaryInfo.commit ?? null,
+        boundary_committed_at: boundaryInfo.committed_at ?? null,
         benchmark_mode: opts.benchmarkMode || "full_boundary_snapshot",
         benchmark_previous_watermark_at: formatTimestamp(opts.benchmarkPreviousWatermarkAt ?? null),
         benchmark_window_started_after: formatTimestamp(windowStartedAfter),
@@ -319,14 +323,15 @@ export function buildStartupIntermediate(corpus, opts) {
 }
 export function buildNoRuntimeStartupIntermediate(opts = {}) {
     const loaded = opts.contract ?? loadContract();
-    const boundary = parseTimestamp((loaded.boundary ?? {}).committed_at);
+    const boundaryInfo = loaded.boundary && typeof loaded.boundary === "object" && !Array.isArray(loaded.boundary) ? loaded.boundary : {};
+    const boundary = parseTimestamp(boundaryInfo.committed_at);
     const windowStartedAfter = opts.benchmarkPreviousWatermarkAt ?? boundary;
     return {
         output_envelope: STARTUP_INTERMEDIATE_ENVELOPE,
         contract_version: loaded.version ?? null,
-        boundary_source: (loaded.boundary ?? {}).source ?? null,
-        boundary_commit: (loaded.boundary ?? {}).commit ?? null,
-        boundary_committed_at: (loaded.boundary ?? {}).committed_at ?? null,
+        boundary_source: boundaryInfo.source ?? null,
+        boundary_commit: boundaryInfo.commit ?? null,
+        boundary_committed_at: boundaryInfo.committed_at ?? null,
         benchmark_mode: opts.benchmarkMode ?? "since_previous_benchmark",
         benchmark_previous_watermark_at: formatTimestamp(opts.benchmarkPreviousWatermarkAt ?? null),
         benchmark_window_started_after: formatTimestamp(windowStartedAfter),
@@ -342,21 +347,82 @@ export function buildNoRuntimeStartupIntermediate(opts = {}) {
         compatibility_note: "No runtime stores were approved, so no local runtime history was read.",
     };
 }
+/**
+ * Build a degraded corpus envelope for a tier-compatibility state. The
+ * local-corpus pseudo-runtime carries the contract-projected reason and
+ * recovery so a caller can self-service. `reason` must be a value from the
+ * evidence-tier authority's compatibility states (oversized,
+ * no_evidence, unreadable_or_schema_divergent, legacy_monolithic_state).
+ */
+function degradeEnvelope(reason, recovery) {
+    const status = {
+        runtime: "local-corpus",
+        status: "degraded",
+        reason,
+        error_count: 1,
+    };
+    if (recovery)
+        status.recovery = recovery;
+    return {
+        metadata: { runtime_statuses: [status] },
+        records: [],
+    };
+}
 export function extractStartupIntermediateFromCorpusFile(corpusPath, opts) {
+    const tiersDir = tiersDirForCorpusPath(corpusPath);
+    const assessment = assessTiers(tiersDir, corpusPath);
     let corpus;
-    try {
-        corpus = JSON.parse(fs.readFileSync(corpusPath, "utf8"));
-    }
-    catch {
+    if (assessment.analyzable) {
+        // Bounded tier read: assemble the corpus envelope from bounded evidence
+        // shards (read one at a time, each under the reader cap) plus the retained
+        // manifest metadata, then run the multi-pass startup classification. The
+        // monolithic corpus envelope is never read whole at real scale.
+        const meta = readBoundedMetadata(tiersDir);
+        const records = Array.from(iterBoundedRecords(tiersDir) ?? []);
         corpus = {
             metadata: {
-                runtime_statuses: [
-                    { runtime: "local-corpus", status: "degraded", reason: "schema_divergent", error_count: 1 },
-                ],
+                runtime_statuses: meta.corpusMetadata?.runtime_statuses ?? [],
+                adapter_version: meta.manifest?.adapter_version ?? null,
+                extracted_at: meta.corpusMetadata?.extracted_at ??
+                    meta.manifest?.published_at ??
+                    null,
             },
-            records: [],
+            records,
         };
     }
+    else if (assessment.state === "corrupt" || assessment.state === "oversized") {
+        // Tier-level failure: degrade truthfully with the contract-projected
+        // reason and recovery guidance. The boundedRuntimeStatus normalizer
+        // preserves compatibility-state reasons (no_evidence, oversized,
+        // unreadable_or_schema_divergent, legacy_monolithic_state) and passes
+        // through the recovery field for self-service correction.
+        corpus = degradeEnvelope(assessment.state === "corrupt"
+            ? "unreadable_or_schema_divergent"
+            : "oversized", assessment.recovery);
+    }
+    else if (assessment.state === "missing") {
+        // No evidence artifact or tier exists at the resolved path. Degrade with
+        // the contract's missing reason and recovery; never auto-build or scan.
+        corpus = degradeEnvelope("no_evidence", assessment.recovery);
+    }
+    else {
+        // Legacy monolithic corpus.json exists but no bounded tiers published.
+        // Size-check before reading — an oversized legacy corpus is never loaded
+        // whole, matching the contract's oversized compatibility state.
+        if (!legacyCorpusReadable(corpusPath)) {
+            corpus = degradeEnvelope("oversized", recoveryForState("oversized") ?? undefined);
+        }
+        else {
+            // Small legacy corpus: backward-compat bounded read.
+            try {
+                corpus = JSON.parse(fs.readFileSync(corpusPath, "utf8"));
+            }
+            catch {
+                // Corrupt legacy corpus: report the contract's corrupt reason.
+                corpus = degradeEnvelope("unreadable_or_schema_divergent", recoveryForState("corrupt") ?? undefined);
+            }
+        }
+    }
     const intermediate = buildStartupIntermediate(corpus, { salt: opts.salt, contract: opts.contract ?? null });
     if (opts.outputPath) {
         fs.mkdirSync(path.dirname(opts.outputPath), { recursive: true });
@@ -364,4 +430,3 @@ export function extractStartupIntermediateFromCorpusFile(corpusPath, opts) {
     }
     return intermediate;
 }
-//# sourceMappingURL=benchmark.js.map

package/dist/state/startupAnalysis/contract.js

@@ -1,8 +1,4 @@
 import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import { loadYamlMapping } from "../../core/yaml.js";
-import { resolveSourceRoot } from "../../core/sourceRoot.js";
 export const TRANSCRIPT_KEYS = new Set([
     "content",
     "text",
@@ -15,11 +11,51 @@ export const TRANSCRIPT_KEYS = new Set([
 ]);
 export const SESSION_KEYS = new Set(["session_id", "sessionID", "sessionId", "conversation_id"]);
 export const PATH_KEYS = new Set(["path", "project_path", "store_path", "file_path", "cwd", "report_path"]);
-export function contractPath(root = resolveSourceRoot()) {
-    return path.join(root, "references", "analysis", "startup-measurement-contract.yaml");
+const DEFAULT_CONTRACT = {
+    version: "startup-state-analysis-v1",
+    boundary: {
+        source: "git tag evidence",
+        commit: "b18e3dc7d768d4ad2726880916e7cfe6bd8617d3",
+        committed_at: "2026-05-12T17:50:13+02:00",
+    },
+    degradation_reasons: [
+        "pre_boundary_record",
+        "missing_timestamp",
+        "malformed_record",
+        "missing_conversation_key",
+        "no_agentera_state_sequence",
+        "privacy_redaction_required",
+    ],
+    privacy_boundary: {
+        canonical_artifact_labels: {
+            ".agentera/plan.yaml": "plan",
+            ".agentera/progress.yaml": "progress",
+            ".agentera/docs.yaml": "docs",
+            ".agentera/decisions.yaml": "decisions",
+            ".agentera/health.yaml": "health",
+            ".agentera/vision.yaml": "vision",
+            ".agentera/objective.yaml": "objective",
+            ".agentera/experiments.yaml": "experiments",
+            plan: "plan",
+            progress: "progress",
+            docs: "docs",
+            decisions: "decisions",
+            health: "health",
+            vision: "vision",
+            objective: "objective",
+            experiments: "experiments",
+            "AGENTS.md": "AGENTS.md",
+            "SKILL.md": "SKILL.md",
+        },
+    },
+};
+/** Legacy diagnostic label; startup analysis no longer loads a reference file. */
+export function contractPath() {
+    return "built-in:startup-state-analysis-v1";
 }
-export function loadContract(p = contractPath()) {
-    return loadYamlMapping(fs.readFileSync(p, "utf8"));
+/** Startup analysis is source-only compatibility code with fixed redaction defaults. */
+export function loadContract() {
+    return DEFAULT_CONTRACT;
 }
 export function hashLabel(kind, value, salt) {
     if (!salt) {
@@ -57,7 +93,10 @@ const FALLBACK_ARTIFACT_LABELS = [
 export function canonicalArtifactLabel(value, contract = null) {
     const text = String(value).replace(/\\/g, "/");
     const loaded = contract ?? loadContract();
-    const labels = (loaded.privacy_boundary ?? {}).canonical_artifact_labels;
+    const privacyBoundary = loaded.privacy_boundary && typeof loaded.privacy_boundary === "object" && !Array.isArray(loaded.privacy_boundary)
+        ? loaded.privacy_boundary
+        : {};
+    const labels = privacyBoundary.canonical_artifact_labels;
     if (labels && typeof labels === "object" && !Array.isArray(labels)) {
         for (const [suffix, label] of Object.entries(labels)) {
             const normalized = String(suffix).replace(/\\/g, "/");
@@ -119,4 +158,3 @@ export function formatTimestamp(value) {
     // ISO 8601 UTC, seconds precision (mirrors Python isoformat(timespec="seconds")).
     return value.toISOString().replace(/\.\d{3}Z$/, "+00:00");
 }
-//# sourceMappingURL=contract.js.map

package/dist/state/startupAnalysis/helpers.js

@@ -1,3 +1,4 @@
+import { pyJsonDumps as pyJsonDumpsCore, pyJsonString as pyJsonStringCore } from "../../core/pyjson.js";
 import { hashLabel } from "./contract.js";
 export const CLI_COMMAND_ARTIFACTS = {
     plan: new Set(["plan"]),
@@ -8,7 +9,7 @@ export const CLI_COMMAND_ARTIFACTS = {
     docs: new Set(["docs"]),
     objective: new Set(["objective"]),
     experiments: new Set(["experiments"]),
-    hej: new Set(["plan", "progress", "health", "todo", "docs", "decisions"]),
+    status: new Set(["plan", "progress", "health", "todo", "docs", "decisions"]),
     prime: new Set(["plan", "progress", "health", "todo", "docs", "decisions", "changelog"]),
 };
 export const QUERY_ARTIFACTS = {
@@ -23,23 +24,23 @@ export const QUERY_ARTIFACTS = {
     experiments: "experiments",
 };
 const PRIMARY_ROUTE_TO_CAPABILITY = {
-    build: "realisera",
-    plan: "planera",
-    status: "hej",
-    discuss: "resonera",
-    research: "inspirera",
-    optimize: "optimera",
-    audit: "inspektera",
-    document: "dokumentera",
-    profile: "profilera",
-    design: "visualisera",
-    orchestrate: "orkestrera",
-    vision: "visionera",
+    build: "build",
+    plan: "plan",
+    status: "status",
+    discuss: "discuss",
+    research: "research",
+    optimize: "optimize",
+    audit: "audit",
+    document: "document",
+    profile: "profile",
+    design: "design",
+    orchestrate: "orchestrate",
+    vision: "vision",
 };
-const CAPABILITIES_WITH_HEJ = new Set([...Object.values(PRIMARY_ROUTE_TO_CAPABILITY), "hej"]);
-const MARKER_RE = /─{2,}\s+(\S)\s+([a-z]+era|hej)\s+·\s+([a-z]+(?:\s+\d+)?)\s+─{2,}/g;
+const CAPABILITIES_WITH_STATUS = new Set([...Object.values(PRIMARY_ROUTE_TO_CAPABILITY)]);
+const MARKER_RE = /─{2,}\s+(\S)\s+(status|vision|discuss|research|plan|build|optimize|audit|document|profile|design|orchestrate)\s+·\s+([a-z]+(?:\s+\d+)?)\s+─{2,}/g;
 const BARE_AGENTERA_ROUTE_RE = /^\s*\/agentera(?:\s+([A-Za-z0-9._:-]+))?/m;
-const BARE_CAPABILITY_ROUTE_RE = /^\s*\/([a-z]+era|hej)(?:\s|$)/m;
+const BARE_CAPABILITY_ROUTE_RE = /^\s*\/(status|vision|discuss|research|plan|build|optimize|audit|document|profile|design|orchestrate)(?:\s|$)/m;
 const XML_ROUTE_RE = /<command-name>\s*\/(?:agentera\s+)?([A-Za-z0-9._:-]+)\s*<\/command-name>/;
 export const THRESHOLD_WARNING_PATTERNS = [
     [
@@ -50,7 +51,7 @@ export const THRESHOLD_WARNING_PATTERNS = [
     ],
     ["self_audit", "abstraction", "self_audit.abstraction", /abstraction creep/i],
     ["self_audit", "filler", "self_audit.filler", /\bfiller\s*:/i],
-    ["compaction", "over_limit", "compaction.uniform_10_40_50", /over(?:\s+|_)limit|uniform_10_40_50/i],
+    ["compaction", "over_limit", "compaction.uniform_10_40_50", /over(?:\s+|_)limit|uniform_(?:10_40_50|20_50_100)/i],
     ["compaction", "protected_overflow", "compaction.protected_overflow", /protected[-_ ]overflow/i],
 ];
 export const POST_AUDIT_FLAG_RE = /\[post-audit-flagged(?::[^\]]*)?\]/gi;
@@ -139,61 +140,15 @@ export function toolArgument(record, ...keys) {
     }
     return "";
 }
-export function pyJsonString(str) {
-    let out = '"';
-    for (const ch of str) {
-        const cp = ch.codePointAt(0);
-        if (ch === '"')
-            out += '\\"';
-        else if (ch === "\\")
-            out += "\\\\";
-        else if (cp === 0x08)
-            out += "\\b";
-        else if (cp === 0x09)
-            out += "\\t";
-        else if (cp === 0x0a)
-            out += "\\n";
-        else if (cp === 0x0c)
-            out += "\\f";
-        else if (cp === 0x0d)
-            out += "\\r";
-        else if (cp < 0x20)
-            out += "\\u" + cp.toString(16).padStart(4, "0");
-        else if (cp < 0x80)
-            out += ch;
-        else if (cp > 0xffff) {
-            const v = cp - 0x10000;
-            const hi = 0xd800 + (v >> 10);
-            const lo = 0xdc00 + (v & 0x3ff);
-            out += "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
-        }
-        else {
-            out += "\\u" + cp.toString(16).padStart(4, "0");
-        }
-    }
-    return out + '"';
+export const pyJsonString = pyJsonStringCore;
+function startupJsonScalar(value) {
+    if (value instanceof Flt)
+        return formatFloat(value.v);
+    return undefined;
 }
 /** Mirror Python json.dumps(value, sort_keys=True) (separators ", "/": ", ensure_ascii). */
 export function pyJsonDumps(value) {
-    if (value === null || value === undefined)
-        return "null";
-    if (value === true)
-        return "true";
-    if (value === false)
-        return "false";
-    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))
-        return "[" + value.map((v) => pyJsonDumps(v)).join(", ") + "]";
-    if (typeof value === "object") {
-        const keys = Object.keys(value).sort();
-        return "{" + keys.map((k) => `${pyJsonString(k)}: ${pyJsonDumps(value[k])}`).join(", ") + "}";
-    }
-    return "null";
+    return pyJsonDumpsCore(value, startupJsonScalar);
 }
 export function argumentsText(record) {
     return pyJsonDumps(toolArguments(record));
@@ -213,12 +168,12 @@ export function routeCapability(text) {
     let m = XML_ROUTE_RE.exec(text);
     if (m) {
         const route = m[1].toLowerCase();
-        return CAPABILITIES_WITH_HEJ.has(route) ? route : (PRIMARY_ROUTE_TO_CAPABILITY[route] ?? null);
+        return CAPABILITIES_WITH_STATUS.has(route) ? route : (PRIMARY_ROUTE_TO_CAPABILITY[route] ?? null);
     }
     m = BARE_AGENTERA_ROUTE_RE.exec(text);
     if (m) {
         const route = (m[1] || "status").toLowerCase();
-        return CAPABILITIES_WITH_HEJ.has(route) ? route : (PRIMARY_ROUTE_TO_CAPABILITY[route] ?? null);
+        return CAPABILITIES_WITH_STATUS.has(route) ? route : (PRIMARY_ROUTE_TO_CAPABILITY[route] ?? null);
     }
     m = BARE_CAPABILITY_ROUTE_RE.exec(text);
     if (m) {
@@ -234,7 +189,7 @@ export function capabilityInvocation(text) {
     if (marker)
         return marker;
     const lowered = text.toLowerCase();
-    for (const capability of [...CAPABILITIES_WITH_HEJ].sort()) {
+    for (const capability of [...CAPABILITIES_WITH_STATUS].sort()) {
         if (new RegExp(`\\b${capability.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(lowered)) {
             return capability;
         }
@@ -329,4 +284,3 @@ export function safeInt(value) {
 export function nowIsoSeconds() {
     return new Date().toISOString().replace(/\.\d{3}Z$/, "+00:00");
 }
-//# sourceMappingURL=helpers.js.map

package/dist/state/startupAnalysis/index.js

@@ -4,4 +4,3 @@ export { classifyStartupRecords } from "./records.js";
 export { STARTUP_METRICS_ENVELOPE, TOKEN_ESTIMATOR_VERSION, aggregateStartupMetrics, } from "./metrics.js";
 export { STARTUP_REPORT_MARKDOWN, STARTUP_REPORT_JSON, renderStartupReport, writeStartupReports, } from "./report.js";
 export { STARTUP_INTERMEDIATE_ENVELOPE, BENCHMARK_HISTORY_JSONL, BENCHMARK_LATEST_REPORT_JSON, BENCHMARK_LATEST_REPORT_MARKDOWN, previousBenchmarkWatermark, buildBenchmarkHistoryRow, persistStartupBenchmark, buildStartupIntermediate, buildNoRuntimeStartupIntermediate, extractStartupIntermediateFromCorpusFile, } from "./benchmark.js";
-//# sourceMappingURL=index.js.map