@juzser/blacksmith 0.1.0

package/factory/scaffold/mcp/test/mcp/surface.test.ts

@@ -0,0 +1,100 @@
+/**
+ * The one test that talks the actual protocol.
+ *
+ * guard.test.ts and redact.test.ts check the policy in isolation; this one
+ * wires a real client to a real server over an in-memory transport pair and
+ * asserts the surface an agent would actually see. It is the difference between
+ * "the manifest is well-formed" and "the server built from that manifest
+ * answers tools/list and tools/call".
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { describe, expect, it } from 'vitest';
+import { buildServer, loadManifest } from '../../src/mcp/server.js';
+
+interface TextContent {
+  type: string;
+  text: string;
+}
+
+async function connectedClient(): Promise<Client> {
+  const server = buildServer(loadManifest());
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  const client = new Client({ name: 'surface-test', version: '0.0.0' });
+  await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
+  return client;
+}
+
+function textOf(result: { content?: unknown }): string {
+  const content = result.content as TextContent[] | undefined;
+  return content?.[0]?.text ?? '';
+}
+
+describe('the MCP surface', () => {
+  it('advertises exactly the tools the manifest declares, and nothing else', async () => {
+    const manifest = loadManifest();
+    const client = await connectedClient();
+
+    const { tools } = await client.listTools();
+
+    expect(tools.map((tool) => tool.name).sort()).toEqual(
+      manifest.tools.map((tool) => tool.name).sort(),
+    );
+    await client.close();
+  });
+
+  it('carries the manifest annotations through to the client', async () => {
+    const client = await connectedClient();
+
+    const { tools } = await client.listTools();
+    const health = tools.find((tool) => tool.name === 'project_health');
+
+    // An agent decides whether a call is safe from these hints, so they have to
+    // survive the trip — asserting them on the manifest alone would not prove it.
+    expect(health?.annotations?.readOnlyHint).toBe(true);
+    expect(health?.annotations?.destructiveHint).toBe(false);
+    expect(health?.annotations?.openWorldHint).toBe(false);
+    await client.close();
+  });
+
+  it('answers project_health with the server identity', async () => {
+    const manifest = loadManifest();
+    const client = await connectedClient();
+
+    const result = await client.callTool({ name: 'project_health', arguments: {} });
+    const payload = JSON.parse(textOf(result)) as Record<string, unknown>;
+
+    expect(payload.name).toBe(manifest.name);
+    expect(payload.version).toBe(manifest.version);
+    expect(payload.transport).toBe('stdio');
+    expect(payload.tools).toBeUndefined();
+    await client.close();
+  });
+
+  it('lists the declared surface when asked verbosely', async () => {
+    const client = await connectedClient();
+
+    const result = await client.callTool({
+      name: 'project_health',
+      arguments: { verbose: true },
+    });
+    const payload = JSON.parse(textOf(result)) as { tools?: { name: string }[] };
+
+    expect(payload.tools?.map((tool) => tool.name)).toContain('project_health');
+    await client.close();
+  });
+
+  it('rejects an argument that is not in the tool input schema', async () => {
+    const client = await connectedClient();
+
+    const result = await client.callTool({
+      name: 'project_health',
+      arguments: { verbose: 'yes-please' },
+    });
+
+    // Typed input schemas (MCP-P4) are the reason unvalidated arguments never
+    // reach tool code; a wrong type has to come back as an error, not a crash.
+    expect(result.isError).toBe(true);
+    await client.close();
+  });
+});

package/factory/scaffold/ui/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>__PROJECT_NAME__</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

package/factory/scaffold/ui/package.fragment.json

@@ -0,0 +1,13 @@
+{
+  "scripts": {
+    "dev": "vite",
+    "build:ui": "vite build"
+  },
+  "dependencies": {
+    "vue": "3.5.40"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "6.0.8",
+    "vite": "8.2.0"
+  }
+}

package/factory/scaffold/ui/src/App.vue

@@ -0,0 +1,10 @@
+<script setup lang="ts">
+// Scaffold stub — replace with the project's first real page.
+</script>
+
+<template>
+  <main class="app">
+    <h1>__PROJECT_NAME__</h1>
+    <p>Styles start in <code>src/styles/main.css</code>.</p>
+  </main>
+</template>

package/factory/scaffold/ui/src/main.ts

@@ -0,0 +1,5 @@
+import { createApp } from 'vue';
+import App from './App.vue';
+import './styles/main.css';
+
+createApp(App).mount('#app');

package/factory/scaffold/ui/src/shims.d.ts

@@ -0,0 +1,11 @@
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue';
+
+  const component: DefineComponent<Record<string, never>, Record<string, never>, unknown>;
+  export default component;
+}
+
+// Side-effect asset imports (main.ts's `import './styles/main.css'`) need an
+// ambient module declaration too, or tsc/vue-tsc fails the build on the
+// first `--ui` scaffold typecheck (TS2882-class "cannot find module").
+declare module '*.css';

package/factory/scaffold/ui/vite.config.ts

@@ -0,0 +1,20 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import vue from '@vitejs/plugin-vue';
+import { defineConfig } from 'vite';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  root: here,
+  plugins: [vue()],
+  resolve: {
+    alias: {
+      '@': path.join(here, 'src'),
+    },
+  },
+  build: {
+    outDir: path.join(here, 'dist'),
+    emptyOutDir: true,
+  },
+});

package/factory/scaffold/ui-tailwind/package.fragment.json

@@ -0,0 +1,6 @@
+{
+  "devDependencies": {
+    "@tailwindcss/vite": "4.3.3",
+    "tailwindcss": "4.3.3"
+  }
+}

package/factory/scaffold/ui-tailwind/vite.config.ts

@@ -0,0 +1,26 @@
+// The Tailwind variant of this project's Vite config, chosen when the stack
+// answers named `styling: tailwind`. Identical to the plain
+// one but for the plugin — kept as a whole file rather than a patch because
+// `copyTemplateDir` layers files, and a config assembled from fragments is a
+// config nobody can read in one place.
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import tailwindcss from '@tailwindcss/vite';
+import vue from '@vitejs/plugin-vue';
+import { defineConfig } from 'vite';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  root: here,
+  plugins: [vue(), tailwindcss()],
+  resolve: {
+    alias: {
+      '@': path.join(here, 'src'),
+    },
+  },
+  build: {
+    outDir: path.join(here, 'dist'),
+    emptyOutDir: true,
+  },
+});

package/factory/specs/schema/event.schema.json

@@ -0,0 +1,82 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://black-smith.dev/schema/event.schema.json",
+  "$comment": "Taxonomy-valued fields carry an x-taxonomy annotation naming the dimension in factory/policies/taxonomy.yml. The runtime validates those values against that file at write time; enums are never inlined here to avoid drift between the schema and the taxonomy (architecture §8).",
+  "title": "Event",
+  "description": "One record in state/events/*.jsonl, the factory's durable execution substrate (architecture §7). Field names follow §7's record shape exactly: {ts, session_id, actor, event_type, task_id?, agent_id?, plan_version, causal_parent, payload}.",
+  "type": "object",
+  "required": [
+    "ts",
+    "session_id",
+    "actor",
+    "event_type",
+    "plan_version",
+    "causal_parent",
+    "payload"
+  ],
+  "properties": {
+    "ts": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "session_id": {
+      "type": "string",
+      "description": "Names one event log file -- logPath() interpolates it into <dir>/<session_id>.jsonl -- and is also the key half of an event id, <session-id>#<index>. So it must be a single non-empty path segment. Structural, not a charset: '#' stays legal because parseEventId splits on the LAST one deliberately, and a '#' cannot move a file. This mirrors requireSessionIdShape() in events.ts, which guards every read and every write; an id that validator can already open satisfies this by construction, so no record on disk is rejected by it (D-197).",
+      "minLength": 1,
+      "pattern": "^[^/]+$",
+      "not": { "enum": [".", ".."] }
+    },
+    "actor": {
+      "type": "string",
+      "description": "Who emitted the event: 'user', 'system', an agent role, or a concrete agent_id."
+    },
+    "event_type": {
+      "type": "string",
+      "description": "Free string, not an enum — a closed list here would reject a new event type at write time and lose the record. e.g. user_prompt, dispatch_decision, error-logged, or one of the gate_event / graph_event taxonomy values (taxonomy.yml)."
+    },
+    "task_id": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Optional — absent for session-level or epic-level events. Absence is the whole signal (agents-registry.ts folds a dispatch with no task id as epic-level), so \"\" is not a way to say it: minLength 1 keeps the field to two states instead of three (D-244)."
+    },
+    "agent_id": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Optional — concrete instance id (e.g. coder-142), not a taxonomy role. Present means it names an instance; \"\" names none, so it is refused rather than written (D-244)."
+    },
+    "plan_version": {
+      "type": "integer",
+      "minimum": 1
+    },
+    "causal_parent": {
+      "type": ["string", "null"],
+      "description": "Event id of the event that caused this one; null only for session-root events."
+    },
+    "payload": {
+      "type": "object",
+      "description": "Event-type-specific body."
+    },
+    "project": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Optional plain-string project identifier (Phase 6b, architecture §8) — NOT a closed taxonomy.yml vocabulary value, so no x-taxonomy annotation here. Absent on every event logged before Phase 6b; db/queries.ts's read helpers treat an absent/null project as the default 'black-smith'. That default is reached by absence, so \"\" would slip past it and name a project called nothing (D-244)."
+    },
+    "edge": {
+      "type": "object",
+      "description": "Present only on edge-recorded events (architecture §7).",
+      "required": ["edge_type", "edge_provenance"],
+      "properties": {
+        "edge_type": {
+          "type": "string",
+          "x-taxonomy": "edge_type"
+        },
+        "edge_provenance": {
+          "type": "string",
+          "x-taxonomy": "edge_provenance"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

package/factory/specs/schema/finding-evidence.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://black-smith.dev/schema/finding-evidence.schema.json",
+  "$comment": "Taxonomy-valued fields carry an x-taxonomy annotation naming the dimension in factory/policies/taxonomy.yml. The runtime validates those values against that file at write time; enums are never inlined here to avoid drift between the schema and the taxonomy (architecture §8).",
+  "title": "Finding Evidence",
+  "description": "What a judge actually returns when its mandate is to FIND: evidence, no identity. finding.schema.json describes the record the orchestrator stores, and requires six fields a judge cannot know — finding_id, task_id, fingerprint, finding_status, found_by, found_by_provider — which findings.ts then refuses to accept from a judge (findings.evidence-carries-identity). Asking an external finder for that shape means asking it to invent a sha256 and a status, and throwing both away. This schema is the judge's half of the contract; mintFindings() adds the other half.",
+  "type": "object",
+  "required": ["file_path", "finding_category", "severity", "summary", "failure_scenario"],
+  "properties": {
+    "file_path": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Repo-relative path the finding is anchored to, normalized (forward slashes, no leading ./). The fingerprint's first component."
+    },
+    "finding_category": {
+      "type": "string",
+      "x-taxonomy": "finding_category"
+    },
+    "severity": {
+      "type": "string",
+      "x-taxonomy": "severity"
+    },
+    "summary": {
+      "type": "string",
+      "minLength": 1
+    },
+    "failure_scenario": {
+      "type": "object",
+      "description": "Concrete inputs -> wrong output. A finding without one dies at verify (agent-interviews.md V-2).",
+      "required": ["inputs", "expected", "actual"],
+      "properties": {
+        "inputs": { "type": "string" },
+        "expected": { "type": "string" },
+        "actual": { "type": "string" }
+      },
+      "additionalProperties": false
+    },
+    "criterion_ref": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Which acceptance criterion the evidence is against. Evidence, not identity: a spec reviewer legitimately knows which criterion it read, and cannot know the plan version it was dispatched on."
+    }
+  },
+  "additionalProperties": false
+}

package/factory/specs/schema/finding.schema.json

@@ -0,0 +1,115 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://black-smith.dev/schema/finding.schema.json",
+  "$comment": "Taxonomy-valued fields carry an x-taxonomy annotation naming the dimension in factory/policies/taxonomy.yml. The runtime validates those values against that file at write time; enums are never inlined here to avoid drift between the schema and the taxonomy (architecture §8).",
+  "title": "Review Finding",
+  "description": "One reviewer/verifier finding. Verifier's mandate is to refute, not confirm (architecture §6); a finding survives only with a concrete failure scenario (agent-interviews.md V-2).",
+  "type": "object",
+  "required": [
+    "finding_id",
+    "task_id",
+    "fingerprint",
+    "file_path",
+    "finding_category",
+    "severity",
+    "finding_status",
+    "summary",
+    "failure_scenario",
+    "found_by"
+  ],
+  "properties": {
+    "finding_id": { "type": "string" },
+    "task_id": { "type": "string" },
+    "epic_id": {
+      "type": "string",
+      "minLength": 1,
+      "description": "The epic this finding belongs to. Optional, not required: findings raised before this field existed carry the epic in the task_id prefix instead, and a task_id that names no epic yields no epic_id rather than a guessed one (D-49/P9-10)."
+    },
+    "fingerprint": {
+      "type": "string",
+      "description": "Stable hash identifying this finding for dedup and waiver lookup; waived findings are suppressed in future reviews of the same code by fingerprint match."
+    },
+    "file_path": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Repo-relative path the finding is anchored to, normalized (forward slashes, no leading ./). The fingerprint's first component, kept as a field because a hash cannot be joined against a task's claims: dispatch-time context and the stale-evidence check both need the path itself (P9-15)."
+    },
+    "finding_category": {
+      "type": "string",
+      "x-taxonomy": "finding_category"
+    },
+    "severity": {
+      "type": "string",
+      "x-taxonomy": "severity"
+    },
+    "finding_status": {
+      "type": "string",
+      "x-taxonomy": "finding_status"
+    },
+    "finding_scope": {
+      "type": "string",
+      "x-taxonomy": "finding_scope",
+      "description": "Absent means `diff` — findings written before the dimension existed carry no scope. `spec` says the code is right and the plan is wrong; such a finding blocks the plan, never the diff (P9-9/D-33), and requires spec_ref."
+    },
+    "spec_ref": {
+      "type": "object",
+      "description": "Which criterion of which plan version the spec finding is against. Required when finding_scope is `spec` and forbidden otherwise — enforced in findings.ts, not here, because a JSON-Schema `if/then` would have to inline the taxonomy value `spec` (see $comment).",
+      "required": ["plan_version", "criterion_ref"],
+      "properties": {
+        "plan_version": { "type": "integer", "minimum": 1 },
+        "criterion_ref": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "summary": {
+      "type": "string",
+      "minLength": 1
+    },
+    "failure_scenario": {
+      "type": "object",
+      "description": "Concrete inputs -> wrong output. A finding without one dies at verify (agent-interviews.md V-2).",
+      "required": ["inputs", "expected", "actual"],
+      "properties": {
+        "inputs": { "type": "string" },
+        "expected": { "type": "string" },
+        "actual": { "type": "string" }
+      },
+      "additionalProperties": false
+    },
+    "found_by": {
+      "type": "string",
+      "x-taxonomy": "agent"
+    },
+    "found_by_provider": {
+      "type": "string",
+      "x-taxonomy": "provider"
+    },
+    "verified_by": {
+      "type": "string",
+      "x-taxonomy": "agent"
+    },
+    "verified_by_provider": {
+      "type": "string",
+      "x-taxonomy": "provider"
+    },
+    "same_mistake_of_lesson_id": {
+      "type": ["string", "null"],
+      "description": "Set when this finding matches an approved lesson; auto-escalates one severity level (architecture §9.7)."
+    },
+    "waiver_id": {
+      "type": ["string", "null"],
+      "description": "Set once an S3/S4 finding has been waived by the operator; keyed by fingerprint, never re-asked."
+    },
+    "amends_task_ids": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Set once an amendment took this finding to `amend-pending`: the task ids that amendment added or superseded. They are the finding's discharge condition — until they land it cannot reach `amended`. Without them an amendment closes an unwaivable S1/S2 spec finding at plan-write time, naming no task outcome at all (D-127)."
+    },
+    "amends_plan_version": {
+      "type": "integer",
+      "minimum": 1,
+      "description": "The plan version that amendment cut, so `amends_task_ids` can be resolved against the version that defines them (D-127)."
+    }
+  },
+  "additionalProperties": false
+}

package/factory/specs/schema/grader-verdict.schema.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://black-smith.dev/schema/grader-verdict.schema.json",
+  "title": "Grader Verdict",
+  "description": "The rubric result a grader writes into the `structured_output` of state/results/<task-id>.grader-r<round>.json (.claude/agents/grader.md, 'Output contract'). It validates the verdict, not the envelope around it: the envelope is a result and validates against result.schema.json. `status` and `overall` are plain structural enums, not taxonomy dimensions — they describe whether a criterion was met, not a controlled-vocabulary classification (architecture §8 draws that line at classification fields only). `round` is capped at 2 because the grader's loop is a hard stop at two rounds, not a suggestion.",
+  "type": "object",
+  "required": ["round", "criteria", "overall"],
+  "properties": {
+    "round": {
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 2
+    },
+    "criteria": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["criterion", "status", "evidence"],
+        "properties": {
+          "criterion": {
+            "type": "string",
+            "minLength": 1
+          },
+          "status": {
+            "type": "string",
+            "enum": ["pass", "fail", "partial"]
+          },
+          "evidence": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "overall": {
+      "type": "string",
+      "enum": ["pass", "fail"]
+    },
+    "gaps": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/factory/specs/schema/judge-verdict.schema.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://black-smith.dev/schema/judge-verdict.schema.json",
+  "title": "Judge Verdict",
+  "description": "Generic binary verdict returned by an external judge for a 'verify' or 'plan-critique' JudgeRequest (architecture §6, Phase 8): does this provider agree with the native claim under judgment (a blocking finding, an epic-final verdict, ...)? A 'review' JudgeRequest validates against finding.schema.json instead (an array of findings), not this schema. `verdict` is a plain structural enum, not a taxonomy dimension — it describes a judge's agree/disagree stance, not a controlled-vocabulary tag (architecture §8 draws that line at classification fields only).",
+  "type": "object",
+  "required": ["verdict", "rationale"],
+  "properties": {
+    "verdict": {
+      "type": "string",
+      "enum": ["confirm", "refute"]
+    },
+    "rationale": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "additionalProperties": false
+}

package/factory/specs/schema/lesson.schema.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://black-smith.dev/schema/lesson.schema.json",
+  "$comment": "Taxonomy-valued fields carry an x-taxonomy annotation naming the dimension in factory/policies/taxonomy.yml. The runtime validates those values against that file at write time; enums are never inlined here to avoid drift between the schema and the taxonomy (architecture §8).",
+  "title": "Lesson",
+  "description": "A typed, principle-level memory entry (architecture §9). Instance-level transcripts are rejected at the gate. Bi-temporal supersession with provenance: nothing self-modifies without operator approval.",
+  "type": "object",
+  "required": [
+    "lesson_id",
+    "lesson_type",
+    "lesson_level",
+    "lesson_status",
+    "lesson_scope",
+    "statement",
+    "valid_from",
+    "superseded_by",
+    "provenance_event_ids"
+  ],
+  "properties": {
+    "lesson_id": { "type": "string" },
+    "lesson_type": {
+      "type": "string",
+      "x-taxonomy": "lesson_type"
+    },
+    "lesson_level": {
+      "type": "string",
+      "x-taxonomy": "lesson_level"
+    },
+    "lesson_status": {
+      "type": "string",
+      "x-taxonomy": "lesson_status"
+    },
+    "lesson_scope": {
+      "type": "string",
+      "x-taxonomy": "lesson_scope"
+    },
+    "statement": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Abstract, transferable, checkable principle — never an instance-level transcript."
+    },
+    "valid_from": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "superseded_by": {
+      "type": ["string", "null"],
+      "description": "lesson_id of the lesson that superseded this one, or null."
+    },
+    "invalidated_by_event_id": {
+      "type": ["string", "null"],
+      "description": "Set when a later run contradicts this lesson (lesson_status: invalidated)."
+    },
+    "provenance_event_ids": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1,
+      "description": "Event-log entries that produced this lesson (traceable, never silent deletion)."
+    },
+    "evidence": {
+      "type": "string",
+      "description": "Short excerpt/summary of the error or decision checkpoint that generated this candidate."
+    },
+    "finding_category": {
+      "type": "string",
+      "x-taxonomy": "finding_category",
+      "description": "Phase 7 (lessons.ts): optional — only meaningful for a `rule`-typed, claim-path/stack-wide-scoped entry. Compiled into lessons.md's same-mistake entry format so severity.ts can match a new finding's category against it (architecture §9.7). Not required at write time — agent-role/case-type-scoped entries never carry one (lessons.md: \"do not participate in this per-file match\")."
+    },
+    "claim_path": {
+      "type": "string",
+      "description": "Phase 7 (lessons.ts): optional glob (picomatch), meaningful only for claim-path/stack-wide-scoped entries — the file pattern this lesson's same-mistake match applies to. Omitted/treated as \"**\" for stack-wide entries (lessons.md convention)."
+    },
+    "agent_role": {
+      "type": "string",
+      "x-taxonomy": "agent",
+      "description": "D-129: the selector an agent-role-scoped entry is filtered by at dispatch — required for that scope and ignored for every other. Without it the entry reaches no role at all, because the three selector scopes (claim-path/agent-role/case-type) each filter on exactly one field and a missing selector matches nothing rather than everything."
+    },
+    "case_type": {
+      "type": "string",
+      "x-taxonomy": "case",
+      "description": "D-129: the selector a case-type-scoped entry is filtered by at dispatch — the taxonomy `case` of the dispatching task, read off the immutable plan. Required for that scope, ignored for every other."
+    }
+  },
+  "additionalProperties": false
+}