akm-cli 0.9.23 → 0.9.25-alpha.1

package/dist/integrations/agent/model-map.js

@@ -220,32 +220,33 @@ function mergeProfiles(base, overlay) {
  * copied verbatim from the engine's own config value; it must already be
  * meaningful for the model-map column's platform (akm does not translate
  * between an engine's connection and an agent platform's own provider
- * registry). Only `kind: "llm"` engines contribute inference defaults — an
- * agent-kind engine's schema carries no temperature/thinking fields.
+ * registry). An agent-kind engine contributes only the inference fields its
+ * platform translates (config validation rejects the rest); an `llm` engine
+ * also contributes `supportsJsonSchema` and `extraParams`.
  */
 export function engineModelAndInference(engine) {
     const out = {};
     if (Object.hasOwn(engine, "model") && engine.model !== undefined)
         out.model = engine.model;
+    const inference = {};
+    if (Object.hasOwn(engine, "temperature"))
+        inference.temperature = engine.temperature;
+    if (Object.hasOwn(engine, "maxTokens"))
+        inference.maxTokens = engine.maxTokens;
     if (engine.kind === "llm") {
-        const inference = {};
-        if (Object.hasOwn(engine, "temperature"))
-            inference.temperature = engine.temperature;
-        if (Object.hasOwn(engine, "maxTokens"))
-            inference.maxTokens = engine.maxTokens;
         if (Object.hasOwn(engine, "supportsJsonSchema"))
             inference.supportsJsonSchema = engine.supportsJsonSchema;
         if (Object.hasOwn(engine, "extraParams"))
             inference.extraParams = engine.extraParams;
-        if (Object.hasOwn(engine, "contextLength"))
-            inference.contextLength = engine.contextLength;
-        if (Object.hasOwn(engine, "enableThinking"))
-            inference.enableThinking = engine.enableThinking;
-        if (Object.hasOwn(engine, "reasoningEffort"))
-            inference.reasoningEffort = engine.reasoningEffort;
-        if (Object.keys(inference).length > 0)
-            out.inference = inference;
     }
+    if (Object.hasOwn(engine, "contextLength"))
+        inference.contextLength = engine.contextLength;
+    if (Object.hasOwn(engine, "enableThinking"))
+        inference.enableThinking = engine.enableThinking;
+    if (Object.hasOwn(engine, "reasoningEffort"))
+        inference.reasoningEffort = engine.reasoningEffort;
+    if (Object.keys(inference).length > 0)
+        out.inference = inference;
     return Object.freeze(out);
 }
 /** Overlay user fields over installed fields, per (alias, column), without resolving `engine` indirection. */

package/dist/integrations/agent/prompts.js

