@monoes/monomindcli 2.13.0 → 2.14.0

package/dist/src/orgrt/tool-spill.js

@@ -0,0 +1,180 @@
+// packages/@monomind/cli/src/orgrt/tool-spill.ts
+/**
+ * ADR-O001 D2 — spill-and-reference for tool results.
+ *
+ * Measured on one real run: tool results are 76% of all context mass (Bash
+ * 4,387 calls / 5.7M chars and Read 420 / 2.0M chars are 97% of that), while
+ * inter-agent mail is 0.1%. A role holds ONE SDK session for its whole life
+ * with no truncation anywhere in orgrt/, so every tool result it ever saw is
+ * re-sent on every later turn — cost is roughly quadratic in turns.
+ *
+ * The mechanism already existed, pointed at the 0.1% channel: cross-org.ts's
+ * `mailBody` writes an oversized mail body to `.mail/<id>.md` and leaves a
+ * 1,024-char digest plus a path in context. This is the same shape, applied to
+ * the channel that carries the mass — same "write in full FIRST, digest
+ * second" ordering, same "on write failure deliver in full rather than lose
+ * content" fallback.
+ *
+ * ── Threshold arithmetic (why 2,048) ──────────────────────────────────────
+ * Result sizes: p50 451, p75 1,583, p90 3,506, p95 5,138, p99 11,739, max
+ * 59,805, mean 1,370. It is a long tail of SMALL results, so the usual "only
+ * spill the monsters" instinct recovers almost nothing:
+ *
+ *   threshold   spilled calls   net tool mass recovered
+ *   11,739 (p99)      1.0%              21%
+ *    5,138 (p95)      5.0%              37%
+ *    4,096 (mail's)   8.2%              42%
+ *    3,506 (p90)     10.0%              45%
+ *    2,048           21.4%              52%      ← chosen
+ *    1,536 (p75)     26.0%              52%
+ *
+ * Two constraints fix the choice. Below, a spilled result still costs its
+ * digest (1,536) plus a reference line (~160) — about 1,700 chars — so any
+ * threshold under ~1,700 ADDS mass instead of removing it; that is the floor.
+ * Above, the curve is flat from 1,536 to ~3,000 and then falls away, so 2,048
+ * (= 2× the mail digest) sits at the knee: it takes essentially all the
+ * recoverable mass while leaving four fifths of all calls untouched, which is
+ * what keeps a role able to do its job.
+ *
+ * ── Digest strategy ───────────────────────────────────────────────────────
+ * Never a blind one-sided truncation. A Bash result puts what matters at the
+ * END (assertion failures, the summary line, the exit status); a Read puts it
+ * at the START. So the digest is always head + elision note + tail, with the
+ * WEIGHT flipped by tool: 1/3 head + 2/3 tail for command-shaped tools
+ * (the default, since Bash dominates), 2/3 head + 1/3 tail for file-shaped
+ * ones.
+ *
+ * The response object's SHAPE is preserved — only its long string leaves are
+ * digested, and the budget is water-filled across them smallest-first, so a
+ * short `stderr` next to a huge `stdout` survives whole.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** Results at or under this stay byte-identical. See the threshold arithmetic
+ *  in the module comment — this is the knee of the recovery curve, not a
+ *  round number. */
+export const TOOL_RESULT_MAX = 2048;
+/** Total digest text a spilled result may keep in context, across all of its
+ *  string leaves. 1.5× cross-org.ts's MAIL_DIGEST_CHARS: a tool result has to
+ *  carry a stack trace where a mail body only has to carry a subject. */
+export const TOOL_DIGEST_CHARS = 1536;
+/** Tools whose output is read top-down — the head is the useful end. Everything
+ *  else is treated as command-shaped (tail-weighted), because Bash is 76% of
+ *  the calls and an unknown tool is far more likely to be command-shaped. */
+const HEAD_WEIGHTED = new Set(['Read', 'NotebookRead', 'Glob', 'Grep', 'WebFetch']);
+/** Every string leaf of a tool response, in a stable traversal order that
+ *  `rebuild` replays exactly. */
+function collect(value, label, out) {
+    if (typeof value === 'string') {
+        out.push({ value, label });
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((v, i) => collect(v, label ? `${label}[${i}]` : `[${i}]`, out));
+        return;
+    }
+    if (value && typeof value === 'object')
+        for (const [k, v] of Object.entries(value))
+            collect(v, label ? `${label}.${k}` : k, out);
+}
+/** Same traversal as `collect`, substituting each leaf from `next` in order. */
+function rebuild(value, next) {
+    if (typeof value === 'string')
+        return next();
+    if (Array.isArray(value))
+        return value.map((v) => rebuild(v, next));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, rebuild(v, next)]));
+    return value;
+}
+/** head + note + tail, weighted by tool kind. `keep` is the character budget
+ *  for the retained text; the note is on top of it (it is the pointer, not
+ *  content, and dropping it would make the spill unrecoverable). */
+function digest(value, keep, headWeighted, file) {
+    if (value.length <= keep)
+        return value;
+    const head = Math.round(keep * (headWeighted ? 2 / 3 : 1 / 3));
+    const tail = keep - head;
+    const elided = value.length - keep;
+    const note = `\n\n[... ${elided} chars elided — full tool result at ${file} — Read it if needed]\n\n`;
+    return value.slice(0, head) + note + (tail > 0 ? value.slice(value.length - tail) : '');
+}
+/** What gets written to disk: the raw text when only one leaf carries content
+ *  (the overwhelmingly common case — Bash with an empty stderr, or a plain
+ *  string response), otherwise labelled sections so a multi-leaf response
+ *  stays readable AND attributable. Empty leaves are omitted: they carry no
+ *  data and a `=== stderr ===` with nothing under it only makes the file
+ *  harder to read. */
+function renderFull(leaves) {
+    const filled = leaves.filter((l) => l.value.length > 0);
+    if (filled.length === 1)
+        return filled[0].value;
+    return filled.map((l) => `=== ${l.label} ===\n${l.value}`).join('\n\n');
+}
+/**
+ * Bound one tool result. Returns undefined when nothing needs doing (the
+ * result is at or under TOOL_RESULT_MAX) or when the spill write failed — in
+ * both cases the caller leaves the original result alone, so content is never
+ * lost to a disk error.
+ */
+export function spillToolResult(dir, toolName, toolUseId, response) {
+    const leaves = [];
+    collect(response, '', leaves);
+    const total = leaves.reduce((n, l) => n + l.value.length, 0);
+    if (total <= TOOL_RESULT_MAX)
+        return undefined;
+    // Full body to disk FIRST — nothing is elided until it is recoverable.
+    const file = join(dir, `${toolUseId.replace(/[^a-zA-Z0-9_-]/g, '_')}.txt`);
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(file, renderFull(leaves));
+    }
+    catch {
+        return undefined; // spill failed — deliver in full rather than lose content
+    }
+    // Water-fill the digest budget smallest-leaf-first: short leaves (a 200-char
+    // stderr) keep every character, and whatever is left over goes to the leaf
+    // that actually carries the mass. Total retained text <= TOOL_DIGEST_CHARS.
+    const headWeighted = HEAD_WEIGHTED.has(toolName);
+    const keeps = new Map();
+    let remaining = TOOL_DIGEST_CHARS;
+    const ascending = [...leaves].sort((a, b) => a.value.length - b.value.length);
+    ascending.forEach((leaf, i) => {
+        const share = Math.floor(remaining / (ascending.length - i));
+        const keep = Math.min(leaf.value.length, share);
+        keeps.set(leaf, keep);
+        remaining -= keep;
+    });
+    let i = 0;
+    const output = rebuild(response, () => {
+        const leaf = leaves[i++];
+        return digest(leaf.value, keeps.get(leaf) ?? 0, headWeighted, file);
+    });
+    return { output, file };
+}
+/**
+ * A `PostToolUse` hook for the Claude Agent SDK. This is the ONLY layer that
+ * can rewrite a tool result before it reaches the model: Bash and Read run
+ * inside the SDK's own CLI process, so the org runtime never touches their
+ * output — `agent-runner.ts`'s `tool_result` stream is read-only observation,
+ * emitted after the transcript already holds the full text. The SDK does
+ * expose the seam we need here (`PostToolUseHookSpecificOutput.
+ * updatedToolOutput`: "Replaces the tool output before it is sent to the
+ * model"), so the clean approach is achievable — for the Claude path. The
+ * vendor runners (codex/opencode/qwen/…) drive their own CLIs and have no
+ * equivalent, so they are out of scope here.
+ */
+export function toolResultSpillHook(dir) {
+    return async (input) => {
+        const spilled = spillToolResult(dir, String(input.tool_name ?? ''), String(input.tool_use_id ?? `t${Date.now()}`), input.tool_response);
+        if (!spilled)
+            return {};
+        return {
+            hookSpecificOutput: {
+                hookEventName: 'PostToolUse',
+                updatedToolOutput: spilled.output,
+            },
+        };
+    };
+}
+//# sourceMappingURL=tool-spill.js.map

