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

package/dist/validate/selfAudit.js

@@ -2,31 +2,7 @@
  * Self-audit checks for artifact writing conventions. Faithful TS port of
  * `scripts/self_audit.py`. Advisory only — report but do not block writes.
  */
-import { normalizeArtifactProtocolId } from "../registries/artifactProtocolIds.js";
-const FULL_FILE_BUDGETS = {
-    progress: 3000,
-    experiments: 2500,
-    health: 2000,
-    decisions: 5000,
-    todo: 5000,
-    changelog: 5000,
-    plan: 2500,
-    vision: 1500,
-    design: 2000,
-    docs: 2000,
-};
-const PER_ENTRY_BUDGETS = {
-    progress: 500,
-    experiments: 300,
-    health: 150,
-    decisions: 200,
-    todo: 100,
-    changelog: 300,
-    plan: 100,
-};
-function resolveBudgetArtifact(artifact) {
-    return normalizeArtifactProtocolId(artifact) ?? artifact.toLowerCase();
-}
+import { inspectArtifactVerbosityBudget, } from "../registries/verbosityBudgetContract.js";
 const FILE_PATH_RE = /\b(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+\.[A-Za-z]{1,10}\b/;
 const REPO_PATH_RE = /\b(?:internal|src|lib|pkg|cmd|app|test|tests|doc|docs|script|scripts|skill|skills|hook|hooks|fixture|fixtures|reference|references)(?:\/[A-Za-z0-9_.-]+)+\b/;
 const LINE_NUMBER_RE = /:\d{2,}\b/;
@@ -49,34 +25,56 @@ const BANNED_PATTERNS = [
     ["filler introductions", /After\s+careful\s+consideration\b/i],
     ["summary preambles", /\bIn\s+summary\b/i],
     ["summary preambles", /\bTo\s+recap\b/i],
-    ["summary preambles", /\bOverall\b/i],
+    ["summary preambles", /\bOverall\b(?!\s+acceptance\b)/i],
     ["excessive justification", /I\s+chose\s+this\s+approach\s+because\b/i],
 ];
 /** Count non-whitespace tokens, matching Python's str.split(). */
 function wordCount(text) {
     return (text.match(/\S+/g) ?? []).length;
 }
-export function checkVerbosity(text, artifact, budgets = null) {
-    const count = wordCount(text);
-    const table = budgets ?? PER_ENTRY_BUDGETS;
-    const resolved = resolveBudgetArtifact(artifact);
-    let perEntryBudget = table[resolved];
-    if (perEntryBudget === undefined) {
-        const fullBudget = FULL_FILE_BUDGETS[resolved];
-        perEntryBudget = fullBudget !== undefined ? Math.floor(fullBudget / 5) : 500;
+export function checkVerbosity(text, artifact, contractPath) {
+    return checkAuthoritativeWordBudget(text, artifact, false, contractPath);
+}
+export function checkFullFileVerbosity(text, artifact, contractPath) {
+    return checkAuthoritativeWordBudget(text, artifact, true, contractPath);
+}
+function authorityError(artifact, detail) {
+    return [
+        false,
+        `verbosity authority error for ${JSON.stringify(artifact)}: ${detail}; ` +
+            "repair the declared owner in references/artifacts/verbosity-budget-authority.yaml",
+    ];
+}
+function applicableDimensions(dimensions, fullArtifact) {
+    return dimensions.filter((dimension) => fullArtifact ? dimension.scope === "full_file" : dimension.scope !== "full_file");
+}
+function checkAuthoritativeWordBudget(text, artifact, fullArtifact, contractPath) {
+    let dimensions;
+    try {
+        dimensions = inspectArtifactVerbosityBudget(artifact, contractPath).dimensions;
     }
-    if (count <= perEntryBudget) {
+    catch (error) {
+        return authorityError(artifact, error.message);
+    }
+    const invalid = dimensions.filter((dimension) => dimension.classification === "invalid_declaration");
+    if (invalid.length > 0) {
+        return authorityError(artifact, invalid.map((dimension) => `${dimension.scope}: ${dimension.error ?? "invalid declaration"}`).join("; "));
+    }
+    const applicable = applicableDimensions(dimensions, fullArtifact);
+    if (applicable.length > 1) {
+        const kind = fullArtifact ? "full-file" : "per-entry";
+        return authorityError(artifact, `multiple ${kind} declarations apply: ${applicable.map((d) => d.scope).join(", ")}`);
+    }
+    const dimension = applicable[0];
+    if (!dimension || dimension.classification !== "numeric_limit") {
         return [true, ""];
     }
-    return [false, `verbosity mismatch: ${count} words exceeds ${perEntryBudget} budget`];
-}
-export function checkFullFileVerbosity(text, artifact) {
     const count = wordCount(text);
-    const budget = FULL_FILE_BUDGETS[resolveBudgetArtifact(artifact)] ?? 2500;
-    if (count <= budget) {
+    if (count <= dimension.limit) {
         return [true, ""];
     }
-    return [false, `verbosity mismatch: ${count} words exceeds ${budget} full-file budget`];
+    const qualifier = fullArtifact ? " full-file" : "";
+    return [false, `verbosity mismatch: ${count} words exceeds ${dimension.limit}${qualifier} budget`];
 }
 export function checkAbstraction(text) {
     for (const re of [
@@ -112,9 +110,6 @@ export function checkFiller(text) {
 /** Smoke-validate that self-audit conventions and budgets are wired. */
 export function validateSelfAuditConventions() {
     const errors = [];
-    if (Object.keys(FULL_FILE_BUDGETS).length === 0 || Object.keys(PER_ENTRY_BUDGETS).length === 0) {
-        errors.push("self-audit: budget tables must be non-empty");
-    }
     const sample = "concrete anchor `scripts/agentera` at line 42 with 12 words total here";
     const [verbosityOk] = checkVerbosity(sample, "progress");
     if (!verbosityOk) {
@@ -146,4 +141,3 @@ export function selfAuditMain(opts = {}) {
     out("self-audit conventions ok");
     return 0;
 }
-//# sourceMappingURL=selfAudit.js.map

package/dist/validate/v1LegacyCruft.js

@@ -0,0 +1,131 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { resolvePath } from "../core/paths.js";
+import { confirmedVariantGuardContract } from "../registries/glossaryEntryContract.js";
+import { containsGlossaryTerm } from "../registries/glossaryTermOccurrence.js";
+import { loadProjectGlossaryDocument, } from "../state/write/glossaryPublication.js";
+const EXCLUDED_DIRECTORIES = new Set(confirmedVariantGuardContract().excludedDirectories);
+// Lowercased extensions classify ASCII path suffixes; they are not term identities.
+const TEXT_EXTENSIONS = new Set([
+    ".cjs", ".css", ".go", ".html", ".js", ".json", ".jsonc", ".jsx",
+    ".md", ".mjs", ".py", ".rs", ".sh", ".toml", ".ts", ".tsx", ".txt",
+    ".xml", ".yaml", ".yml",
+]);
+const RERUN = "pnpm -C packages/cli exec vitest run test/cli/v1LegacyCruft.test.ts";
+function fixedLegacyViolations(root) {
+    const violations = [];
+    if (fs.existsSync(path.join(root, "skills/hej")))
+        violations.push("skills/hej/ bridge directory present");
+    if (fs.existsSync(path.join(root, "references/v1-section-mapping.md"))) {
+        violations.push("references/v1-section-mapping.md present");
+    }
+    if (fs.existsSync(path.join(root, ".opencode/commands/hej.md"))) {
+        violations.push(".opencode/commands/hej.md legacy bridge command present");
+    }
+    const marketplacePath = path.join(root, ".claude-plugin/marketplace.json");
+    if (fs.existsSync(marketplacePath)) {
+        const marketplace = JSON.parse(fs.readFileSync(marketplacePath, "utf8"));
+        const names = (marketplace.plugins ?? []).map((item) => item.name);
+        if (names.includes("status"))
+            violations.push(".claude-plugin/marketplace.json still lists hej plugin");
+    }
+    const codexPath = path.join(root, ".codex-plugin/plugin.json");
+    if (fs.existsSync(codexPath)) {
+        const codex = JSON.parse(fs.readFileSync(codexPath, "utf8"));
+        const names = (codex.skillMetadata ?? []).map((item) => item.name);
+        if (names.includes("status"))
+            violations.push(".codex-plugin/plugin.json still lists hej skillMetadata");
+    }
+    const packageRegistryPath = path.join(root, "references/adapters/package-registry.yaml");
+    if (fs.existsSync(packageRegistryPath)) {
+        const registry = YAML.parse(fs.readFileSync(packageRegistryPath, "utf8"));
+        const versionFiles = registry.records?.[0]?.docs_targets?.version_files ?? [];
+        if (versionFiles.includes("skills/hej/SKILL.md")) {
+            violations.push("package-registry docs_targets still lists skills/hej/SKILL.md");
+        }
+    }
+    return violations;
+}
+function confirmedVariants(document) {
+    return document.approvals.flatMap((approval, index) => {
+        const entry = document.entries[index];
+        const canonical = String(entry.term);
+        // Project-glossary validation already rejects every canonical/variant
+        // identity collision. Preserve all validated variants for guard scanning.
+        return approval.proposal.variants
+            .map(({ term, evidence }) => ({
+            variant: term,
+            canonical,
+            approvalDigest: approval.proposal_digest,
+            evidence,
+        }));
+    });
+}
+function projectTextFiles(root) {
+    const files = [];
+    const visit = (directory) => {
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (entry.isSymbolicLink())
+                continue;
+            const target = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (!EXCLUDED_DIRECTORIES.has(entry.name))
+                    visit(target);
+            }
+            else if (entry.isFile() && TEXT_EXTENSIONS.has(path.extname(entry.name).toLocaleLowerCase())) {
+                files.push(target);
+            }
+        }
+    };
+    visit(root);
+    return files;
+}
+function lineDigest(line) {
+    return crypto.createHash("sha256").update(line).digest("hex");
+}
+function isApprovedEvidence(variant, sourcePath, line, text) {
+    const digest = lineDigest(text);
+    return variant.evidence.some((item) => item.source_path === sourcePath && item.line === line && item.source_record_sha256 === digest);
+}
+function variantViolations(root, document, glossaryPath) {
+    const violations = [];
+    const seen = new Set();
+    for (const file of projectTextFiles(root)) {
+        if (path.resolve(file) === path.resolve(glossaryPath))
+            continue;
+        const sourcePath = path.relative(root, file).split(path.sep).join(path.posix.sep);
+        const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+        for (const variant of confirmedVariants(document)) {
+            for (const [index, text] of lines.entries()) {
+                const line = index + 1;
+                if (!containsGlossaryTerm(text, variant.variant) || isApprovedEvidence(variant, sourcePath, line, text))
+                    continue;
+                const identity = `${variant.approvalDigest}\0${variant.variant}\0${sourcePath}\0${line}`;
+                if (seen.has(identity))
+                    continue;
+                seen.add(identity);
+                const evidence = variant.evidence.map((item) => `${item.source_path}:${item.line}`).join(", ");
+                violations.push(`confirmed variant '${variant.variant}' reintroduced at ${sourcePath}:${line}; canonical term '${variant.canonical}' ` +
+                    `from approval ${variant.approvalDigest} (confirmed variant evidence: ${evidence}). ` +
+                    `Correction: replace '${variant.variant}' with '${variant.canonical}' at ${sourcePath}:${line}; rerun: ${RERUN}`);
+            }
+        }
+    }
+    return violations.sort();
+}
+export function scanPost30CruftViolations(root) {
+    const resolved = resolvePath(root);
+    const violations = fixedLegacyViolations(resolved);
+    try {
+        const loaded = loadProjectGlossaryDocument(resolved);
+        if (loaded)
+            violations.push(...variantViolations(resolved, loaded.document, loaded.path));
+    }
+    catch (error) {
+        violations.push(`project glossary is malformed: ${error.message}. ` +
+            `Correction: restore a valid confirmed document or rerun agentera state glossary publish --input REQUEST.yaml --format json; rerun: ${RERUN}`);
+    }
+    return violations.sort();
+}

package/dist/validate/vocabularyAuthority.js

@@ -4,6 +4,12 @@ import { resolvePath } from "../core/paths.js";
 import { resolveSourceRoot } from "../core/sourceRoot.js";
 import { loadYamlMappingFile } from "../core/yaml.js";
 import { APP_MANUAL_REVIEW_NEEDED, APP_MIGRATION_NEEDED, APP_OUTDATED, APP_REPAIR_NEEDED, APP_UP_TO_DATE, } from "../upgrade/doctor.js";
+import { validateGlossaryEntryContract } from "../registries/glossaryEntryContract.js";
+/**
+ * Validate vocabulary authority YAML contracts (Decision 54 lifecycle status
+ * vocabulary, Decision 57 first_invocation_read, update channels, index order).
+ * Emits the same delegated validate envelope shape as lifecycle-adapters.
+ */
 const EXPECTED_STATUSES = [
     "up_to_date",
     "outdated",
@@ -15,7 +21,7 @@ const EXPECTED_STATUSES = [
     "no_changes_needed",
 ];
 const EXPECTED_VERBS = ["install", "repair", "update", "migrate", "upgrade", "refresh"];
-const EXPECTED_LIFECYCLE_CONSUMERS = ["doctor", "hej", "upgrade", "docs", "tests"];
+const EXPECTED_LIFECYCLE_CONSUMERS = ["doctor", "status", "upgrade", "docs", "tests"];
 const EXPECTED_CHANNELS = ["stable", "development"];
 const EXPECTED_CHANNEL_CONSUMERS = ["upgrade", "doctor", "prime", "docs", "tests"];
 function rootDefault() {
@@ -44,7 +50,7 @@ function validateLifecycleAuthority(root) {
     const p = authorityPath(root, "references/cli/app-lifecycle-vocabulary.yaml");
     let authority;
     try {
-        authority = loadYamlMappingFile(p);
+        authority = loadYamlMappingFile(p); // cast: YAML parse IO boundary
     }
     catch (exc) {
         return [`app-lifecycle-vocabulary.yaml: ${exc.message}`];
@@ -143,7 +149,7 @@ function validateUpdateChannelsAuthority(root) {
     const p = authorityPath(root, "references/cli/update-channels.yaml");
     let authority;
     try {
-        authority = loadYamlMappingFile(p);
+        authority = loadYamlMappingFile(p); // cast: YAML parse IO boundary
     }
     catch (exc) {
         return [`update-channels.yaml: ${exc.message}`];
@@ -197,7 +203,7 @@ function validateInstructionContract(root) {
     const p = authorityPath(root, "references/cli/capability-instruction-contract.yaml");
     let authority;
     try {
-        authority = loadYamlMappingFile(p);
+        authority = loadYamlMappingFile(p); // cast: YAML parse IO boundary
     }
     catch (exc) {
         return [`capability-instruction-contract.yaml: ${exc.message}`];
@@ -213,8 +219,8 @@ function validateInstructionContract(root) {
     }
     else {
         const meaning = String(allowed.prime_context.meaning ?? "");
-        if (!meaning.includes("agentera prime --context")) {
-            errors.push("capability-instruction-contract.yaml: prime_context obligation must reference agentera prime --context");
+        if (!meaning.includes("npx -y agentera@next prime --context")) {
+            errors.push("capability-instruction-contract.yaml: prime_context obligation must reference npx -y agentera@next prime --context");
         }
     }
     if (firstRead.default_rule !== "prime_context") {
@@ -237,7 +243,7 @@ function validateVocabularyIndex(root) {
     const p = authorityPath(root, "references/cli/vocabulary-index.yaml");
     let index;
     try {
-        index = loadYamlMappingFile(p);
+        index = loadYamlMappingFile(p); // cast: YAML parse IO boundary
     }
     catch (exc) {
         return [`vocabulary-index.yaml: ${exc.message}`];
@@ -248,12 +254,11 @@ function validateVocabularyIndex(root) {
     }
     const lifecycleIdx = order.indexOf("references/cli/app-lifecycle-vocabulary.yaml");
     const channelsIdx = order.indexOf("references/cli/update-channels.yaml");
-    const bundleIdx = order.indexOf("references/cli/bundle-skill-vocabulary.yaml");
-    if (lifecycleIdx < 0 || channelsIdx < 0 || bundleIdx < 0) {
+    if (lifecycleIdx < 0 || channelsIdx < 0) {
         errors.push("vocabulary-index.yaml: authority_order missing required vocabulary authorities");
     }
-    else if (!(lifecycleIdx < channelsIdx && channelsIdx < bundleIdx)) {
-        errors.push("vocabulary-index.yaml: authority_order must place lifecycle before channels before bundle");
+    else if (!(lifecycleIdx < channelsIdx)) {
+        errors.push("vocabulary-index.yaml: authority_order must place lifecycle before channels");
     }
     const vocabularyMd = authorityPath(root, "references/cli/vocabulary.md");
     if (!fs.existsSync(vocabularyMd)) {
@@ -266,7 +271,7 @@ function validateVocabularyIndex(root) {
         !lifecycleSection.includes("machine-readable authority")) {
         errors.push("references/cli/vocabulary.md: app lifecycle section must delegate to YAML authority");
     }
-    const channelsSection = vocabulary.split("### Update channels")[1]?.split("### Bundle and SKILL.md vocabulary", 1)[0] ?? "";
+    const channelsSection = vocabulary.split("### Update channels")[1]?.split("## Evaluation and evidence grammar", 1)[0] ?? "";
     if (!channelsSection.includes("references/cli/update-channels.yaml") ||
         !channelsSection.includes("machine-readable authority")) {
         errors.push("references/cli/vocabulary.md: update channels section must delegate to YAML authority");
@@ -280,6 +285,7 @@ export function validateVocabularyAuthority(root = rootDefault()) {
         ...validateUpdateChannelsAuthority(resolved),
         ...validateInstructionContract(resolved),
         ...validateVocabularyIndex(resolved),
+        ...validateGlossaryEntryContract(authorityPath(resolved, "references/artifacts/glossary-entry-contract.yaml")),
     ];
 }
 export function vocabularyAuthorityMain(opts = {}) {
@@ -295,4 +301,3 @@ export function vocabularyAuthorityMain(opts = {}) {
     out("vocabulary authority ok");
     return 0;
 }
-//# sourceMappingURL=vocabularyAuthority.js.map

package/package.json

@@ -1,24 +1,20 @@
 {
   "name": "agentera",
-  "version": "3.0.0-dev.6",
-  "description": "Agentera app-home protocol and CLI (TypeScript)",
-  "type": "module",
-  "license": "Apache-2.0",
-  "author": "Jonathan Gabor",
-  "homepage": "https://github.com/jgabor/agentera",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jgabor/agentera.git",
-    "directory": "packages/cli"
-  },
+  "version": "3.0.0-dev.69",
+  "description": "One CLI, many capabilities: project state, artifact validation, and capability routing for AI coding agents",
   "keywords": [
     "agentera",
     "agents",
     "cli",
     "orchestration"
   ],
-  "engines": {
-    "node": ">=22"
+  "homepage": "https://github.com/jgabor/agentera",
+  "license": "Apache-2.0",
+  "author": "Jonathan Gabor",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jgabor/agentera.git",
+    "directory": "packages/cli"
   },
   "bin": {
     "agentera": "dist/bin/agentera.js"
@@ -27,30 +23,65 @@
     "dist",
     "bundle"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "prepack": "tsc -p tsconfig.json && node scripts/copy-bundle.mjs",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "bundle:data": "node scripts/copy-bundle.mjs",
-    "publish:dev": "set -a; [ -f ../../.env ] && . ../../.env; set +a; npm run build && npm run bundle:data && npm publish --tag next"
-  },
-  "agentera": {
-    "suiteVersion": "3.0.0",
-    "gitRef": "2521c7a8f4d33a52c0198944b5cac4bf1e58f0b7"
-  },
+  "type": "module",
   "publishConfig": {
     "access": "public",
     "tag": "next"
   },
+  "scripts": {
+    "build": "node scripts/build-package.mjs",
+    "prepack": "node scripts/reject-direct-prepack.mjs",
+    "test": "pnpm run test:source",
+    "test:source": "node scripts/verify-lane.mjs source",
+    "test:stress": "node scripts/verify-lane.mjs stress",
+    "test:performance": "node scripts/verify-lane.mjs performance",
+    "test:performance:integration": "node test/integration/performanceOwner.integration.mjs",
+    "test:capacity": "node scripts/verify-lane.mjs capacity",
+    "test:watch": "vp test watch --config vite.config.ts",
+    "verify:package": "node scripts/verify-lane.mjs package",
+    "verify:generated-overlap": "node scripts/verify-generated-overlap.mjs",
+    "generated:cleanup": "node scripts/build-package.mjs --cleanup",
+    "pack:dry-run": "node scripts/pack-package.mjs --dry-run",
+    "release:prepare": "node scripts/publication-transaction.mjs prepare development",
+    "release:prepare:push": "node scripts/publication-transaction.mjs prepare-push development",
+    "release:validate:push": "node scripts/publication-transaction.mjs validate-push development",
+    "release:qualify:source": "node scripts/release-qualification.mjs source",
+    "release:ready": "node scripts/release-readiness.mjs development",
+    "release:qualify:candidate": "node scripts/release-qualification.mjs candidate --adapter development",
+    "release:approve": "node scripts/release-qualification.mjs approval --adapter development",
+    "release:attest": "node scripts/release-qualification.mjs attest --adapter development",
+    "release:benchmark:qualification": "node scripts/release-benchmark.mjs qualification",
+    "release:publish:qualified": "node scripts/release-benchmark.mjs publication --adapter development",
+    "release:stage": "node scripts/publication-transaction.mjs stage development --approve",
+    "release:promote": "node scripts/publication-transaction.mjs promote development --approve",
+    "verify:targeted": "node scripts/verify-lane.mjs policy targeted",
+    "verify:precommit": "node scripts/verify-lane.mjs policy precommit",
+    "verify:fast": "node scripts/verify-lane.mjs policy fast",
+    "verify:local": "node scripts/verify-lane.mjs policy local",
+    "verify:merge": "node scripts/verify-lane.mjs policy merge",
+    "verify:scheduled": "node scripts/verify-lane.mjs policy scheduled",
+    "verify:release": "node scripts/release-qualification.mjs verify --json",
+    "lint": "vp lint",
+    "fmt": "vp fmt",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "bundle:data": "node scripts/build-package.mjs"
+  },
   "dependencies": {
-    "smol-toml": "^1.3.1",
+    "smol-toml": "^1.7.1",
     "yaml": "^2.8.3"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "@typescript/typescript6": "6.0.2",
+    "typescript": "^7.0.2",
+    "vite": "^8.2.1",
+    "vite-plus": "^0.2.8"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "agentera": {
+    "suiteVersion": "3.0.0",
+    "gitRef": "cb8746e8eaec765d3b7a0a82cc561656caca33e9"
   }
 }