akm-cli 0.9.30 → 0.10.261001-beta

package/dist/commands/improve/retrieval-gate.js

@@ -1,132 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * The retrieval regression gate (#722): a reflect rewrite of an existing asset
- * must not grade lower on the queries that actually retrieved it.
- *
- * Measured before it was built: of 60 accepted reflect rewrites judged against
- * their own queries, 14 graded lower (23%, 95% CI 14–35%) and 12 higher. The
- * old and new content are graded one query at a time, blind, with the
- * retrieval-eval judge's prompt (kappa 0.83 against human grades) and its
- * document shape: type, ref, name, description and the first 1,500 characters
- * of the body.
- */
-import relevanceJudgePrompt from "../../assets/prompts/retrieval-relevance-judge.md" with { type: "text" };
-import { parseFrontmatter } from "../../core/asset/frontmatter.js";
-import { parseRefInput } from "../../core/asset/resolve-ref.js";
-import { nonTaskInput } from "../../core/non-task-input.js";
-import { parseEmbeddedJsonResponse } from "../../core/parse.js";
-import { listRetrievalQueries } from "../../indexer/usage/usage-events.js";
-import { readLedgerDb, stripBundle } from "./ledger.js";
-import { callStage } from "./stage.js";
-/** Queries graded per rewrite, as measured. */
-const MAX_QUERIES = 5;
-/** The retrieval suite treats a longer input as a paste, not a query; the measurement did the same. */
-const MAX_QUERY_CHARS = 2000;
-/** The judge sees this much of the body, as in the retrieval eval. */
-const MAX_DOC_CHARS = 1500;
-export const GRADE_SCHEMA = {
-    type: "object",
-    required: ["grade", "reason"],
-    additionalProperties: false,
-    properties: { grade: { type: "integer", minimum: 0, maximum: 3 }, reason: { type: "string" } },
-};
-function parseGrade(raw) {
-    const grade = parseEmbeddedJsonResponse(raw)?.grade;
-    return typeof grade === "number" && Number.isInteger(grade) && grade >= 0 && grade <= 3 ? grade : undefined;
-}
-/** Up to five distinct task queries, in the given order, whitespace collapsed. */
-export function usableRetrievalQueries(raw) {
-    const out = [];
-    for (const text of raw) {
-        const query = text.replace(/\s+/g, " ").trim();
-        if (!query || query.length > MAX_QUERY_CHARS || nonTaskInput(query) || out.includes(query))
-            continue;
-        out.push(query);
-        if (out.length === MAX_QUERIES)
-            break;
-    }
-    return out;
-}
-/** The asset's own retrieval queries from the usage log (none when state.db cannot be read). */
-export function loadRetrievalQueries(access, ref) {
-    try {
-        return usableRetrievalQueries(readLedgerDb(access, (db) => listRetrievalQueries(db, stripBundle(ref))) ?? []);
-    }
-    catch {
-        return [];
-    }
-}
-function judgeDocument(ref, raw) {
-    const conceptId = stripBundle(ref);
-    const parsed = parseRefInput(conceptId);
-    const { data, content } = parseFrontmatter(raw);
-    const text = content
-        .replace(/\n{3,}/g, "\n\n")
-        .trim()
-        .slice(0, MAX_DOC_CHARS);
-    const name = typeof data.name === "string" && data.name ? data.name : parsed.name;
-    const description = typeof data.description === "string" ? data.description : "";
-    return [
-        "Candidate asset:",
-        `Type: ${parsed.type}`,
-        `Ref: ${conceptId}`,
-        `Name: ${name}`,
-        `Description: ${description}`,
-        "",
-        "Content:",
-        text,
-    ].join("\n");
-}
-/**
- * Grade `before` and `after` on each query; refuse the rewrite when the new
- * content's mean grade is lower. Fails closed, like the quality judge: a grade
- * that cannot be obtained refuses the rewrite.
- */
-export async function runRetrievalRegressionGate(args) {
-    if (args.queries.length === 0)
-        return { pass: true, queries: 0, reason: "no retrieval queries to compare on" };
-    const documents = { old: judgeDocument(args.ref, args.before), new: judgeDocument(args.ref, args.after) };
-    const totals = { old: 0, new: 0 };
-    for (const query of args.queries) {
-        for (const version of ["old", "new"]) {
-            const outcome = await callStage({
-                feature: "proposal_quality_gate",
-                runner: args.runner,
-                system: relevanceJudgePrompt.trim(),
-                prompt: `Query: ${query}\n\n${documents[version]}`,
-                request: {
-                    enableThinking: false,
-                    temperature: 0,
-                    responseSchema: GRADE_SCHEMA,
-                    ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : {}),
-                    ...(args.signal ? { signal: args.signal } : {}),
-                    ...(args.chat ? { chat: args.chat } : {}),
-                },
-                parse: parseGrade,
-                ...(args.onNotices ? { onNotices: args.onNotices } : {}),
-            });
-            const grade = outcome.ok ? parseGrade(outcome.raw) : undefined;
-            if (grade === undefined) {
-                return {
-                    pass: false,
-                    queries: args.queries.length,
-                    reason: `retrieval check could not grade the ${version} content${outcome.ok ? "" : ` (${outcome.reason})`}`,
-                };
-            }
-            totals[version] += grade;
-        }
-    }
-    const oldMean = totals.old / args.queries.length;
-    const newMean = totals.new / args.queries.length;
-    const pass = newMean >= oldMean;
-    const grades = `${oldMean.toFixed(2)} -> ${newMean.toFixed(2)} over ${args.queries.length} retrieval ${args.queries.length === 1 ? "query" : "queries"}`;
-    return {
-        pass,
-        queries: args.queries.length,
-        oldMean,
-        newMean,
-        reason: pass ? `retrieval grade ${grades}` : `retrieval regression: grade ${grades}`,
-    };
-}

