agentera 3.0.0-dev.5 → 3.0.0-dev.51

package/dist/eval/evalSkills.js

@@ -2,19 +2,24 @@ import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { resolveSourceRoot } from "../core/sourceRoot.js";
+/**
+ * Tier 2 eval runner for agentera skill smoke testing. Faithful TS port of
+ * scripts/eval_skills.py. Crash/error detection only; output correctness is not
+ * evaluated. `which`/`run` are injectable for deterministic testing.
+ */
 export const TRIGGER_PROMPTS = {
-    dokumentera: "Audit the documentation for this project.",
-    hej: "Start a new session and give me a status briefing on this project.",
-    inspektera: "Run a codebase health audit.",
-    inspirera: "Analyze https://example.com and map patterns to this project.",
-    optimera: "Optimize test suite execution time.",
-    orkestrera: "Execute the next cycle of the current plan.",
-    planera: "Plan the next feature for this project.",
-    profilera: "Generate a decision profile from session history.",
-    realisera: "Run one autonomous development cycle.",
-    resonera: "Deliberate on whether to add a new dependency.",
-    visionera: "Create a vision document for this project.",
-    visualisera: "Create a visual identity system for this project.",
+    document: "Audit the documentation for this project.",
+    status: "Start a new session and give me a status briefing on this project.",
+    audit: "Run a codebase health audit.",
+    research: "Analyze https://example.com and map patterns to this project.",
+    optimize: "Optimize test suite execution time.",
+    orchestrate: "Execute the next cycle of the current plan.",
+    plan: "Plan the next feature for this project.",
+    profile: "Generate a decision profile from session history.",
+    build: "Run one autonomous development cycle.",
+    discuss: "Deliberate on whether to add a new dependency.",
+    vision: "Create a vision document for this project.",
+    design: "Create a visual identity system for this project.",
 };
 export const DEFAULT_TIMEOUT = 120;
 export const DEFAULT_PARALLEL = 1;