package/dist/src/orgrt/tool-spill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-spill.js","sourceRoot":"","sources":["../../../src/orgrt/tool-spill.ts"],"names":[],"mappings":"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"}

package/dist/src/orgrt/types.d.ts

@@ -142,6 +142,10 @@ export declare const RolePolicySchema: z.ZodObject<{
     fileRead: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
     webAllow: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     maxTokens: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    maxTokensBasis: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        billable: "billable";
+        uncached: "uncached";
+    }>>>;
     maxUsd: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
     git: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
         commit: "commit";
@@ -276,6 +280,10 @@ export declare const RoleSchema: z.ZodObject<{
         fileRead: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
         webAllow: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         maxTokens: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        maxTokensBasis: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            billable: "billable";
+            uncached: "uncached";
+        }>>>;
         maxUsd: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
         git: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
             commit: "commit";
@@ -323,6 +331,13 @@ export declare const RoleSchema: z.ZodObject<{
         autoApproveTools: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         approvalTools: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     }, z.core.$loose>>;
+    session_scope: z.ZodOptional<z.ZodEnum<{
+        role: "role";
+        task: "task";
+    }>>;
+    review_input: z.ZodOptional<z.ZodEnum<{
+        "artifact-only": "artifact-only";
+    }>>;
     runtime: z.ZodOptional<z.ZodEnum<{
         antigravity: "antigravity";
         claude: "claude";
@@ -371,6 +386,56 @@ export declare const RoleSchema: z.ZodObject<{
  *  Set run_config.max_turns_per_message (or a role's own
  *  max_turns_per_message) to cap turns when you want a hard limit. */
 export declare const DEFAULT_MAX_TURNS_PER_MESSAGE = 100000;
+export declare const CostTiersSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodString>;
+    roles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        tier: z.ZodString;
+        effort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            off: "off";
+            xhigh: "xhigh";
+        }>>;
+    }, z.core.$loose>]>>>;
+    tiers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodString;
+        effort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            off: "off";
+            xhigh: "xhigh";
+        }>>;
+    }, z.core.$loose>>>>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        effort_env: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            off: "off";
+            xhigh: "xhigh";
+        }> & z.core.$partial, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+/** ADR-O001 D7: one named loadout — a stable bundle of role-prompt text and
+ *  skills that becomes part of the SYSTEM PROMPT of the session serving a
+ *  task. Validation (catalog size, names, skills, file) and resolution live in
+ *  orgrt/loadouts.ts. */
+export declare const LoadoutSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    instructions_file: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** ADR-O001 D4's number: three failed evidence checks on one task, then
+ *  escalate instead of handing it back again. Exported so the call site can
+ *  fall back to it for an org definition that never went through the schema
+ *  (a hand-built RunningOrg, a config written before this field existed). */
+export declare const DEFAULT_MAX_EVIDENCE_ATTEMPTS = 3;
 export declare const OrgDefSchema: z.ZodObject<{
     name: z.ZodString;
     goal: z.ZodDefault<z.ZodString>;
@@ -379,6 +444,10 @@ export declare const OrgDefSchema: z.ZodObject<{
     run_config: z.ZodPipe<z.ZodDefault<z.ZodObject<{
         max_concurrent_agents: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         budget_tokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        budget_tokens_basis: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            billable: "billable";
+            uncached: "uncached";
+        }>>>;
         memory_namespace: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         max_turns_per_message: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         idle_minutes: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -386,6 +455,13 @@ export declare const OrgDefSchema: z.ZodObject<{
             boss: "boss";
             dag: "dag";
         }>>>;
+        completion_evidence: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        max_evidence_attempts: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        session_scope: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            role: "role";
+            task: "task";
+        }>>>;
+        session_idle_exit_ms: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
         workspace: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"repo">, z.ZodLiteral<"isolated">, z.ZodLiteral<"worktree">, z.ZodLiteral<"worktree-per-role">, z.ZodString]>>>;
         circuit_breaker: z.ZodOptional<z.ZodOptional<z.ZodObject<{
             failure_threshold: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
@@ -411,6 +487,8 @@ export declare const OrgDefSchema: z.ZodObject<{
     }, z.core.$loose>>, z.ZodTransform<{
         memory_namespace?: string | undefined;
         idle_minutes?: number | undefined;
+        session_scope?: "role" | "task" | undefined;
+        session_idle_exit_ms?: number | undefined;
         circuit_breaker?: {
             failure_threshold?: number | undefined;
             cooldown_ms?: number | undefined;
@@ -429,11 +507,14 @@ export declare const OrgDefSchema: z.ZodObject<{
         }[] | undefined;
         max_concurrent_agents: number;
         budget_tokens: number;
+        budget_tokens_basis: "billable" | "uncached";
         max_turns_per_message: number;
         workspace: string;
         stale_base_threshold: number;
         max_role_respawns: number;
         completion: "boss" | "dag";
+        completion_evidence: boolean;
+        max_evidence_attempts: number;
         respawn_drain_timeout_ms: number;
         respawn_force_stop_timeout_ms: number;
         respawn_start_timeout_ms: number;
@@ -441,10 +522,15 @@ export declare const OrgDefSchema: z.ZodObject<{
         [x: string]: unknown;
         max_concurrent_agents?: number | undefined;
         budget_tokens?: number | undefined;
+        budget_tokens_basis?: "billable" | "uncached" | undefined;
         memory_namespace?: string | undefined;
         max_turns_per_message?: number | undefined;
         idle_minutes?: number | undefined;
         completion?: "boss" | "dag" | undefined;
+        completion_evidence?: boolean | undefined;
+        max_evidence_attempts?: number | undefined;
+        session_scope?: "role" | "task" | undefined;
+        session_idle_exit_ms?: number | undefined;
         workspace?: string | undefined;
         circuit_breaker?: {
             failure_threshold?: number | undefined;
@@ -498,6 +584,47 @@ export declare const OrgDefSchema: z.ZodObject<{
         allow_from: z.ZodOptional<z.ZodArray<z.ZodString>>;
         allow_to: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$loose>>;
+    cost_tiers: z.ZodOptional<z.ZodObject<{
+        default: z.ZodOptional<z.ZodString>;
+        roles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            tier: z.ZodString;
+            effort: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+        }, z.core.$loose>]>>>;
+        tiers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodString;
+            effort: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+        }, z.core.$loose>>>>;
+        providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            effort_env: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                off: "off";
+                xhigh: "xhigh";
+            }> & z.core.$partial, z.ZodRecord<z.ZodString, z.ZodString>>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+    loadouts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        instructions_file: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
     roles: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodDefault<z.ZodString>;
@@ -562,6 +689,10 @@ export declare const OrgDefSchema: z.ZodObject<{
             fileRead: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
             webAllow: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             maxTokens: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+            maxTokensBasis: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+                billable: "billable";
+                uncached: "uncached";
+            }>>>;
             maxUsd: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
             git: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
                 commit: "commit";
@@ -609,6 +740,13 @@ export declare const OrgDefSchema: z.ZodObject<{
             autoApproveTools: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
             approvalTools: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
         }, z.core.$loose>>;
+        session_scope: z.ZodOptional<z.ZodEnum<{
+            role: "role";
+            task: "task";
+        }>>;
+        review_input: z.ZodOptional<z.ZodEnum<{
+            "artifact-only": "artifact-only";
+        }>>;
         runtime: z.ZodOptional<z.ZodEnum<{
             antigravity: "antigravity";
             claude: "claude";

package/dist/src/orgrt/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/orgrt/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/orgrt/types.ts"],"names":[],"mappings":"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"}

package/dist/src/orgrt/types.js

@@ -1,5 +1,6 @@
 // packages/@monomind/cli/src/orgrt/types.ts
 import { z } from 'zod';
+import { ORG_EFFORT_LEVELS } from './cost-tier.js';
 export const ContextSliceSchema = z.object({ source: z.string(), summary: z.string() });
 export const ArtifactRefSchema = z.object({ path: z.string(), description: z.string().optional() });
 export const HandoffDecisionSchema = z.object({
@@ -141,6 +142,13 @@ export const RolePolicySchema = z
      *  'api.example.com'), '*.example.com' wildcard, or '*' for any host. */
     webAllow: z.array(z.string()).optional(),
     maxTokens: z.number().int().positive().optional(),
+    /** ADR-O001 D1: which token basis `maxTokens` is compared against.
+     *  'uncached' (default) — input + output only, the basis every existing
+     *  budget_tokens value was written against. 'billable' — also counts
+     *  cache reads and cache writes, i.e. what is actually billed. Derived by
+     *  the daemon from `run_config.budget_tokens_basis`; never set per role in
+     *  a config. */
+    maxTokensBasis: z.enum(['uncached', 'billable']).optional(),
     /** USD spend cap for this role (ORG-7). Enforced the same way maxTokens/overBudget
      *  is: PolicyEngine.decide() denies once accumulated cost meets or exceeds it. */
     maxUsd: z.number().positive().optional(),
@@ -252,6 +260,13 @@ export const RoleSchema = z
         .optional(),
     provider: ProviderSchema.optional(),
     policy: RolePolicySchema.optional(),
+    /** ADR-O001 D3: overrides run_config.session_scope for this role. */
+    session_scope: z.enum(['role', 'task']).optional(),
+    /** ADR-O001 D6: 'artifact-only' makes this a cold reviewer — a new model
+     *  session per message, fed only runtime-built review packets
+     *  (org_review); other agents' org_send to it is refused, so the doer's
+     *  framing cannot reach it. Absent = an ordinary role. */
+    review_input: z.enum(['artifact-only']).optional(),
     /** Per-role runtime override: when set, this role's sessions run on the given
      *  agent runtime regardless of the org-level `runtime` field or the
      *  MONOMIND_RUNTIME env var ('claude' explicitly forces the Claude default).
@@ -303,6 +318,73 @@ export const RoleSchema = z
  *  Set run_config.max_turns_per_message (or a role's own
  *  max_turns_per_message) to cap turns when you want a hard limit. */
 export const DEFAULT_MAX_TURNS_PER_MESSAGE = 100_000;
+/** ADR-O001 D8 cost tiers. Keys are provider keys — a Vercel vendor slug
+ *  (`glm`, `openai`, …) when the role has one, else the role's runtime id
+ *  (`claude`, `codex`, `kimicode`, …) — so a tier is expressible for a
+ *  provider this code has never heard of without touching code. Resolution,
+ *  the built-in Claude catalog and the deliberative-role warning live in
+ *  orgrt/cost-tier.ts. */
+const EffortLevelSchema = z.enum(ORG_EFFORT_LEVELS);
+export const CostTiersSchema = z
+    .object({
+    /** Tier applied to every role with no `roles` entry of its own. */
+    default: z.string().optional(),
+    /** Per-role tier. A bare string is a tier name or `"exempt"`; the object
+     *  form also overrides the tier's effort — how "patrol roles drop effort
+     *  since they do simpler, more repetitive work" is expressed. */
+    roles: z
+        .record(z.string(), z.union([
+        z.string(),
+        z.object({ tier: z.string(), effort: EffortLevelSchema.optional() }).passthrough(),
+    ]))
+        .optional(),
+    /** tier name → provider key → { model, effort }. Merged over the built-in
+     *  catalog per provider, so adding one provider to a built-in tier keeps
+     *  the rest of that tier. */
+    tiers: z
+        .record(z.string(), z.record(z.string(), z
+        .object({ model: z.string().min(1), effort: EffortLevelSchema.optional() })
+        .passthrough()))
+        .optional(),
+    /** provider key → how that provider expresses an effort level. Claude is
+     *  handled natively (the SDK's own `effort`/`thinking` options); anything
+     *  else declares env vars here, or encodes effort in the per-tier model id
+     *  (e.g. `gemini-3.6-flash-high`). A provider with neither ignores it. */
+    providers: z
+        .record(z.string(), z
+        .object({
+        // partialRecord, not record: z.record() over an enum key demands
+        // EVERY level be present, so an org declaring only `low` would be
+        // rejected for not also declaring medium/high/xhigh/max.
+        effort_env: z
+            .partialRecord(EffortLevelSchema, z.record(z.string(), z.string()))
+            .optional(),
+    })
+        .passthrough())
+        .optional(),
+})
+    .passthrough();
+/** ADR-O001 D7: one named loadout — a stable bundle of role-prompt text and
+ *  skills that becomes part of the SYSTEM PROMPT of the session serving a
+ *  task. Validation (catalog size, names, skills, file) and resolution live in
+ *  orgrt/loadouts.ts. */
+export const LoadoutSchema = z
+    .object({
+    /** One line shown to the boss in org_task's description, to select by. */
+    description: z.string().optional(),
+    /** Role-prompt text for this kind of work. */
+    prompt: z.string().optional(),
+    /** Built-in role skills (orgrt/role-skills/<name>.md) to include. */
+    skills: z.array(z.string()).optional(),
+    /** Extra guidance file, resolved against the project root. */
+    instructions_file: z.string().optional(),
+})
+    .passthrough();
+/** ADR-O001 D4's number: three failed evidence checks on one task, then
+ *  escalate instead of handing it back again. Exported so the call site can
+ *  fall back to it for an org definition that never went through the schema
+ *  (a hand-built RunningOrg, a config written before this field existed). */
+export const DEFAULT_MAX_EVIDENCE_ATTEMPTS = 3;
 export const OrgDefSchema = z
     .object({
     name: z.string().min(1),
@@ -313,6 +395,15 @@ export const OrgDefSchema = z
         .object({
         max_concurrent_agents: z.number().int().positive().default(4),
         budget_tokens: z.number().int().positive().default(1_000_000),
+        /** ADR-O001 D1: which token basis `budget_tokens` is enforced on.
+         *  'uncached' (default) counts input + output, the basis this value
+         *  has always meant. 'billable' also counts cache reads/writes — the
+         *  honest basis, but ~100x larger on a well-cached run, so opting in
+         *  means re-sizing budget_tokens. The meter itself is always billable
+         *  (usage events, checkpoints, dashboards); this knob only governs
+         *  enforcement, so switching it can never change what is reported.
+         *  Prefer `budget_usd`, which needs no basis. */
+        budget_tokens_basis: z.enum(['uncached', 'billable']).optional(),
         memory_namespace: z.string().optional(),
         max_turns_per_message: z.number().int().positive().default(DEFAULT_MAX_TURNS_PER_MESSAGE),
         /** idle watchdog window in minutes (fractions allowed); 0 disables. Default 10. */
@@ -326,6 +417,36 @@ export const OrgDefSchema = z
          *  with no populated DAG (the common case today) gets no benefit
          *  from it, only a new refusal path. See completion-gate.ts. */
         completion: z.enum(['boss', 'dag']).optional(),
+        /** ADR-O001 D5: gate `org_task_done` on machine-checkable evidence —
+         *  acceptance commands with their real exit codes, pinned to the
+         *  workspace's current commit sha. Adjacent FLAG rather than a third
+         *  `completion` value because it constrains a different call
+         *  (org_task_done, per item) than `completion` does (org_complete,
+         *  per run): an org wants to choose both independently. Default
+         *  false — turning it on refuses task completions that previously
+         *  succeeded, which is the point, but must not happen on upgrade.
+         *  See completion-gate.ts's `checkTaskEvidence`. */
+        completion_evidence: z.boolean().optional(),
+        /** ADR-O001 D4 ("bound retries (3) and escalate"): how many times one
+         *  task may fail the `completion_evidence` gate before the runtime
+         *  stops handing it back to its assignee and escalates it to the boss
+         *  instead. Counted per task and carried by the checkpoint (see
+         *  `OrgTask.evidenceFailures`). Only meaningful with
+         *  `completion_evidence` on — without the gate nothing fails. */
+        max_evidence_attempts: z.number().int().positive().default(3),
+        /** ADR-O001 D3: how a role's MODEL sessions are keyed. 'role'
+         *  (the default, and the behaviour before D3) keeps one session for
+         *  the role's life. 'task' keeps one per task: the role's process
+         *  exits at a task boundary and the next wake resumes that task's
+         *  session from the run's session ledger. Applies to every role
+         *  except the coordinator, whose work spans tasks — a role's own
+         *  `session_scope` overrides it either way. */
+        session_scope: z.enum(['role', 'task']).optional(),
+        /** ADR-O001 D3: end a role's process after this many ms with no mail;
+         *  the next message resumes the same model session. Absent = never
+         *  (the process parks, as before). Idle residency costs no tokens,
+         *  so this is about process count, not spend. */
+        session_idle_exit_ms: z.number().int().positive().optional(),
         /** Where role sessions run.
          *  'repo' (default) — the project root, so roles can Read/Edit real files.
          *  'isolated' — a scratch dir under .monomind/orgs/<name>/workspace, which the
@@ -378,11 +499,14 @@ export const OrgDefSchema = z
         .transform((rc) => ({
         max_concurrent_agents: 4,
         budget_tokens: 1_000_000,
+        budget_tokens_basis: 'uncached',
         max_turns_per_message: DEFAULT_MAX_TURNS_PER_MESSAGE,
         workspace: 'repo',
         stale_base_threshold: 0,
         max_role_respawns: 0,
         completion: 'boss',
+        completion_evidence: false,
+        max_evidence_attempts: DEFAULT_MAX_EVIDENCE_ATTEMPTS,
         respawn_drain_timeout_ms: 30_000,
         respawn_force_stop_timeout_ms: 5_000,
         respawn_start_timeout_ms: 60_000,
@@ -399,6 +523,30 @@ export const OrgDefSchema = z
     })
         .passthrough()
         .optional(),
+    /** ADR-O001 D8: named cost tiers, each setting BOTH the model AND the
+     *  reasoning/thinking effort for a role, per provider. Absent (the
+     *  default) = no tiering at all and today's model resolution, unchanged.
+     *
+     *  Precedence at session start: an explicit `adapter_config.model` wins
+     *  over the tier's model; the tier wins over a named provider's default
+     *  and the runtime default. A tier's EFFORT applies either way, since it
+     *  is a separate axis from which model to run.
+     *
+     *  DO NOT TIER A DELIBERATIVE ROLE INTO A WEAK VOICE. The ADR is explicit:
+     *  tier by *difficulty of the judgement*, not by role label — "a cheap
+     *  model in a debate produces cheap arguments and the synthesiser cannot
+     *  tell". Assign `"exempt"` to any role whose value is the quality of its
+     *  disagreement (design reviewer, red-teamer, debate synthesiser) and
+     *  control its cost with a budget instead. See orgrt/cost-tier.ts. */
+    cost_tiers: CostTiersSchema.optional(),
+    /** ADR-O001 D7: the org's catalog of named loadouts (target 5–15; more
+     *  than 15 fails `org validate` and `org run`). When present, org_task and
+     *  org_plan_graph take an optional `loadout` the boss SELECTS by name; it
+     *  is recorded on the task row and every re-dispatch reuses it. Absent
+     *  (the default) = no loadout argument and byte-identical prompts/tools.
+     *  Deliberative work that wants many one-off perspectives belongs in its
+     *  own org (ADR-O001, "What this does NOT apply to"). See orgrt/loadouts.ts. */
+    loadouts: z.record(z.string(), LoadoutSchema).optional(),
     roles: z.array(RoleSchema).min(1),
     /** Which agent runtime hosts this org's role sessions. When absent, the
      *  MONOMIND_RUNTIME env var is honored, falling back to the default Claude