package/dist/commands/tasks/validate.js

@@ -1,176 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * `akm task validate <path>` (#907) — parse ONE task file by filesystem
- * path, not a concept ref/id, and report the same diagnostic `akm task
- * sync` would produce for it. The file need not live in any configured
- * bundle: unlike every other `akm task` subcommand, this one never resolves
- * a bundle/adapter/concept id at all — it reads exactly the path it was
- * given and classifies it.
- *
- * Reuses the exact version router `parseTaskSource`
- * (`src/tasks/source/parse-task-source.ts`) every other task-source reader
- * uses (`akm task sync`'s `compileTaskSources` included) — this module never
- * forks a second parser. `readBoundedTaskSourceYaml` /
- * `peekTaskSourceVersion` / `own` are the SAME front-end helpers the router
- * calls first; they are used here only to recover the file's DECLARED schema
- * version for the report and to tell `blocked` from `invalid`.
- *
- * Beyond parsing, this module also runs the SAME two per-source gates
- * `akm task sync`'s `compileTaskSources` runs before it ever installs a
- * schedule — `assertTaskScheduleInputsSatisfyContract` and
- * `assertTaskScheduleCronValid` (both extracted from `scheduler-sync.ts` for
- * exactly this reuse) — so a file `sync` would reject can never
- * be reported `valid` here. Cron dialect is checked against
- * `backendNameForPlatform()`, the same platform default `sync` falls back
- * to whenever it has no injected/native-inspected backend to hand (see
- * `akmTasksAdd`, `src/commands/tasks/tasks.ts`); a bare file was never
- * installed anywhere; there is no native scheduler state to inspect for it.
- *
- * Deliberately DOES NOT call `prepareTaskV3Execution` (the function
- * `compileTaskSources` calls between those two gates) or resolve an
- * execution engine: that path resolves a composed command/persona ref
- * against the local index and lowers the task's cascade-composed
- * engine/model — both of which assume a real, indexed bundle and a
- * configured engine. A bare file passed to `validate` has neither, so
- * running that step would make an otherwise-valid command-kind task report
- * `invalid` on any machine with no engine configured. `resolved`
- * is therefore the compiled task shape `sync` itself would build a
- * scheduler binding from — id, the compiled v4 `version`, `target`
- * (`uses`/`run`), the declared `inputs` contract, and `schedule` bindings —
- * never an execution-lowered plan.
- *
- * Outcome classification (mirrors `parse-task-source.ts`'s own routing
- * table in its header, extended for the two gates above):
- *   - `valid`       — parses as task source v4 and passes both sync gates.
- *   - `blocked`     — declared `version: 2` or `3`, or a `version: 4`
- *                      document still carrying the retired
- *                      `schedule[].enabled`: what `akm migrate apply`
- *                      rewrites. The runtime reads only v4 (#987), so the
- *                      reason names that command.
- *   - `invalid`     — the document declares SOME version (`4`, or anything
- *                      other than 2/3/4) but fails to parse/validate, OR it
- *                      parsed but fails one of the two sync gates above, OR
- *                      the YAML itself does not parse at all (a genuine
- *                      syntax error, not merely a non-task shape) — reported
- *                      with the parser's own reason.
- *   - `not-a-task`  — the document parses as YAML but never declares a
- *                      `version:` field at all (or isn't a YAML mapping) —
- *                      the strongest signal available that the file was
- *                      never intended as a task source in the first place.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { UsageError } from "../../core/errors.js";
-import { backendNameForPlatform } from "../../tasks/backends/index.js";
-import { assertTaskScheduleCronValid, assertTaskScheduleInputsSatisfyContract } from "../../tasks/scheduler-sync.js";
-import { own, readBoundedTaskSourceYaml } from "../../tasks/source/bounded-document.js";
-import { parseTaskSource, peekTaskSourceVersion, v4ScheduleHasRetiredEnabledKey, } from "../../tasks/source/parse-task-source.js";
-/** True when `root` is a YAML mapping that itself declares a `version:` key, regardless of that key's type/value. */
-function declaresVersionKey(root) {
-    return root !== null && typeof root === "object" && !Array.isArray(root) && own(root, "version");
-}
-function buildResolved(id, v4) {
-    return {
-        id,
-        version: v4.version,
-        ...(v4.name !== undefined ? { name: v4.name } : {}),
-        ...(v4.description !== undefined ? { description: v4.description } : {}),
-        target: v4.target,
-        inputs: v4.inputs ?? {},
-        schedule: v4.schedule,
-    };
-}
-export async function akmTaskValidate(filePath) {
-    const resolvedPath = path.resolve(filePath);
-    let stat;
-    try {
-        stat = fs.statSync(resolvedPath);
-    }
-    catch {
-        throw new UsageError(`Task file not found: ${JSON.stringify(filePath)}.`, "INVALID_FLAG_VALUE");
-    }
-    if (!stat.isFile()) {
-        throw new UsageError(`${JSON.stringify(filePath)} is not a regular file.`, "INVALID_FLAG_VALUE");
-    }
-    let yaml;
-    try {
-        yaml = fs.readFileSync(resolvedPath, "utf8");
-    }
-    catch (cause) {
-        throw new UsageError(`Task file ${JSON.stringify(filePath)} could not be read: ${cause instanceof Error ? cause.message : String(cause)}`, "INVALID_FLAG_VALUE");
-    }
-    // Peek the declared version BEFORE the real parse, using the identical
-    // bounded YAML front end `parseTaskSource` calls internally — never a
-    // second/looser YAML reader. A front-end failure here (unparseable YAML,
-    // not a mapping, exceeds a resource bound) means the document itself does
-    // not parse at all — tracked as `peekFailed` so that case reports
-    // `invalid`, never `not-a-task` (`not-a-task` is reserved for
-    // YAML that DOES parse but never declared a task shape). The real parse
-    // below throws the identical error either way, so nothing is lost by
-    // swallowing it here.
-    let root;
-    let peekFailed = false;
-    try {
-        root = readBoundedTaskSourceYaml({ yaml, filePath: resolvedPath }, { sourceLabel: "task source" }).root;
-    }
-    catch {
-        peekFailed = true;
-    }
-    const declaredVersion = peekFailed ? undefined : peekTaskSourceVersion(root);
-    const hasVersionKey = !peekFailed && declaresVersionKey(root);
-    const workspaceRoot = path.dirname(resolvedPath);
-    const backend = backendNameForPlatform();
-    let parsed;
-    try {
-        parsed = parseTaskSource({ yaml, filePath: resolvedPath, workspaceRoot });
-    }
-    catch (cause) {
-        if (!(cause instanceof UsageError))
-            throw cause;
-        const reason = cause.message;
-        // What `akm migrate apply` rewrites is the only refusal for these
-        // shapes (`parse-task-source.ts`), so no message-text sniffing is needed.
-        if (declaredVersion === 2 ||
-            declaredVersion === 3 ||
-            (declaredVersion === 4 && v4ScheduleHasRetiredEnabledKey(root))) {
-            return { ok: false, path: resolvedPath, sourceVersion: declaredVersion, outcome: "blocked", reason };
-        }
-        if (peekFailed) {
-            return { ok: false, path: resolvedPath, outcome: "invalid", reason };
-        }
-        if (!hasVersionKey) {
-            return { ok: false, path: resolvedPath, outcome: "not-a-task", reason };
-        }
-        return {
-            ok: false,
-            path: resolvedPath,
-            ...(declaredVersion !== undefined ? { sourceVersion: declaredVersion } : {}),
-            outcome: "invalid",
-            reason,
-        };
-    }
-    // Success is unreachable from any path that leaves `declaredVersion`
-    // undefined — the router requires a numeric version 4 to reach here.
-    const sourceVersion = declaredVersion ?? 4;
-    // The document itself parsed — now the two gates `compileTaskSources`
-    // runs before accepting it. A violation here is `invalid`.
-    try {
-        assertTaskScheduleInputsSatisfyContract(parsed.v4, resolvedPath);
-        assertTaskScheduleCronValid(parsed.v4, backend);
-    }
-    catch (cause) {
-        if (!(cause instanceof UsageError))
-            throw cause;
-        return { ok: false, path: resolvedPath, sourceVersion, outcome: "invalid", reason: cause.message };
-    }
-    const id = path.parse(resolvedPath).name;
-    return {
-        ok: true,
-        path: resolvedPath,
-        sourceVersion,
-        outcome: "valid",
-        resolved: buildResolved(id, parsed.v4),
-    };
-}

package/dist/core/config/legacy-source-shape-shim.js

@@ -1,117 +0,0 @@
-import path from "node:path";
-import { isBundleSlug } from "../asset/asset-ref.js";
-import { warnOnce } from "../warn.js";
-function isPlainRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-const DEFAULT_WRITABLE_BY_TYPE = {
-    filesystem: true,
-    git: false,
-    website: false,
-    npm: false,
-};
-function bundleFromLegacySource(entry, index) {
-    if (!isPlainRecord(entry))
-        return undefined;
-    const type = typeof entry.type === "string" ? entry.type : undefined;
-    const bundle = {};
-    switch (type) {
-        case "filesystem":
-            if (typeof entry.path !== "string" || !entry.path)
-                return undefined;
-            bundle.path = entry.path;
-            break;
-        case "git":
-            if (typeof entry.url !== "string" || !entry.url)
-                return undefined;
-            bundle.git = entry.url;
-            break;
-        case "website":
-            if (typeof entry.url !== "string" || !entry.url)
-                return undefined;
-            bundle.website = { url: entry.url };
-            break;
-        case "npm": {
-            const spec = typeof entry.url === "string" && entry.url ? entry.url : entry.path;
-            if (typeof spec !== "string" || !spec)
-                return undefined;
-            bundle.npm = spec;
-            break;
-        }
-        default:
-            return undefined;
-    }
-    const writable = typeof entry.writable === "boolean" ? entry.writable : DEFAULT_WRITABLE_BY_TYPE[type ?? ""];
-    if (writable !== undefined)
-        bundle.writable = writable;
-    if (typeof entry.enabled === "boolean")
-        bundle.enabled = entry.enabled;
-    const name = typeof entry.name === "string" ? entry.name : undefined;
-    const key = name && isBundleSlug(name) ? name : `source-${index + 1}`;
-    return [key, bundle];
-}
-function filesystemLocator(bundle) {
-    if (!isPlainRecord(bundle) || typeof bundle.path !== "string" || bundle.path.length === 0)
-        return undefined;
-    return path.resolve(bundle.path);
-}
-/**
- * Pure legacy `stashDir`/`sources[]`/`installed` -> `bundles`/`defaultBundle`
- * conversion. Triggers on key *presence* (not on the value being usable), so
- * an unusable value — `stashDir: ""`, `sources: []` — is still removed along
- * with the rest of the legacy shape; only a usable `stashDir` or `sources[]`
- * entry is actually folded into `bundles`. Never warns — see
- * {@link migrateLegacySourceShape} for the warn-once wrapper callers use.
- */
-export function convertLegacySourceShape(raw) {
-    const hasStashDir = "stashDir" in raw;
-    const hasSources = "sources" in raw;
-    const hasInstalled = "installed" in raw && raw.installed !== undefined;
-    if (!hasStashDir && !hasSources && !hasInstalled)
-        return { config: raw, converted: [] };
-    const { stashDir: _stashDir, sources: _sources, installed: _installed, ...rest } = raw;
-    const bundles = isPlainRecord(rest.bundles) ? { ...rest.bundles } : {};
-    let defaultBundle = typeof rest.defaultBundle === "string" ? rest.defaultBundle : undefined;
-    const usableStashDir = typeof raw.stashDir === "string" && raw.stashDir.trim().length > 0;
-    if (usableStashDir) {
-        bundles.stash = { path: raw.stashDir, writable: true };
-        defaultBundle ??= "stash";
-    }
-    if (Array.isArray(raw.sources)) {
-        raw.sources.forEach((entry, index) => {
-            const converted = bundleFromLegacySource(entry, index);
-            if (!converted)
-                return;
-            const [key, bundle] = converted;
-            const locator = filesystemLocator(bundle);
-            if (locator && Object.values(bundles).some((candidate) => filesystemLocator(candidate) === locator))
-                return;
-            bundles[key] = bundle;
-            defaultBundle ??= key;
-        });
-    }
-    const converted = [hasStashDir && "stashDir", hasSources && "sources", hasInstalled && "installed"].filter((key) => typeof key === "string");
-    // Only add a `bundles` key when there is something to say: either a
-    // legacy entry actually converted into one, or the config already had a
-    // `bundles` map (preserved as-is). An unusable `stashDir: ""` / `sources: []`
-    // with no pre-existing `bundles` should just disappear, not leave behind
-    // an empty `bundles: {}`.
-    const hasBundles = Object.keys(bundles).length > 0 || isPlainRecord(rest.bundles);
-    return {
-        config: { ...rest, ...(hasBundles ? { bundles } : {}), ...(defaultBundle !== undefined ? { defaultBundle } : {}) },
-        converted,
-    };
-}
-/**
- * Warn-once wrapper around {@link convertLegacySourceShape} for the
- * in-memory read path: converts the legacy shape and, when it removed
- * anything, warns once that `akm migrate apply` will persist the rewrite.
- */
-export function migrateLegacySourceShape(raw, sourcePath) {
-    const { config, converted } = convertLegacySourceShape(raw);
-    if (converted.length === 0)
-        return config;
-    const where = sourcePath ? ` at ${sourcePath}` : "";
-    warnOnce(`legacy-source-shape${sourcePath ? `:${sourcePath}` : ""}`, `Config${where} uses the retired ${converted.join("/")} shape — auto-migrated in memory to \`bundles\`/\`defaultBundle\`. Run \`akm migrate apply\` to rewrite the config file and silence this warning.`);
-    return config;
-}

package/dist/indexer/feedback/utility-policy.js

@@ -1,75 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * MemRL feedback → utility policy, extracted from indexer/db/db.ts.
- *
- * This is the domain/policy math (arXiv:2601.03192) that decides how a batch of
- * positive/negative feedback signals moves an asset's utility score. It is pure
- * — no database access — so the bounded-step behaviour is unit-testable in
- * isolation; the DB read/write stays with `applyFeedbackToUtilityScore` in db.ts.
- */
-/**
- * MemRL learning rate for feedback-driven utility updates (F-5 / #386).
- *
- * Follows the bounded-step formula from MemRL (arXiv:2601.03192):
- *   next = clamp(current + lr × (reward − current), 0, 1)
- *
- * This replaces the unbounded `-0.03 × negativeCount` delta that could
- * silently remove high-utility assets from the improvement loop.
- */
-export const FEEDBACK_LR = 0.1;
-/**
- * Positive reward signal for a single positive feedback event.
- * Reward 1.0 means "fully correct / helpful".
- */
-const FEEDBACK_REWARD_POSITIVE = 1.0;
-/**
- * Negative reward signal for a single negative feedback event.
- * Reward 0.0 means "not helpful" (lowest MemRL signal).
- */
-const FEEDBACK_REWARD_NEGATIVE = 0.0;
-/**
- * Utility threshold below which a review-needed escalation is triggered.
- * When a previously high-utility asset (≥ HIGH_UTILITY_THRESHOLD) drops
- * below this value, the caller should create an escalation proposal.
- */
-export const UTILITY_REVIEW_THRESHOLD = 0.5;
-/**
- * Utility level considered "high" — assets above this are tracked for
- * threshold-crossing escalation.
- */
-export const HIGH_UTILITY_THRESHOLD = 0.5;
-/**
- * Compute the next utility from accumulated feedback counts using the MemRL
- * bounded-step EMA formula (F-5 / #386, arXiv:2601.03192):
- *
- *   reward   = weighted average of positive and negative signals
- *   nextUtil = clamp(currentUtil + lr × (reward − currentUtil), 0, 1)
- *
- * The step is inherently bounded: reward ∈ [0, 1] and currentUtil ∈ [0, 1], so
- * a single call moves utility by at most {@link FEEDBACK_LR} in either
- * direction. `reward` is a proportion of the counts, not their magnitude, so
- * with no positive signals the number of negatives is irrelevant (reward is 0
- * whether there is 1 negative or 100). Mixing in positives shifts reward and so
- * the step, but never past the learning-rate bound.
- *
- * Pure: no DB access. When both counts are zero, utility is unchanged.
- */
-export function computeNextUtility(previousUtility, positiveCount, negativeCount) {
-    if (positiveCount === 0 && negativeCount === 0) {
-        return { previousUtility, nextUtility: previousUtility, crossedReviewThreshold: false };
-    }
-    const total = positiveCount + negativeCount;
-    // Weighted reward: proportion of positive signals.
-    const reward = positiveCount > 0 && negativeCount === 0
-        ? FEEDBACK_REWARD_POSITIVE
-        : negativeCount > 0 && positiveCount === 0
-            ? FEEDBACK_REWARD_NEGATIVE
-            : (positiveCount * FEEDBACK_REWARD_POSITIVE + negativeCount * FEEDBACK_REWARD_NEGATIVE) / total;
-    // MemRL bounded-step EMA: lr × (reward − current). |delta| ≤ FEEDBACK_LR.
-    const delta = FEEDBACK_LR * (reward - previousUtility);
-    const nextUtility = Math.max(0, Math.min(1, previousUtility + delta));
-    const crossedReviewThreshold = previousUtility >= HIGH_UTILITY_THRESHOLD && nextUtility < UTILITY_REVIEW_THRESHOLD;
-    return { previousUtility, nextUtility, crossedReviewThreshold };
-}

package/dist/integrations/harnesses/ids.js

@@ -1,28 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-export const HARNESS_ID_TABLE = [
-    { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true, nativeAgentSelector: true },
-    { id: "claude", agentDispatch: true, enforcesModelWorkTools: true, nativeAgentSelector: true },
-    { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true, nativeAgentSelector: true },
-    { id: "codex", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "pi", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "aider", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-    { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false, nativeAgentSelector: false },
-];
-/**
- * Canonical, ordered list of valid harness / platform ids — the
- * dependency-free counterpart of `./index.ts`'s `VALID_HARNESS_IDS` (which
- * remains the barrel's own derivation for its own consumers). Both are
- * asserted equal at `HARNESS_REGISTRY` construction time.
- */
-export const VALID_HARNESS_IDS = Object.freeze(HARNESS_ID_TABLE.map((h) => h.id));
-/** Harness ids whose `capabilities.agentDispatch` is `true`. */
-export const HARNESS_AGENT_DISPATCH_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.agentDispatch).map((h) => h.id));
-/** Harness ids that confine the model-work tool policy, so unattended model work may run on them. */
-export const HARNESS_MODEL_WORK_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.enforcesModelWorkTools).map((h) => h.id));
-/** Harness ids that can run a named native agent, so an engine may name a default `agent`. */
-export const HARNESS_NATIVE_AGENT_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.nativeAgentSelector).map((h) => h.id));