@@ -36,7 +41,11 @@ export function detectRuntime(explicit, opts = {}) {
     const which = opts.which ?? realWhich;
     const err = opts.err ?? ((line) => process.stderr.write(line + "\n"));
     if (explicit && explicit !== "auto") {
-        if (explicit === "cursor-agent") {
+        if (explicit !== "opencode" && explicit !== "cursor") {
+            err(`ERROR: '${explicit}' is not an active eval runtime; choose opencode or cursor.`);
+            throw new ExitError(1);
+        }
+        if (explicit === "cursor") {
             if (which("cursor-agent") === null && which("agent") === null) {
                 err("ERROR: 'cursor-agent' not found on PATH. Install Cursor Agent CLI " +
                     "and ensure the binary is accessible.");
@@ -45,17 +54,14 @@ export function detectRuntime(explicit, opts = {}) {
         }
         return explicit;
     }
-    const hasClaude = which("claude") !== null;
     const hasOpencode = which("opencode") !== null;
     const hasCursorAgent = which("cursor-agent") !== null || which("agent") !== null;
-    if (hasClaude)
-        return "claude";
     if (hasOpencode)
         return "opencode";
     if (hasCursorAgent)
-        return "cursor-agent";
-    err("ERROR: Neither 'claude', 'opencode', nor 'cursor-agent' found on PATH. " +
-        "Install a supported runtime host and ensure the binary is accessible.");
+        return "cursor";
+    err("ERROR: Neither the OpenCode nor Cursor eval surface was found on PATH. " +
+        "Install an active eval runtime host and ensure the binary is accessible.");
     throw new ExitError(1);
 }
 export function parseFrontmatterName(text) {
@@ -103,7 +109,7 @@ const realRun = (cmd, opts) => {
         timedOut: result.signal === "SIGTERM" && result.error !== undefined,
     };
 };
-export function invokeSkill(name, prompt, timeout, runtime = "claude", opts = {}) {
+export function invokeSkill(name, prompt, timeout, runtime = "opencode", opts = {}) {
     const which = opts.which ?? realWhich;
     const run = opts.run ?? realRun;
     const repoRoot = opts.repoRoot ?? resolveSourceRoot();
@@ -113,14 +119,13 @@ export function invokeSkill(name, prompt, timeout, runtime = "claude", opts = {}
         cmd = ["opencode", "run", "--prompt"];
         stdinPrompt = prompt;
     }
-    else if (runtime === "cursor-agent") {
+    else if (runtime === "cursor") {
         const binary = which("cursor-agent") ? "cursor-agent" : "agent";
         cmd = [binary, "-p", "--output-format", "json", "--force", prompt];
         stdinPrompt = null;
     }
     else {
-        cmd = ["claude", "-p", "--output-format", "json"];
-        stdinPrompt = prompt;
+        throw new ExitError(1, `unsupported active eval runtime: ${runtime}`);
     }
     const start = Date.now();
     let error = null;
@@ -163,7 +168,7 @@ export function invokeSkill(name, prompt, timeout, runtime = "claude", opts = {}
         error,
     };
 }
-export function runSkills(skills, timeout, _parallel, runtime = "claude", opts = {}) {
+export function runSkills(skills, timeout, _parallel, runtime = "opencode", opts = {}) {
     // Parallelism in the Python runner is a maintainer perf detail; the smoke
     // semantics (one result per skill, original order) are preserved sequentially.
     return skills.map((entry) => invokeSkill(entry.name, entry.prompt, timeout, runtime, opts));
@@ -179,7 +184,7 @@ export function buildReport(results) {
         results,
     };
 }
-export function buildDryRun(skills, runtime = "claude", runtimeSource = "auto-detected") {
+export function buildDryRun(skills, runtime = "opencode", runtimeSource = "auto-detected") {
     return {
         mode: "dry-run",
         runtime: `${runtime} (${runtimeSource})`,
@@ -255,4 +260,3 @@ export function parseArgs(argv) {
     }
     return args;
 }
-//# sourceMappingURL=evalSkills.js.map

package/dist/eval/hybridRouteEvaluation.js

@@ -0,0 +1,155 @@
+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";
+import { resolveRouteRequest } from "../registries/hybridRoute.js";
+import { validateRouteReceiptSubmission } from "../registries/hybridRouteReceipt.js";
+function mapping(value, source) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${source} must be a mapping`);
+    return value;
+}
+function requiredString(value, source) {
+    if (typeof value !== "string" || !value)
+        throw new Error(`${source} must be a non-empty string`);
+    return value;
+}
+function cases(value, source) {
+    if (!Array.isArray(value))
+        throw new Error(`${source} must be a list`);
+    return value;
+}
+function elapsedMs(start) {
+    return Number(process.hrtime.bigint() - start) / 1_000_000;
+}
+function percentile(values) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((left, right) => left - right);
+    return sorted[Math.ceil(sorted.length * 0.95) - 1];
+}
+function hashFile(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function nullableFixtureReceipt(receipt) {
+    return {
+        version: null,
+        request_sha256: null,
+        semantic_capsule_sha256: null,
+        outcome: null,
+        capability: null,
+        compound: null,
+        question: null,
+        remainder_span: null,
+        ...receipt,
+    };
+}
+/** Runs the complete frozen synthetic conformance corpus without invoking a semantic host. */
+export function evaluateHybridRoute(sourceRoot = resolveSourceRoot()) {
+    const contractPath = path.join(sourceRoot, "references/cli/hybrid-route-contract.yaml");
+    const corpusPath = path.join(sourceRoot, "fixtures/routing/hybrid-corpus.yaml");
+    const phrasePath = path.join(sourceRoot, "skills/agentera/route-phrases.yaml");
+    const skillPath = path.join(sourceRoot, "skills/agentera/SKILL.md");
+    const contract = loadYamlMapping(fs.readFileSync(contractPath, "utf8"));
+    const corpus = loadYamlMapping(fs.readFileSync(corpusPath, "utf8"));
+    const evaluation = mapping(contract.evaluation, "contract.evaluation");
+    const targetGates = mapping(evaluation.target_gates, "contract.evaluation.target_gates");
+    const routeCases = cases(corpus.route_cases, "corpus.route_cases");
+    const receiptCases = cases(corpus.receipt_cases, "corpus.receipt_cases");
+    const results = [];
+    const deterministicTimings = [];
+    const receiptTimings = [];
+    for (const routeCase of routeCases) {
+        const start = process.hrtime.bigint();
+        const observed = resolveRouteRequest(routeCase.request, sourceRoot);
+        const elapsed = elapsedMs(start);
+        deterministicTimings.push(elapsed);
+        const passed = observed.outcome === routeCase.expected.phase1
+            && (observed.outcome !== "deterministic_selection" || (observed.tier === routeCase.expected.tier && observed.capability === routeCase.expected.capability));
+        const harmfulMisroute = observed.outcome === "deterministic_selection"
+            && (routeCase.expected.phase1 !== "deterministic_selection" || observed.capability !== routeCase.expected.capability);
+        results.push({
+            case_id: routeCase.id,
+            partition: routeCase.partition,
+            evaluation_tier: "deterministic",
+            routing_tier: observed.outcome === "deterministic_selection" ? observed.tier : "deterministic_abstention",
+            expected_outcome: routeCase.expected.phase1,
+            observed_outcome: observed.outcome,
+            ...(observed.outcome === "deterministic_selection" ? { capability: observed.capability } : {}),
+            status: passed ? "pass" : "fail",
+            ...(passed ? {} : { failure_tier: "deterministic" }),
+            harmful_misroute: harmfulMisroute,
+            elapsed_ms: elapsed,
+        });
+    }
+    for (const receiptCase of receiptCases) {
+        const start = process.hrtime.bigint();
+        let terminal = "invalid_receipt";
+        try {
+            const receipt = receiptCase.valid ? nullableFixtureReceipt(receiptCase.receipt) : receiptCase.receipt;
+            terminal = validateRouteReceiptSubmission({ request: receiptCase.request, receipt }, sourceRoot).outcome;
+        }
+        catch {
+            terminal = "invalid_receipt";
+        }
+        const elapsed = elapsedMs(start);
+        receiptTimings.push(elapsed);
+        const passed = terminal === receiptCase.expected_terminal;
+        const harmfulMisroute = terminal === "selected" && receiptCase.expected_terminal !== "selected";
+        results.push({
+            case_id: receiptCase.id,
+            partition: receiptCase.partition,
+            evaluation_tier: "receipt_validation",
+            routing_tier: "semantic_receipt_validation",
+            expected_outcome: receiptCase.expected_terminal,
+            observed_outcome: terminal,
+            status: passed ? "pass" : "fail",
+            ...(passed ? {} : { failure_tier: "receipt_validation" }),
+            harmful_misroute: harmfulMisroute,
+            elapsed_ms: elapsed,
+        });
+    }
+    const failed = results.filter(({ status }) => status === "fail");
+    const harmfulMisroutes = results.filter((result) => result.harmful_misroute === true).length;
+    return {
+        schemaVersion: "agentera.hybrid_route_evaluation.v1",
+        status: failed.length === 0 ? "pass" : "fail",
+        authority: {
+            contract_version: requiredString(contract.schema_version, "contract.schema_version"),
+            protocol_sha256: hashFile(contractPath),
+            phrase_authority_sha256: hashFile(phrasePath),
+            shared_skill_sha256: hashFile(skillPath),
+        },
+        corpus: {
+            schema_version: requiredString(corpus.schema_version, "corpus.schema_version"),
+            content_sha256: hashFile(corpusPath),
+            partitions: corpus.partitions,
+            case_count: results.length,
+        },
+        results,
+        aggregate_metrics: {
+            passed: results.length - failed.length,
+            failed: failed.length,
+            harmful_misroutes: {
+                scope: "deterministic_and_receipt_validation_conformance",
+                target: targetGates.harmful_misroutes,
+                observed: harmfulMisroutes,
+                status: harmfulMisroutes === 0 ? "pass" : "fail",
+                taxonomy: evaluation.harmful_misroute_taxonomy,
+            },
+        },
+        model_context: {
+            status: "unmeasured",
+            reason: "host_dependent",
+            samples: 0,
+            distributions: {},
+        },
+        latency: {
+            deterministic_phase1: { sample_count: deterministicTimings.length, p95_ms: percentile(deterministicTimings), target: targetGates.deterministic_phase1_p95 },
+            receipt_validation: { sample_count: receiptTimings.length, p95_ms: percentile(receiptTimings), target: targetGates.receipt_validation_p95 },
+            semantic_model: { status: "unmeasured", reason: "host_dependent" },
+            end_to_end: { status: "unmeasured", reason: "host_dependent" },
+        },
+    };
+}

package/dist/eval/semanticEval.js

@@ -45,7 +45,9 @@ export function buildReport(results) {
 function checkOutputFacts(fixture) {
     const facts = [];
     const expected = fixture.expectedFacts;
-    (expected.required_output ?? []).forEach((text, index) => {
+    const requiredOutput = expected.required_output;
+    const requiredOutputArr = Array.isArray(requiredOutput) ? requiredOutput : []; // cast: JSON.parse fixture IO boundary
+    requiredOutputArr.forEach((text, index) => {
         const found = fixture.capturedOutput.includes(text);
         facts.push({
             fact: `required_output[${index}]`,
@@ -53,7 +55,9 @@ function checkOutputFacts(fixture) {
             detail: `captured output ${found ? "contains" : "does not contain"} ${pyRepr(text)}`,
         });
     });
-    (expected.forbidden_output ?? []).forEach((text, index) => {
+    const forbiddenOutput = expected.forbidden_output;
+    const forbiddenOutputArr = Array.isArray(forbiddenOutput) ? forbiddenOutput : []; // cast: JSON.parse fixture IO boundary
+    forbiddenOutputArr.forEach((text, index) => {
         const found = fixture.capturedOutput.includes(text);
         facts.push({
             fact: `forbidden_output[${index}]`,
@@ -61,7 +65,8 @@ function checkOutputFacts(fixture) {
             detail: `captured output ${found ? "contains forbidden" : "omits forbidden"} ${pyRepr(text)}`,
         });
     });
-    const writes = expected.artifact_expectations?.writes;
+    const artifactExpectations = expected.artifact_expectations; // cast: JSON.parse fixture IO boundary
+    const writes = artifactExpectations?.writes;
     if (writes === "none") {
         facts.push({
             fact: "artifact_expectations.writes",
@@ -74,9 +79,12 @@ function checkOutputFacts(fixture) {
 function checkToolTraceFacts(fixture) {
     const facts = [];
     const expected = fixture.expectedFacts;
-    const callList = fixture.toolTrace.calls ?? [];
+    const rawCalls = fixture.toolTrace.calls;
+    const callList = Array.isArray(rawCalls) ? rawCalls : []; // cast: JSON.parse fixture IO boundary
     const calls = callList.join("\n");
-    (expected.required_tool_calls ?? []).forEach((text, index) => {
+    const requiredToolCalls = expected.required_tool_calls;
+    const requiredToolCallsArr = Array.isArray(requiredToolCalls) ? requiredToolCalls : []; // cast: JSON.parse fixture IO boundary
+    requiredToolCallsArr.forEach((text, index) => {
         const found = calls.includes(text);
         facts.push({
             fact: `required_tool_calls[${index}]`,
@@ -84,7 +92,9 @@ function checkToolTraceFacts(fixture) {
             detail: `tool trace ${found ? "contains" : "does not contain"} ${pyRepr(text)}`,
         });
     });
-    (expected.forbidden_tool_calls ?? []).forEach((text, index) => {
+    const forbiddenToolCalls = expected.forbidden_tool_calls;
+    const forbiddenToolCallsArr = Array.isArray(forbiddenToolCalls) ? forbiddenToolCalls : []; // cast: JSON.parse fixture IO boundary
+    forbiddenToolCallsArr.forEach((text, index) => {
         const found = calls.includes(text);
         facts.push({
             fact: `forbidden_tool_calls[${index}]`,
@@ -92,31 +102,43 @@ function checkToolTraceFacts(fixture) {
             detail: `tool trace ${found ? "contains forbidden" : "omits forbidden"} ${pyRepr(text)}`,
         });
     });
-    for (const [text, expectedCount] of Object.entries(expected.tool_call_counts ?? {})) {
-        const actual = callList.filter((call) => call.includes(text)).length;
-        facts.push({
-            fact: `tool_call_counts[${text}]`,
-            status: actual === expectedCount ? "pass" : "fail",
-            detail: `tool trace contains ${actual} call(s) matching ${pyRepr(text)}; expected ${expectedCount}`,
-        });
+    const toolCallCounts = expected.tool_call_counts;
+    if (toolCallCounts && typeof toolCallCounts === "object" && !Array.isArray(toolCallCounts)) {
+        for (const [text, expectedCount] of Object.entries(toolCallCounts)) { // cast: JSON.parse fixture IO boundary
+            const actual = callList.filter((call) => call.includes(text)).length;
+            facts.push({
+                fact: `tool_call_counts[${text}]`,
+                status: actual === expectedCount ? "pass" : "fail",
+                detail: `tool trace contains ${actual} call(s) matching ${pyRepr(text)}; expected ${expectedCount}`,
+            });
+        }
     }
     return facts;
 }
 function checkSeededArtifactFacts(fixture) {
     const facts = [];
     const byPath = {};
-    for (const item of fixture.seededState.files ?? []) {
-        if (item && typeof item === "object" && typeof item.path === "string") {
-            byPath[item.path] = item.content;
+    const rawFiles = fixture.seededState.files;
+    const filesArr = Array.isArray(rawFiles) ? rawFiles : [];
+    for (const item of filesArr) {
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+            const obj = item; // cast: JSON.parse fixture IO boundary
+            const path = obj.path;
+            if (typeof path === "string") {
+                byPath[path] = obj.content; // cast: JSON.parse fixture IO boundary
+            }
         }
     }
-    (fixture.expectedFacts.required_artifacts ?? []).forEach((expected, index) => {
+    const requiredArtifacts = fixture.expectedFacts.required_artifacts;
+    const requiredArtifactsArr = Array.isArray(requiredArtifacts) ? requiredArtifacts : [];
+    requiredArtifactsArr.forEach((expected, index) => {
         const factName = `required_artifacts[${index}]`;
         if (!expected || typeof expected !== "object" || Array.isArray(expected)) {
             facts.push({ fact: factName, status: "fail", detail: "expected artifact fact must be an object" });
             return;
         }
-        const path = expected.path;
+        const expectedObj = expected; // cast: JSON.parse fixture IO boundary
+        const path = expectedObj.path;
         if (typeof path !== "string" || !path.trim()) {
             facts.push({ fact: factName, status: "fail", detail: "expected artifact fact must name a path" });
             return;
@@ -126,7 +148,9 @@ function checkSeededArtifactFacts(fixture) {
             facts.push({ fact: factName, status: "fail", detail: `seeded artifact ${pyRepr(path)} is missing` });
             return;
         }
-        const missing = (expected.contains ?? []).filter((text) => !content.includes(text));
+        const containsRaw = expectedObj.contains;
+        const containsArr = Array.isArray(containsRaw) ? containsRaw : []; // cast: JSON.parse fixture IO boundary
+        const missing = containsArr.filter((text) => !content.includes(text));
         if (missing.length > 0) {
             facts.push({ fact: factName, status: "fail", detail: `seeded artifact ${pyRepr(path)} lacks ${pyRepr(missing[0])}` });
         }
@@ -145,4 +169,3 @@ export function main(argv = [], out = (l) => process.stdout.write(l)) {
     out(pyJsonIndent(report) + "\n");
     return report.status === "pass" ? 0 : 1;
 }
-//# sourceMappingURL=semanticEval.js.map

package/dist/eval/semanticFixtures.js

@@ -1,4 +1,8 @@
 import fs from "node:fs";
+/**
+ * Semantic fixture contract validation for offline skill evals. Faithful TS
+ * port of scripts/semantic_fixtures.py. Defines the fixture shape only.
+ */
 export const REQUIRED_SECTIONS = [
     "Prompt",
     "Seeded Project State",
@@ -113,10 +117,18 @@ function validateExpectedFacts(sectionText) {
     errors.push(...validateStringList(d, "required_tool_calls", false));
     errors.push(...validateStringList(d, "forbidden_tool_calls", false));
     errors.push(...validateToolCallCounts(d.tool_call_counts));
-    const hasOutputFact = Boolean(d.required_output?.length || d.forbidden_output?.length);
-    const hasToolFact = Boolean(d.required_tool_calls?.length ||
-        d.forbidden_tool_calls?.length ||
-        (d.tool_call_counts && Object.keys(d.tool_call_counts).length));
+    const requiredOutput = d.required_output;
+    const forbiddenOutput = d.forbidden_output;
+    const hasOutputFact = Boolean((Array.isArray(requiredOutput) || typeof requiredOutput === "string" ? requiredOutput.length : 0) ||
+        (Array.isArray(forbiddenOutput) || typeof forbiddenOutput === "string" ? forbiddenOutput.length : 0));
+    const requiredToolCalls = d.required_tool_calls;
+    const forbiddenToolCalls = d.forbidden_tool_calls;
+    const toolCallCounts = d.tool_call_counts;
+    const hasToolFact = Boolean((Array.isArray(requiredToolCalls) || typeof requiredToolCalls === "string" ? requiredToolCalls.length : 0) ||
+        (Array.isArray(forbiddenToolCalls) || typeof forbiddenToolCalls === "string" ? forbiddenToolCalls.length : 0) ||
+        (toolCallCounts && typeof toolCallCounts === "object" && !Array.isArray(toolCallCounts)
+            ? Object.keys(toolCallCounts).length
+            : 0));
     const hasArtifactFact = "artifact_expectations" in d;
     if (!hasOutputFact && !hasToolFact && !hasArtifactFact) {
         errors.push("malformed section: Expected Facts: must declare at least one expected fact");
@@ -224,4 +236,3 @@ export function pyRepr(value) {
     }
     return "'" + value.replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
 }
-//# sourceMappingURL=semanticFixtures.js.map

package/dist/hooks/common.js

@@ -1,18 +1,13 @@
-import crypto from "node:crypto";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
-import { expanduser, resolvePath } from "../core/paths.js";
-import { resolveCandidate } from "../state/installRoot.js";
+import { ARTIFACT_PROTOCOL_PATHS, normalizeArtifactMappingKeys, normalizeArtifactProtocolId, } from "../registries/artifactProtocolIds.js";
 /**
- * Shared utilities for agentera hooks. Faithful TS port of hooks/common.py:
- * compaction retention caps, runtime-local session bookmark paths, and artifact
- * path resolution.
+ * Shared utilities for compaction retention caps and artifact path resolution.
  */
 export { loadYamlMapping, loadYamlMappingFile, } from "../core/yaml.js";
 export const MAX_FULL_ENTRIES = 10;
 export const MAX_ONELINE_ENTRIES = 40;
-export const MAX_TOTAL_ENTRIES = MAX_FULL_ENTRIES + MAX_ONELINE_ENTRIES;
+export const MAX_TOTAL_ENTRIES = 50;
 export function applyRetentionCaps(fullEntries, archiveEntries, opts = {}) {
     const maxFull = opts.maxFull ?? MAX_FULL_ENTRIES;
     const maxOneline = opts.maxOneline ?? MAX_ONELINE_ENTRIES;
@@ -20,63 +15,7 @@ export function applyRetentionCaps(fullEntries, archiveEntries, opts = {}) {
     const cappedArchive = archiveEntries.slice(0, maxOneline);
     return [...fullEntries.slice(0, maxFull), ...cappedArchive].slice(0, maxTotal);
 }
-export function resolveAgenteraDataHome(env = process.env, home = os.homedir()) {
-    const configured = env.AGENTERA_HOME;
-    if (configured) {
-        return expanduser(configured);
-    }
-    const [root] = resolveCandidate(null, { env, home });
-    return root;
-}
-export function resolveSessionPath(projectRoot, env = process.env, home = os.homedir()) {
-    const dataHome = resolveAgenteraDataHome(env, home);
-    const resolved = resolvePath(projectRoot);
-    const digest = crypto.createHash("sha256").update(resolved, "utf8").digest("hex").slice(0, 16);
-    const name = path.basename(projectRoot);
-    const slug = name.replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^[.-]+|[.-]+$/g, "") || "project";
-    return path.join(dataHome, "sessions", `${slug}-${digest}`, "session.yaml");
-}
-export function sessionBookmarkToOneline(entry) {
-    return {
-        timestamp: String(entry.timestamp ?? ""),
-        artifacts: [],
-        summary: String(entry.summary ?? ""),
-        kind: "oneline",
-    };
-}
-export function compactSessionBookmarkEntries(entries, opts = {}) {
-    const maxFull = opts.maxFull ?? MAX_FULL_ENTRIES;
-    const maxOneline = opts.maxOneline ?? MAX_ONELINE_ENTRIES;
-    const maxTotal = opts.maxTotal ?? MAX_TOTAL_ENTRIES;
-    const convert = opts.toOneline ?? sessionBookmarkToOneline;
-    const ordered = [...entries].sort((a, b) => {
-        const ta = String(a.timestamp ?? "");
-        const tb = String(b.timestamp ?? "");
-        return ta < tb ? 1 : ta > tb ? -1 : 0;
-    });
-    const full = [];
-    const archive = [];
-    for (const entry of ordered) {
-        if (entry.kind === "full" && full.length < maxFull) {
-            full.push(entry);
-        }
-        else {
-            archive.push(convert(entry));
-        }
-    }
-    return applyRetentionCaps(full, archive, { maxFull, maxOneline, maxTotal });
-}
-export const DEFAULT_ARTIFACT_PATHS = {
-    "VISION.md": ".agentera/vision.yaml",
-    "TODO.md": "TODO.md",
-    "CHANGELOG.md": "CHANGELOG.md",
-    "DECISIONS.md": ".agentera/decisions.yaml",
-    "PLAN.md": ".agentera/plan.yaml",
-    "PROGRESS.md": ".agentera/progress.yaml",
-    "HEALTH.md": ".agentera/health.yaml",
-    "DOCS.md": ".agentera/docs.yaml",
-    "DESIGN.md": "DESIGN.md",
-};
+export const DEFAULT_ARTIFACT_PATHS = { ...ARTIFACT_PROTOCOL_PATHS };
 function stripQuotes(value) {
     return value.replace(/^['"]|['"]$/g, "");
 }
@@ -106,7 +45,7 @@ export function parseDocsYamlMapping(docsText) {
             current = null;
         }
     }
-    return mapping;
+    return normalizeArtifactMappingKeys(mapping);
 }
 export function parseArtifactMapping(docsText) {
     const mapping = {};
@@ -130,29 +69,22 @@ export function parseArtifactMapping(docsText) {
             break;
         }
     }
-    return mapping;
+    return normalizeArtifactMappingKeys(mapping);
 }
 export function resolveArtifactPath(projectRoot, artifact, overrides = null) {
-    if (overrides && artifact in overrides) {
-        return path.join(projectRoot, overrides[artifact]);
+    const artifactId = normalizeArtifactProtocolId(artifact) ?? artifact;
+    if (overrides && artifactId in overrides) {
+        return path.join(projectRoot, overrides[artifactId]);
     }
-    return path.join(projectRoot, DEFAULT_ARTIFACT_PATHS[artifact] ?? `.agentera/${artifact}`);
+    return path.join(projectRoot, DEFAULT_ARTIFACT_PATHS[artifactId] ?? `.agentera/${artifactId}.yaml`);
 }
 export function loadArtifactOverrides(projectRoot) {
-    const yamlPath = path.join(projectRoot, ".agentera", "docs.yaml");
+    const yamlPath = path.join(projectRoot, ARTIFACT_PROTOCOL_PATHS.docs);
     if (fs.existsSync(yamlPath)) {
         const mapping = parseDocsYamlMapping(fs.readFileSync(yamlPath, "utf8"));
         if (Object.keys(mapping).length > 0) {
             return mapping;
         }
     }
-    const docsPath = path.join(projectRoot, ".agentera", "DOCS.md");
-    if (fs.existsSync(docsPath)) {
-        const mapping = parseArtifactMapping(fs.readFileSync(docsPath, "utf8"));
-        if (Object.keys(mapping).length > 0) {
-            return mapping;
-        }
-    }
     return null;
 }
-//# sourceMappingURL=common.js.map