@@ -4,15 +4,14 @@
 /**
  * Shared prompt builders for proposal-producing agent commands (#226).
  *
- * `akm reflect` and `akm propose` both shell out to the configured agent CLI
- * (via {@link runAgent}) and ask it for a structured proposal payload. The
- * prompts are intentionally similar and share their construction here. Agent
- * and SDK stdout keeps the JSON/file-write contracts; direct LLM reflect adds
- * native-schema and framed-markdown contracts. Keeping the prompt builders in
- * `src/integrations/agent/` rather than `src/llm/` is deliberate: these are
- * shell-out prompts targeting an agent CLI, not in-tree LLM API calls.
+ * `akm reflect` and `akm proposal new` both ask the configured engine for a
+ * structured proposal payload. The prompts are intentionally similar and share
+ * their construction here. `proposal new` asks every engine kind for the JSON
+ * object below, with {@link PROPOSAL_JSON_SCHEMA} as the request's output
+ * schema. Reflect asks every engine kind for its own contract, JSON Schema or
+ * framed markdown ({@link ReflectOutputMode}).
  *
- * The stdout output an agent must produce is a strict JSON object:
+ * The output an engine must produce for `proposal new` is a strict JSON object:
  *
  * ```json
  * {
@@ -32,6 +31,7 @@ import reflectOutputRepair from "../../assets/prompts/reflect-output-repair.md"
 import { placementTypes } from "../../core/asset/asset-placement.js";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { authoringRulesForType, DESCRIPTION_MAX_CHARS, DESCRIPTION_MIN_CHARS, requiresDescription, } from "../../core/authoring-rules.js";
+import { isRecord } from "../../core/common.js";
 import { parseEmbeddedJsonResponse, stripCodeFences, stripThinkBlocks } from "../../core/parse.js";
 /**
  * Per-asset-type frontmatter / authoring hints surfaced in the prompt so
@@ -77,10 +77,9 @@ export const REFLECT_CONTENT_CAP = 12_000;
  */
 export const REFLECT_TRUNCATION_MARKER = "... [truncated — focus on the visible portion]";
 /**
- * Common envelope every prompt asks the agent to honour when NO draft file
- * path is available. The wrapper code uses `JSON.parse(stdout)` to extract
- * the payload — anything outside the JSON object will be treated as a parse
- * error.
+ * The JSON envelope `proposal new` asks the engine to honour. The wrapper code
+ * uses `JSON.parse(stdout)` to extract the payload — anything outside the JSON
+ * object will be treated as a parse error.
  */
 const RESPONSE_CONTRACT_JSON = [
     "Respond ONLY with a single JSON object. No prose before or after.",
@@ -98,48 +97,25 @@ const RESPONSE_CONTRACT_JSON = [
     "Reviewers and the triage judge read this score when adjudicating the proposal queue. Overclaiming erodes trust in your proposals; underclaiming buries good ones. Be honest.",
 ].join("\n");
 /**
- * Response contract used when a draft file path is available. Instructs the
- * agent to write the improved asset content directly to the file using its
- * native file-editing tools — no stdout JSON parsing required.
+ * The JSON Schema of {@link RESPONSE_CONTRACT_JSON}'s object, the output
+ * schema `proposal new` sends with its request: an LLM engine gets it as
+ * `response_format`, codex as `--output-schema`, every agent engine as the
+ * shared schema instruction. It is in the strict form those native channels
+ * accept (every property required, no others), so it leaves out the optional
+ * `frontmatter`, which `content` already carries. The reply is held only to
+ * what {@link validateProposalPayload} needs.
  */
-function fileWriteContract(draftFilePath) {
-    return [
-        `Write the complete improved asset content to: ${draftFilePath}`,
-        "Use your file-editing tools to create or overwrite that file.",
-        "Do NOT output JSON to stdout. Do NOT print the file contents. Just write the file.",
-        `Never include the text "${REFLECT_TRUNCATION_MARKER}" or any other content from outside the provided asset content in the file you write.`,
-        "When done, output a single line on stdout: DRAFT_WRITTEN confidence=<0.0-1.0>",
-        "`confidence` is REQUIRED and must be your honest self-rated [0, 1] score for this proposal:",
-        "  • 0.90+ — fixes a real defect or adds load-bearing missing content; reviewer would clearly accept.",
-        "  • 0.70–0.89 — clear improvement, but a reviewer might prefer different framing.",
-        "  • 0.50–0.69 — marginal / judgment call.",
-        "  • Below 0.50 — not confident; prefer not writing changes at all.",
-        "Reviewers and the triage judge read this score during adjudication. Overclaim → trust erodes; underclaim → good changes buried.",
-    ].join("\n");
-}
-/**
- * Extract a confidence score from a `DRAFT_WRITTEN confidence=<n>` line emitted
- * by an agent following {@link fileWriteContract}. Tolerates trailing prose,
- * surrounding log lines, and missing/invalid confidence (returns `undefined`
- * so callers can keep the proposal without a score).
- *
- * Matched forms (case-insensitive, anywhere in stdout):
- *   - `DRAFT_WRITTEN confidence=0.85`
- *   - `DRAFT_WRITTEN confidence=0.85 ...trailing`
- *   - `DRAFT_WRITTEN` (no confidence — returns `undefined`)
- */
-export function extractDraftConfidence(stdout) {
-    if (!stdout)
-        return undefined;
-    const match = stdout.match(/\bDRAFT_WRITTEN\b[^\S\r\n]+confidence=([0-9]*\.?[0-9]+)/i);
-    if (!match)
-        return undefined;
-    const value = Number.parseFloat(match[1] ?? "");
-    if (!Number.isFinite(value) || value < 0 || value > 1)
-        return undefined;
-    return value;
-}
-export function reflectLlmResponseContract(mode, targetScoped) {
+export const PROPOSAL_JSON_SCHEMA = {
+    type: "object",
+    required: ["ref", "content", "confidence"],
+    additionalProperties: false,
+    properties: {
+        ref: { type: "string", description: "The new asset's ref as a subdir-qualified conceptId." },
+        content: { type: "string", description: "The full file contents that will be written if accepted." },
+        confidence: { type: "number", minimum: 0, maximum: 1, description: "Self-rated confidence in [0, 1]." },
+    },
+};
+export function reflectResponseContract(mode, targetScoped) {
     if (mode === "json_schema") {
         return reflectLlmSchemaContract
             .replace("{{FIELD_RULE}}", targetScoped
@@ -155,14 +131,7 @@ export function reflectLlmResponseContract(mode, targetScoped) {
         .trim();
 }
 export function buildReflectOutputRepairPrompt(mode, targetScoped) {
-    return reflectOutputRepair.replace("{{OUTPUT_CONTRACT}}", reflectLlmResponseContract(mode, targetScoped)).trim();
-}
-function reflectResponseContract(input) {
-    if (input.draftFilePath)
-        return fileWriteContract(input.draftFilePath);
-    if (input.outputMode)
-        return reflectLlmResponseContract(input.outputMode, input.ref !== undefined);
-    return RESPONSE_CONTRACT_JSON;
+    return reflectOutputRepair.replace("{{OUTPUT_CONTRACT}}", reflectResponseContract(mode, targetScoped)).trim();
 }
 /**
  * Whether the source asset content has a non-empty `description:` key in its
@@ -386,17 +355,13 @@ export function buildReflectPrompt(input) {
             "5. Improve clarity of surrounding prose, fix structural issues, add missing required frontmatter fields. Do NOT rewrite a runbook into an essay.",
         ].join("\n"));
     }
-    if (!input.draftFilePath && !input.outputMode && input.ref) {
-        // Reinforce that the `ref` field is mandatory and must exactly match the target.
-        // Small models frequently omit `ref` from the response JSON, causing parse errors.
-        sections.push(`IMPORTANT: The JSON "ref" field is REQUIRED. It MUST be exactly: "${input.ref}"`);
-    }
-    sections.push(reflectResponseContract(input));
+    sections.push(reflectResponseContract(input.outputMode ?? "json_schema", input.ref !== undefined));
     return { prompt: sections.join("\n\n") };
 }
 /**
- * Build the prompt for `akm propose <type> <name> --task ...`. Asks the
- * agent to author a brand-new asset of the given type fulfilling `task`.
+ * Build the prompt for `akm proposal new <type> <name> --task ...`. Asks the
+ * engine to author a brand-new asset of the given type fulfilling `task`, and
+ * to return it as the JSON object of {@link RESPONSE_CONTRACT_JSON}.
  */
 export function buildProposePrompt(input) {
     const sections = [];
@@ -420,7 +385,7 @@ export function buildProposePrompt(input) {
         }
     }
     sections.push("Produce a single proposal that, if accepted, would land as the asset described above.");
-    sections.push(input.draftFilePath ? fileWriteContract(input.draftFilePath) : RESPONSE_CONTRACT_JSON);
+    sections.push(RESPONSE_CONTRACT_JSON);
     return sections.join("\n\n");
 }
 /**
@@ -457,7 +422,7 @@ export function buildSchemaRepairPrompt(input) {
         "If `description` is missing, generate a concise one-sentence description from the content. " +
         "If `when_to_use` is missing, generate a one-line trigger sentence. " +
         "Preserve all existing frontmatter keys and the full body verbatim.");
-    sections.push(input.draftFilePath ? fileWriteContract(input.draftFilePath) : RESPONSE_CONTRACT_JSON);
+    sections.push(RESPONSE_CONTRACT_JSON);
     return sections.join("\n\n");
 }
 /**
@@ -487,19 +452,31 @@ export function parseAgentProposalPayload(stdout) {
             throw directErr;
         parsed = embedded;
     }
+    const verdict = validateProposalPayload(parsed);
+    if (!verdict.ok)
+        throw new Error(verdict.errors.join("; "));
+    return verdict.value;
+}
+/**
+ * The proposal in a parsed reply, or why the reply is not one: `ref` and
+ * `content` must be non-empty strings. A malformed optional field is dropped,
+ * never refused.
+ */
+export function validateProposalPayload(parsed) {
+    if (!isRecord(parsed))
+        return { ok: false, errors: ["agent response is not a JSON object"] };
     if (typeof parsed.ref !== "string" || !parsed.ref.trim()) {
-        throw new Error('agent response missing required string field "ref"');
+        return { ok: false, errors: ['agent response missing required string field "ref"'] };
     }
     if (typeof parsed.content !== "string" || !parsed.content.trim()) {
-        throw new Error('agent response missing required string field "content"');
+        return { ok: false, errors: ['agent response missing required string field "content"'] };
     }
     const out = {
         ref: parsed.ref.trim(),
         content: parsed.content,
     };
-    if (parsed.frontmatter && typeof parsed.frontmatter === "object" && !Array.isArray(parsed.frontmatter)) {
+    if (isRecord(parsed.frontmatter))
         out.frontmatter = parsed.frontmatter;
-    }
     // Phase 6A: extract optional `confidence` (number in [0, 1]). Clamp gently
     // rather than reject — a model that returns 1.0 or 0 with extra precision
     // (e.g. 1.0000001) should still surface a usable score. Anything that isn't
@@ -509,5 +486,5 @@ export function parseAgentProposalPayload(stdout) {
         const clamped = Math.max(0, Math.min(1, parsed.confidence));
         out.confidence = clamped;
     }
-    return out;
+    return { ok: true, value: out };
 }

package/dist/integrations/agent/request-lowering.js

@@ -2,6 +2,8 @@
 // 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/.
 import { ConfigError } from "../../core/errors.js";
+import { withSchemaInstruction } from "../../core/structured.js";
+import { isModelWorkTools } from "../../execution/source.js";
 import { composeConversationFallbackPrompt } from "./conversation-fallback.js";
 import { composePersonaFallbackPrompt } from "./persona-fallback.js";
 /** A tool selection that actually names tools (not omitted, null, or empty). */
@@ -45,8 +47,8 @@ export function extensionFields(request) {
  * composing into the prompt what the harness has no channel for.
  */
 export function createAgentRequestLowerer(options) {
-    const supportedInference = new Set(options.inference ?? []);
-    return (_profile, request) => {
+    return (profile, request) => {
+        const supportedInference = new Set(typeof options.inference === "function" ? options.inference(profile, request) : (options.inference ?? []));
         const notices = [];
         const skip = (field) => {
             notices.push(untranslated(options.adapter, field));
@@ -78,6 +80,12 @@ export function createAgentRequestLowerer(options) {
             }
             dispatch.agent = request.agent;
         }
+        // Every agent transport gets the schema as the one instruction; a harness
+        // with a native channel (codex --output-schema) also reads dispatch.schema.
+        if (request.outputSchema) {
+            prompt = withSchemaInstruction(prompt, request.outputSchema);
+            dispatch.schema = request.outputSchema;
+        }
         dispatch.prompt = prompt;
         if (request.model)
             dispatch.model = request.model.resolved;
@@ -87,15 +95,18 @@ export function createAgentRequestLowerer(options) {
                 if (!supportedInference.has(key))
                     skip(`inference.${key}`);
             }
-            if (typeof request.inference?.effort === "string")
-                dispatch.effort = request.inference.effort;
         }
-        if (request.outputSchema) {
-            if (!options.outputSchema)
-                skip("outputSchema");
-            dispatch.schema = request.outputSchema;
+        if (isModelWorkTools(request.tools)) {
+            if (!options.modelWorkTools) {
+                throw new ConfigError(`The ${options.adapter} transport cannot enforce the model-work tool policy.`, "INVALID_CONFIG_FILE");
+            }
+            // The builder selects its own confined agent or flags; another agent would replace them.
+            if (dispatch.agent) {
+                throw new ConfigError(`The ${options.adapter} transport cannot run native agent ${JSON.stringify(dispatch.agent)} under the model-work tool policy.`, "INVALID_CONFIG_FILE");
+            }
+            dispatch.tools = request.tools;
         }
-        if (request.tools !== undefined) {
+        else if (request.tools !== undefined) {
             // An explicit empty selection still reaches the builder (e.g. an empty allowlist).
             if (hasToolSelection(request.tools) && !translatesTools(options.tools, request.tools)) {
                 throw new ConfigError(`The ${options.adapter} transport cannot enforce the resolved tool policy.`, "INVALID_CONFIG_FILE");

package/dist/integrations/agent/runner-dispatch.js

@@ -8,10 +8,16 @@
  * credential and passthrough value that could reach the child is redacted
  * from the result.
  */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { assertNever } from "../../core/assert.js";
-import { UsageError } from "../../core/errors.js";
+import { ConfigError, UsageError } from "../../core/errors.js";
 import { collectSensitiveValues, isEnvPassthroughValueSafeToExpose, redactSensitiveText, redactSensitiveValue, } from "../../core/redaction.js";
+import { isModelWorkTools } from "../../execution/source.js";
 import { chatCompletion, LlmCallError } from "../../llm/client.js";
+import { emitLlmUsage } from "../../llm/usage-telemetry.js";
+import { getHarness } from "../harnesses/index.js";
 import { closeServer as disposeOpencodeSdkServers, runOpencodeSdk } from "../harnesses/opencode-sdk/sdk-runner.js";
 import { lookupApiKeyFileValue, lookupApiKeySecretRefValue, lookupCredentialFromEnv, resolveEngine, } from "./engine-resolution.js";
 import { materializeLlmRunnerConnection, materializeSdkFallbackConnection } from "./runner.js";
@@ -74,6 +80,32 @@ function llmFailureReason(error) {
             return "spawn_failed";
     }
 }
+const USAGE_ERROR_CODES = {
+    timeout: "timeout",
+    aborted: "aborted",
+    parse_error: "parse_error",
+    llm_rate_limit: "rate_limited",
+};
+/**
+ * One usage record for an agent or SDK dispatch, through the same sink and
+ * ambient `withLlmStage` attribution as the LLM transport's per-HTTP-attempt
+ * records: the request's model, and tokens when the runner reported them.
+ */
+function recordDispatchUsage(execution, result) {
+    const { inputTokens, outputTokens, reasoningTokens } = result.usage ?? {};
+    const reported = [inputTokens, outputTokens, reasoningTokens].filter((count) => count !== undefined);
+    emitLlmUsage({
+        outcome: result.ok ? "success" : "error",
+        modelSource: "configured",
+        ...(execution.request.model?.resolved ? { model: execution.request.model.resolved } : {}),
+        durationMs: result.durationMs,
+        ...(inputTokens !== undefined ? { promptTokens: inputTokens } : {}),
+        ...(outputTokens !== undefined ? { completionTokens: outputTokens } : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+        ...(reported.length > 0 ? { totalTokens: reported.reduce((sum, count) => sum + count, 0) } : {}),
+        ...(result.ok ? {} : { errorCode: (result.reason && USAGE_ERROR_CODES[result.reason]) ?? "unknown_error" }),
+    });
+}
 async function dispatchRunner(runner, prompt, opts, seams, llm) {
     const envSource = opts.envSource ?? process.env;
     const secrets = collectDispatchSensitiveValues(runner, opts, envSource);
@@ -103,9 +135,70 @@ async function dispatchRunner(runner, prompt, opts, seams, llm) {
     }
     return redactResult(result, collectSensitiveValues(secrets));
 }
-/** Run a built execution. Credentials are read here, once per call, and never returned. */
+/** The git repository a directory is inside, if any: a `.git` file, or a `.git` directory with a HEAD. */
+function enclosingGitRepository(dir) {
+    for (let current = fs.realpathSync(dir);; current = path.dirname(current)) {
+        const marker = path.join(current, ".git");
+        if (fs.existsSync(path.join(marker, "HEAD")) || (fs.existsSync(marker) && fs.statSync(marker).isFile())) {
+            return current;
+        }
+        if (path.dirname(current) === current)
+            return undefined;
+    }
+}
+/**
+ * The scratch working directory for one model-work dispatch on an agent or SDK
+ * engine, so the edit the model-work tool policy grants never reaches the
+ * stash. opencode counts a whole git repository as inside its working
+ * directory, so a scratch directory inside one is refused.
+ */
+function createModelWorkDirectory() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-model-work-"));
+    const repository = enclosingGitRepository(dir);
+    if (repository === undefined)
+        return dir;
+    fs.rmSync(dir, { recursive: true, force: true });
+    throw new ConfigError(`Model work runs an agent in a scratch directory outside any git repository, but ${dir} is inside the repository at ${repository}.`, "INVALID_CONFIG_FILE", "Point TMPDIR at a directory outside any git repository.");
+}
+/**
+ * Run a built execution. Credentials are read here, once per call, and never
+ * returned. Model work on an agent or SDK engine runs in a scratch working
+ * directory that akm creates for the dispatch and removes after it, and must
+ * end with an answer: an agent that stops with none (opencode at its step
+ * limit, for one) has failed with `parse_error`.
+ */
 export async function runExecution(execution, options = {}) {
-    const opts = { ...execution.options };
+    const scratch = execution.runner.kind !== "llm" && isModelWorkTools(execution.request.tools)
+        ? createModelWorkDirectory()
+        : undefined;
+    try {
+        return await runBuiltExecution(execution, options, scratch);
+    }
+    finally {
+        if (scratch)
+            fs.rmSync(scratch, { recursive: true, force: true });
+    }
+}
+/**
+ * A model-work reply's answer: the harness's result extractor strips its
+ * framing (claude's `--output-format json` result envelope, for one), as a
+ * workflow unit's does, and no answer is a `parse_error`.
+ */
+function modelWorkAnswer(runner, result) {
+    const extractor = runner.kind === "agent" ? getHarness(runner.profile.platform ?? runner.profile.name)?.resultExtractor : undefined;
+    const extracted = extractor ? extractor(result) : { text: result.stdout };
+    const answer = {
+        ...result,
+        stdout: extracted.text,
+        ...(extracted.sessionId ? { sessionId: extracted.sessionId } : {}),
+    };
+    if (extracted.text.trim() !== "")
+        return answer;
+    return { ...answer, ok: false, reason: "parse_error", error: `Engine "${runner.engine}" returned no answer.` };
+}
+/** `scratch` is the model-work working directory, set only for model work on an agent or SDK engine. */
+async function runBuiltExecution(execution, options, scratch) {
+    const opts = { ...execution.options, ...(scratch ? { cwd: scratch } : {}) };
     const operational = options.runOptions ?? {};
     for (const key of OPERATIONAL_OPTIONS) {
         if (operational[key] !== undefined)
@@ -140,7 +233,13 @@ export async function runExecution(execution, options = {}) {
             };
         }
     };
-    return dispatchRunner(execution.runner, execution.prompt, opts, options, llm);
+    let result = await dispatchRunner(execution.runner, execution.prompt, opts, options, llm);
+    if (scratch !== undefined && result.ok)
+        result = modelWorkAnswer(execution.runner, result);
+    // The LLM transport records each HTTP attempt itself.
+    if (execution.runner.kind !== "llm")
+        recordDispatchUsage(execution, result);
+    return result;
 }
 /** `akm agent`: launch an agent engine interactively, with no prompt of its own. */
 export async function executeInteractiveAgentInvocation(input, seams = {}) {

package/dist/integrations/agent/runner.js

@@ -67,6 +67,12 @@ export function decodeFrozenRunnerSpec(value) {
 export function runnerIsLlm(runner) {
     return runner.kind === "llm";
 }
-export function runnerSupportsFileWrite(runner) {
-    return runner.kind !== "llm";
+/**
+ * The LLM connection behind a runner, whatever its kind: an llm runner's own,
+ * an sdk runner's provider fallback, none for an agent CLI.
+ */
+export function runnerLlmConnection(runner) {
+    if (runner.kind === "llm")
+        return runner.connection;
+    return runner.kind === "sdk" ? runner.fallbackConnection : undefined;
 }

package/dist/integrations/harnesses/aider/agent-builder.js

@@ -39,13 +39,11 @@
  * - **schema** — the matrix places Aider in the "via prompt+validate" tier
  *   with *no* structured output mode at all (plan §"Structured-output
  *   normalization", tier "none"): there is no schema flag and no JSON output
- *   flag, so the JSON Schema is injected into the message payload using the
- *   exact directive wording of the engine's prompt assembly
- *   (`step-work.ts` `buildUnitPrompt`) and the pi builder, so all
- *   dispatch paths speak one dialect. Downstream, embedded-JSON extraction +
- *   the engine's shared retry-until-valid loop supply the validation Aider
- *   lacks. No temp schema file is written — that is Codex's native-schema
- *   mechanism (`--output-schema`), which Aider does not have.
+ *   flag, so the JSON Schema reaches it only as the instruction the shared
+ *   request lowering appends to the prompt. Downstream, embedded-JSON
+ *   extraction + the engine's shared retry-until-valid loop supply the
+ *   validation Aider lacks. No temp schema file is written — that is Codex's
+ *   native-schema mechanism (`--output-schema`), which Aider does not have.
  * - **tools** — deliberately unconsumed. Aider has no per-tool allowlist
  *   flag; tool-ish behaviour is governed by its own switches (`--yes-always`,
  *   git integration, shell-command confirmation). A restrictive policy is
@@ -57,41 +55,32 @@
  *   durable source of truth; resume works even against a harness with no
  *   session model (plan §"Session, MCP, and identity across harnesses" —
  *   Aider is the plan's named example).
- * - **effort** — stays unconsumed (reserved; the shared request contract's
- *   "no builder consumes it yet" note stays true).
+ * - **inference** — not translated: the shared lowering reports each field of
+ *   the request's inference as untranslated (`inference` in `harnesses/ids.ts`
+ *   lists none for this harness).
  *
  * Registered: `aiderBuilder` is `AiderHarness.agentBuilder` (`./index.ts`),
  * one of the ten harnesses `HARNESS_REGISTRY` constructs
  * (`harnesses/index.ts`); `agent/builders.ts` derives `BUILTIN_BUILDERS` from
  * that registry, so this builder is reachable under the `"aider"` platform
- * name without any further wiring. The registry entry also declares
- * `structuredOutput: "none"` alongside it (`./index.ts`).
+ * name without any further wiring.
  */
 import { resolveDispatchModel } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
 /** Canonical harness/platform id used for model-alias resolution. */
 export const AIDER_PLATFORM = "aider";
-/**
- * Assemble the `--message` payload: optional system text, the task prompt,
- * and — when a schema is requested — the same schema directive the workflow
- * engine's prompt assembly uses (Aider has no native structured output, so
- * the prompt is the only channel; plan §"Structured-output normalization",
- * tier "none").
- */
+/** Assemble the `--message` payload: optional system text, then the task prompt. */
 function buildMessagePayload(req) {
     const sections = [];
     if (req.systemPrompt)
         sections.push(req.systemPrompt);
     sections.push(req.prompt);
-    if (req.schema) {
-        sections.push(`Respond with ONLY a JSON value matching this JSON Schema (no prose, no code fences):\n${JSON.stringify(req.schema)}`);
-    }
     return sections.join("\n\n");
 }
 /**
  * Aider builder.
  * Command shape:
- *   aider [--model <m>] --yes-always --no-pretty --message=<[system\n\n]prompt[\n\nschema directive]>
+ *   aider [--model <m>] --yes-always --no-pretty --message=<[system\n\n]prompt>
  */
 export const aiderBuilder = {
     platform: AIDER_PLATFORM,
@@ -100,7 +89,6 @@ export const aiderBuilder = {
         adapter: AIDER_PLATFORM,
         personaChannel: "prompt",
         tools: "none",
-        outputSchema: true,
     }),
     build(profile, req) {
         const args = [...profile.args];

package/dist/integrations/harnesses/aider/index.js

@@ -29,11 +29,6 @@ export class AiderHarness extends BaseHarness {
     agentBuilder = aiderBuilder;
     resultExtractor = aiderResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
-    // akm spawns the `aider` CLI locally per unit ⇒ local-runner.
-    pattern = "local-runner";
-    // No structured-output mode at all (the matrix's "none — parse output"):
-    // akm injects the schema into the prompt and extracts embedded JSON.
-    structuredOutput = "none";
     // No flag-shaped resume: Aider persists context in chat-history files
     // (`.aider.chat.history.md`), not session ids — the plan's named example of
     // a harness with no session model. akm's `workflow_run_units` remains the

package/dist/integrations/harnesses/amazonq/agent-builder.js

@@ -35,9 +35,8 @@
  *   blank line.
  * - **schema** — the matrix places Q in the NO-structured-output tier
  *   ("via prompt+validate": *(none documented)* — there is no `--json` or
- *   `--output-format` to ask for). The JSON Schema is therefore passed
- *   through the prompt: a directive matching the engine's wording
- *   (`step-work.ts` `buildUnitPrompt`) is appended to the payload.
+ *   `--output-format` to ask for). The JSON Schema therefore reaches it only
+ *   as the instruction the shared request lowering appends to the prompt.
  *   Stdout stays plain text; `./result-extractor.ts` strips terminal framing
  *   and the engine's shared embedded-JSON parse + retry-until-valid loop does
  *   the rest. No schema temp file is written — that seam is codex-only
@@ -51,16 +50,15 @@
  *   falling back to `--trust-all-tools` (never silently widen a restriction)
  *   — Q then refuses untrusted tool actions in non-interactive mode, which is
  *   the conservative failure mode.
- * - **effort** — stays unconsumed (reserved; the shared request contract's
- *   "no builder consumes it yet" note stays true).
+ * - **inference** — not translated: the shared lowering reports each field of
+ *   the request's inference as untranslated (`inference` in `harnesses/ids.ts`
+ *   lists none for this harness).
  *
  * Registered: `amazonqBuilder` is `AmazonqHarness.agentBuilder`
  * (`./index.ts`), one of the ten harnesses `HARNESS_REGISTRY` constructs
  * (`harnesses/index.ts`); `agent/builders.ts` derives `BUILTIN_BUILDERS` from
  * that registry, so this builder is reachable under the `"amazonq"` platform
- * name without any further wiring. The registry-side capability entry —
- * pattern `local-runner`, structuredOutput `none` — is declared alongside it
- * (`./index.ts`).
+ * name without any further wiring.
  */
 import { resolveDispatchModel } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
@@ -84,27 +82,19 @@ function toolPolicyEntries(tools) {
     }
     return undefined;
 }
-/**
- * Assemble the positional prompt payload: optional system prompt, the task
- * prompt, and — when a schema is requested — the same schema directive the
- * workflow engine's prompt assembly uses, so both dispatch paths speak one
- * dialect.
- */
+/** Assemble the positional prompt payload: optional system prompt, then the task prompt. */
 function buildPromptPayload(req) {
     const sections = [];
     if (req.systemPrompt)
         sections.push(req.systemPrompt);
     sections.push(req.prompt);
-    if (req.schema) {
-        sections.push(`Respond with ONLY a JSON value matching this JSON Schema (no prose, no code fences):\n${JSON.stringify(req.schema)}`);
-    }
     return sections.join("\n\n");
 }
 /**
  * Amazon Q Developer CLI builder.
  * Command shape:
  *   q chat --no-interactive (--trust-all-tools | --trust-tools=<t1,t2>)
- *          [--model <m>] -- "<systemPrompt?\n\nprompt\n\nschema directive?>"
+ *          [--model <m>] -- "<systemPrompt?\n\nprompt>"
  */
 export const amazonqBuilder = {
     platform: AMAZONQ_PLATFORM,
@@ -113,7 +103,6 @@ export const amazonqBuilder = {
         adapter: AMAZONQ_PLATFORM,
         personaChannel: "prompt",
         tools: "flat",
-        outputSchema: true,
     }),
     build(profile, req) {
         // Built-in q profiles would ship `args: []`; headless dispatch is the
@@ -141,8 +130,8 @@ export const amazonqBuilder = {
             const resolved = resolveDispatchModel(req, profile, AMAZONQ_PLATFORM);
             args.push("--model", resolved);
         }
-        // No system-prompt / schema flags exist on `q chat` — both travel in the
-        // positional payload, after the end-of-options separator.
+        // No system-prompt flag exists on `q chat` — it travels in the positional
+        // payload, after the end-of-options separator.
         args.push("--");
         args.push(buildPromptPayload(req));
         return { argv: [profile.bin, ...args] };