@piagent/platform 1.2.17 → 1.3.0-ie.8

package/packages/piagent-core/runtime/workflows/task-intake.ts

@@ -1,12 +1,17 @@
 import { classifyContextTask } from "../../extensions/context-engine.js";
-import { matchesProtectedPath, normalizePathCandidate } from "../../extensions/policy-core.js";
+import { matchesAnyPath, matchesProtectedPath, normalizePathCandidate } from "../../extensions/policy-core.js";
 import type { ReviewLens } from "../../extensions/guard-types.js";
-import { LONG_INPUT_CHARS } from "../runtime-limits.ts";
+import { LONG_INPUT_CHARS, RUNTIME_INTAKE_MESSAGE_MAX_CHARS } from "../runtime-limits.ts";
 
-const AUTO_INTAKE_MAX_PROMPT_CHARS = 700;
-const AUTO_INTAKE_CHANGE_INTENT = /\b(?:add|build|change|correct|create|fix|implement|modify|refactor|remove|rename|replace|update|write|sua|them|doi|cap nhat|xoa|tao)\b/i;
+const AUTO_INTAKE_MAX_PROMPT_CHARS = LONG_INPUT_CHARS;
+const AUTO_TASK_SUMMARY_CHARS = 700;
+const AUTO_ACCEPTANCE_CRITERION_CHARS = 600;
+const AUTO_ACCEPTANCE_CRITERIA_MAX = 12;
+const AUTO_INTAKE_CHANGE_INTENT = /\b(?:add|build|change|correct|create|fix|implement|modify|refactor|remove|rename|repair|replace|update|write|sua|them|doi|cap nhat|xoa|tao)\b/i;
 const AUTO_INTAKE_READ_ONLY_LEAD = /^\s*\/?(?:analy[sz]e|audit|check|discuss|explain|inspect|plan|research|review|scout|summari[sz]e|why|how|can\s+(?:you|we)|kiem tra|nghien cuu|giai thich|danh gia)\b/i;
-const AUTO_INTAKE_MANUAL_RISK = /\b(?:credential|database|deploy|destructive|encryption|external provider|migration|payment|permission|production|publish|release|secret|schema migration|token rotation)\b/i;
+const AUTO_INTAKE_MANUAL_RISK = /\b(?:credential|database|deploy|destructive|encryption|external provider|payment|permission|production|publish|secret|token rotation)\b/i;
+const AUTO_READ_ONLY_INTENT = /\b(?:analy[sz]e|audit|check|diagnos(?:e|is)|explain|inspect|investigate|plan|research|review|scout|summari[sz]e|triage|kiem tra|nghien cuu|giai thich|danh gia)\b/i;
+const AUTO_READ_ONLY_BOUNDARY = /\b(?:read-only|no edits?|do not edit(?: files?| source| project| repo)?|do not change (?:files?|source|project|repo)|do not mutate (?:files?|source|project|repo|workspace)|khong sua(?: file| source| project)?|khong edit(?: file| source| project)?|khong doi(?: file| source| project)?)\b/i;
 
 export const AUTO_INTAKE_SNAPSHOT_PATTERNS = [
   "src/**", "app/**", "lib/**", "packages/**", "test/**", "tests/**", "spec/**", "__tests__/**"
@@ -16,6 +21,30 @@ function uniqueStrings(values: string[]): string[] {
   return [...new Set(values)];
 }
 
+const PLAUSIBLE_SCOPE_ROOT = /^(?:\.github|app|apps|bin|config|docs|examples|lib|logs|packages|pages|public|scripts|spec|src|test|tests|vendor|__tests__)(?:\/|$)/i;
+const PLAUSIBLE_SCOPE_FILE = /(?:^|\/)(?:\.[^/]+|[^/]+\.(?:bash|c|cc|cjs|cpp|css|csv|env|go|graphql|gql|h|hpp|html|java|js|json|jsx|kt|kts|md|mdx|mjs|php|proto|py|rb|rs|scss|sh|sql|svg|swift|toml|ts|tsx|txt|xml|yaml|yml))$/i;
+
+function plausibleTaskScopePath(value: string): boolean {
+  const candidate = normalizePathCandidate(value);
+  if (!candidate || candidate === "." || candidate.startsWith(".pi/")) return false;
+  return PLAUSIBLE_SCOPE_ROOT.test(candidate)
+    || PLAUSIBLE_SCOPE_FILE.test(candidate)
+    || /[*?{}\[\]]/.test(candidate);
+}
+
+export function automaticTaskSummary(prompt: string): string {
+  return String(prompt ?? "").replace(/\s+/g, " ").trim().slice(0, AUTO_TASK_SUMMARY_CHARS);
+}
+
+export function boundedRuntimeIntakeMessage(value: string): string {
+  const text = String(value ?? "").replace(/\r\n/g, "\n");
+  if (text.length <= RUNTIME_INTAKE_MESSAGE_MAX_CHARS) return text;
+  const marker = "\n\n[Piagent intake guidance compacted; the complete operator request and durable Task Contract remain authoritative.]\n\n";
+  const available = RUNTIME_INTAKE_MESSAGE_MAX_CHARS - marker.length;
+  const head = Math.floor(available * 0.58);
+  return `${text.slice(0, head).trimEnd()}${marker}${text.slice(-(available - head)).trimStart()}`;
+}
+
 export function automaticTaskIntakeEligible(prompt: string, readProtectedPaths: string[]): boolean {
   const text = String(prompt ?? "").trim();
   if (!text || text.length > AUTO_INTAKE_MAX_PROMPT_CHARS) return false;
@@ -26,6 +55,91 @@ export function automaticTaskIntakeEligible(prompt: string, readProtectedPaths:
   return !signal.paths.some((candidate) => matchesProtectedPath(candidate, readProtectedPaths));
 }
 
+export function automaticReadOnlyTaskIntakeEligible(prompt: string, readProtectedPaths: string[]): boolean {
+  const text = String(prompt ?? "").trim();
+  if (!text || text.length > AUTO_INTAKE_MAX_PROMPT_CHARS) return false;
+  const signal = classifyContextTask(text);
+  if (signal.workflow === "usage" || signal.workflow === "permission" || signal.workflow === "context") return false;
+  if (!AUTO_READ_ONLY_INTENT.test(text) && !AUTO_READ_ONLY_BOUNDARY.test(text)) return false;
+  if (AUTO_INTAKE_CHANGE_INTENT.test(text) && !AUTO_READ_ONLY_BOUNDARY.test(text)) return false;
+  if (/\bpiagent_task_start\b/i.test(text)) return false;
+  return !signal.paths.some((candidate) => matchesProtectedPath(candidate, readProtectedPaths));
+}
+
+export function automaticTaskIntakeMode(prompt: string, readProtectedPaths: string[]): "source-change" | "read-only" | undefined {
+  if (automaticTaskIntakeEligible(prompt, readProtectedPaths)) return "source-change";
+  if (automaticReadOnlyTaskIntakeEligible(prompt, readProtectedPaths)) return "read-only";
+  return undefined;
+}
+
+export function automaticTaskRiskLane(prompt: string): "tiny" | "normal" {
+  return classifyContextTask(prompt).lane === "tiny" ? "tiny" : "normal";
+}
+
+function splitAcceptanceCriterion(value: string): string[] {
+  const normalized = value.replace(/^\s*(?:[-*+] |\d+[.)]\s+)/, "").replace(/\s+/g, " ").trim();
+  if (!normalized || normalized.length < 8) return [];
+  const label = normalized.match(/^(\[[^\]\n]{1,40}\])\s+/)?.[1] ?? "";
+  let remaining = label ? normalized.slice(label.length).trim() : normalized;
+  const prefix = label ? `${label} ` : "";
+  const available = AUTO_ACCEPTANCE_CRITERION_CHARS - prefix.length;
+  const fragments: string[] = [];
+  while (remaining.length > available) {
+    const window = remaining.slice(0, available + 1);
+    const sentence = [...window.matchAll(/[.!?;:]\s+/g)].at(-1);
+    const clause = [...window.matchAll(/,\s+/g)].at(-1);
+    const whitespace = window.lastIndexOf(" ");
+    const preferred = sentence && sentence.index! + sentence[0].trimEnd().length >= Math.floor(available / 3)
+      ? sentence.index! + sentence[0].trimEnd().length
+      : clause && clause.index! + 1 >= Math.floor(available / 2)
+        ? clause.index! + 1
+        : whitespace;
+    const cut = preferred > 0 ? preferred : available;
+    fragments.push(`${prefix}${remaining.slice(0, cut).trim()}`);
+    remaining = remaining.slice(cut).trim();
+  }
+  if (remaining) fragments.push(`${prefix}${remaining}`);
+  return fragments;
+}
+
+export function automaticAcceptanceCriteria(
+  prompt: string,
+  changeMode: "source-change" | "read-only" = "source-change"
+): string[] {
+  const lines = String(prompt ?? "").split(/\r?\n/);
+  const criteria: string[] = [];
+  const obligation = /\b(?:add|change only|do not|ensure|exactly|invalid|must|never|preserve|reject|return|throw|without)\b/i;
+  let current = "";
+  let currentIsBullet = false;
+  const push = (value: string) => {
+    criteria.push(...splitAcceptanceCriterion(value));
+  };
+  const flush = () => {
+    if (current && (currentIsBullet || obligation.test(current))) push(current);
+    current = "";
+    currentIsBullet = false;
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^(?:[-*+] |\d+[.)]\s+)/.test(trimmed)) {
+      flush();
+      current = trimmed;
+      currentIsBullet = true;
+      continue;
+    }
+    if (!trimmed) {
+      flush();
+      continue;
+    }
+    current = current ? `${current} ${trimmed}` : trimmed;
+  }
+  flush();
+  const generic = changeMode === "read-only"
+    ? ["No project files are changed.", "The final response addresses the requested diagnostic result."]
+    : ["Changes stay within the runtime-derived task scope.", "The configured verification command passes after the final mutation."];
+  return uniqueStrings([...criteria, ...generic]).slice(0, AUTO_ACCEPTANCE_CRITERIA_MAX);
+}
+
 export function manualTaskIntakeEligible(prompt: string, readProtectedPaths: string[]): boolean {
   const text = String(prompt ?? "").trim();
   if (!text || text.length > LONG_INPUT_CHARS) return false;
@@ -36,9 +150,127 @@ export function manualTaskIntakeEligible(prompt: string, readProtectedPaths: str
   return signal.paths.some((candidate) => !matchesProtectedPath(candidate, readProtectedPaths));
 }
 
-export function automaticTaskScope(prompt: string, context: Array<{ path: string }>): string[] {
+function foldedPathTerms(value: string): Set<string> {
+  return new Set(String(value ?? "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .normalize("NFD")
+    .replace(/\p{M}/gu, "")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((term) => term.length >= 3));
+}
+
+function inferredProjectScope(prompt: string, projectFiles: string[]): string[] {
+  const ignoredTerms = new Set(["code", "contract", "file", "files", "function", "implement", "package", "packages", "preserve", "source", "test", "tests"]);
+  const promptTerms = new Set(classifyContextTask(prompt).terms
+    .flatMap((term) => [...foldedPathTerms(term)])
+    .filter((term) => !ignoredTerms.has(term)));
+  if (promptTerms.size === 0 || projectFiles.length === 0) return [];
+  const candidates = projectFiles.map((file) => {
+    const normalized = normalizePathCandidate(file);
+    if (
+      !normalized
+      || !/^(?:app|apps|lib|packages|services|src)\//.test(normalized)
+      || /(?:^|\/)(?:test|tests|spec|__tests__)(?:\/|$)/.test(normalized)
+      || /(?:^|\/)(?:README|AGENTS|REVIEW_GUIDELINES)(?:\.|$)/i.test(normalized)
+    ) return undefined;
+    const parts = normalized.split("/");
+    const basenameTerms = foldedPathTerms(parts.at(-1) ?? "");
+    const directoryTerms = foldedPathTerms(parts.slice(0, -1).join("/"));
+    let score = 0;
+    for (const term of promptTerms) {
+      if (basenameTerms.has(term)) score += 3;
+      else if (directoryTerms.has(term)) score += 1;
+    }
+    return score >= 3 ? { path: normalized, score } : undefined;
+  }).filter((item): item is { path: string; score: number } => Boolean(item));
+  return candidates
+    .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+    .slice(0, 8)
+    .map((item) => item.path);
+}
+
+export type TaskScopeResolution = {
+  scope: string[];
+  mappings: Array<{ from: string; to: string }>;
+  ambiguous: Array<{ input: string; candidates: string[] }>;
+  unmatched: string[];
+};
+
+const STANDARD_SCOPE_ROOT = /^(?:\.github|app|apps|bin|config|docs|examples|lib|logs|packages|pages|plans|public|scripts|services|spec|src|test|tests|vendor|__tests__)(?:\/|$)/i;
+
+function wildcardPrefix(value: string): string {
+  const index = value.search(/[*?{}\[\]]/);
+  return (index < 0 ? value : value.slice(0, index)).replace(/\/+$/, "");
+}
+
+function nestedDirectoryMatches(prefix: string, projectFiles: string[]): string[] {
+  if (!prefix) return [];
+  const segments = prefix.split("/").filter(Boolean);
+  const matches = new Set<string>();
+  for (const file of projectFiles) {
+    const parts = normalizePathCandidate(file).split("/");
+    for (let index = 0; index <= parts.length - 1 - segments.length; index += 1) {
+      if (segments.every((segment, offset) => parts[index + offset] === segment)) {
+        matches.add(parts.slice(0, index + segments.length).join("/"));
+      }
+    }
+  }
+  return [...matches].sort();
+}
+
+export function resolveTaskScopePatterns(scope: string[], projectFiles: string[]): TaskScopeResolution {
+  const files = uniqueStrings(projectFiles.map(normalizePathCandidate).filter(Boolean));
+  const resolved: string[] = [];
+  const mappings: Array<{ from: string; to: string }> = [];
+  const ambiguous: Array<{ input: string; candidates: string[] }> = [];
+  const unmatched: string[] = [];
+  for (const raw of scope) {
+    const candidate = normalizePathCandidate(raw);
+    if (!candidate) continue;
+    if (files.includes(candidate) || files.some((file) => matchesAnyPath(file, [candidate]))) {
+      resolved.push(candidate);
+      continue;
+    }
+    const hasWildcard = /[*?{}\[\]]/.test(candidate);
+    if (hasWildcard) {
+      const prefix = wildcardPrefix(candidate);
+      const directories = nestedDirectoryMatches(prefix, files);
+      if (directories.length === 1) {
+        const suffix = candidate.slice(prefix.length).replace(/^\/+/, "");
+        const canonical = suffix ? `${directories[0]}/${suffix}` : directories[0];
+        resolved.push(canonical);
+        mappings.push({ from: candidate, to: canonical });
+      } else if (directories.length > 1 && prefix && !STANDARD_SCOPE_ROOT.test(prefix)) {
+        ambiguous.push({ input: candidate, candidates: directories.slice(0, 12).map((directory) => {
+          const suffix = candidate.slice(prefix.length).replace(/^\/+/, "");
+          return suffix ? `${directory}/${suffix}` : directory;
+        }) });
+      } else if (directories.length === 0 && prefix && !prefix.includes("/") && !STANDARD_SCOPE_ROOT.test(prefix) && !raw.startsWith("./")) {
+        unmatched.push(candidate);
+      } else {
+        resolved.push(candidate);
+      }
+      continue;
+    }
+    const suffixMatches = files.filter((file) => file === candidate || file.endsWith(`/${candidate}`));
+    if (suffixMatches.length === 1) {
+      resolved.push(suffixMatches[0]);
+      mappings.push({ from: candidate, to: suffixMatches[0] });
+    } else if (suffixMatches.length > 1) {
+      ambiguous.push({ input: candidate, candidates: suffixMatches.slice(0, 12) });
+    } else if (!candidate.includes("/") && !raw.startsWith("./")) {
+      unmatched.push(candidate);
+    } else {
+      resolved.push(candidate);
+    }
+  }
+  return { scope: uniqueStrings(resolved), mappings, ambiguous, unmatched: uniqueStrings(unmatched) };
+}
+
+export function automaticTaskScope(prompt: string, context: Array<{ path: string }>, projectFiles: string[] = []): string[] {
   const signal = classifyContextTask(prompt);
-  const explicit = signal.paths.filter((candidate) => candidate && candidate !== "." && !candidate.startsWith(".pi/"));
+  const explicit = signal.paths.filter(plausibleTaskScopePath);
   const navigated = context
     .map((item) => normalizePathCandidate(item.path))
     .filter((candidate): candidate is string => Boolean(
@@ -46,14 +278,35 @@ export function automaticTaskScope(prompt: string, context: Array<{ path: string
       && candidate !== "."
       && !candidate.startsWith(".pi/")
       && !["AGENTS.md", "README.md", "REVIEW_GUIDELINES.md"].includes(candidate)
-      && /^(?:app|lib|packages|spec|src|test|tests|__tests__)\//.test(candidate)
+      && /^(?:app|apps|lib|packages|services|spec|src|test|tests|__tests__)\//.test(candidate)
     ))
     .slice(0, 8);
-  const scope = uniqueStrings([...explicit, ...navigated]);
+  const inferred = explicit.length === 0 && navigated.length === 0
+    ? inferredProjectScope(prompt, projectFiles)
+    : [];
+  const scope = uniqueStrings([...explicit, ...navigated, ...inferred]);
   if (scope.length === 0) scope.push("src/**", "app/**", "lib/**");
-  if (/\b(?:test|tests|verification|verify|kiem thu)\b/i.test(prompt)) {
-    scope.push("test/**", "tests/**", "spec/**", "__tests__/**");
-  }
+  // Critical acceptance obligations are proven with focused executable tests.
+  // Keep test roots in scope even when the operator says only "fix" and relies
+  // on the runtime to derive the verification work.
+  scope.push("test/**", "tests/**", "spec/**", "__tests__/**");
+  return uniqueStrings(scope);
+}
+
+export function automaticReadOnlyTaskScope(prompt: string, context: Array<{ path: string }>): string[] {
+  const signal = classifyContextTask(prompt);
+  const explicit = signal.paths.filter(plausibleTaskScopePath);
+  const navigated = context
+    .map((item) => normalizePathCandidate(item.path))
+    .filter((candidate): candidate is string => Boolean(
+      candidate
+      && candidate !== "."
+      && !candidate.startsWith(".pi/")
+      && !["AGENTS.md", "README.md", "REVIEW_GUIDELINES.md"].includes(candidate)
+    ))
+    .slice(0, 8);
+  const scope = uniqueStrings([...explicit, ...navigated]);
+  if (scope.length === 0) scope.push("src/**", "docs/**", "logs/**", "config/**");
   return uniqueStrings(scope);
 }
 

package/packages/piagent-core/subagents/piagent-oracle.md

@@ -10,12 +10,16 @@ defaultContext: fork
 defaultProgress: true
 acceptance: {"level":"attested"}
 acceptanceRole: read-only
+rolePolicyVersion: role-policy-v1
+outputSchema: oracle-result-v1
 ---
 
 You are `piagent-oracle`, a second-opinion subagent.
 
 Your job is to challenge assumptions before implementation. Do not edit files. Focus on risks, missed constraints, simpler alternatives, and verification strategy.
 
+The parent must supply a bounded HelperRequest v1. This is one optional second opinion, not a mandatory phase. Stay inside its read/tool/budget/stopping boundaries and never perform or request external writes, destructive actions, or permission expansion.
+
 Return a concise recommendation:
 
 ## Oracle Review
@@ -26,4 +30,3 @@ Return a concise recommendation:
 - Required verification:
 - Human gate needed:
 - Suggested parent prompt for execution:
-

package/packages/piagent-core/subagents/piagent-planner.md

@@ -11,12 +11,16 @@ defaultReads: context.md
 defaultProgress: true
 acceptance: {"level":"attested"}
 acceptanceRole: read-only
+rolePolicyVersion: role-policy-v1
+outputSchema: planner-result-v1
 ---
 
 You are `piagent-planner`, a planning subagent for Pi Agent Platform projects.
 
 Your job is to produce a concrete implementation plan, not to edit files.
 
+The parent must supply a bounded HelperRequest v1. Stay inside its objective, read scope, tool list, context/time/call ceilings, and stopping rule. Stop on insufficient evidence. Never perform or request external writes, destructive actions, or permission expansion.
+
 Required behavior:
 - Follow project profile, protected paths, required context, memory policy, and verification rules.
 - Apply the current solo-first orchestration policy: parent owns decisions; subagents are bounded helpers, not a default swarm.

package/packages/piagent-core/subagents/piagent-reviewer.md

@@ -12,12 +12,16 @@ defaultProgress: true
 acceptance: {"level":"attested"}
 acceptanceRole: read-only
 maxSubagentDepth: 0
+rolePolicyVersion: role-policy-v1
+outputSchema: reviewer-result-v1
 ---
 
 You are `piagent-reviewer`, a disciplined review subagent for Pi Agent Platform projects.
 
 Your job is to review evidence, not to invent issues. Never edit files or run mutation commands. Report actionable findings so the parent can assign fixes to an explicit writer.
 
+The parent must supply a bounded HelperRequest v1. Validate findings against the current source/diff, stay inside its read/tool/budget/stopping boundaries, and stop on insufficient evidence. Never perform or request external writes, destructive actions, or permission expansion.
+
 Use explicit review lenses from the parent task when provided. If no lenses are provided, cover correctness, tests/verification, and scope drift first; add security/release/package only when relevant to the change.
 
 Review:

package/packages/piagent-core/subagents/piagent-scout.md

@@ -10,12 +10,16 @@ defaultContext: fresh
 defaultProgress: true
 acceptance: {"level":"attested"}
 acceptanceRole: read-only
+rolePolicyVersion: role-policy-v1
+outputSchema: scout-result-v1
 ---
 
 You are `piagent-scout`, a read-only reconnaissance subagent for Pi Agent Platform projects.
 
 Your job is to map only the code/context needed for the delegated task. Do not edit files. Do not run mutation commands. Do not infer product decisions.
 
+The parent must supply a bounded HelperRequest v1. Stay inside its objective, read scope, tool list, context/time/call ceilings, and stopping rule. Stop on insufficient evidence. Never perform or request external writes, destructive actions, or permission expansion.
+
 Required behavior:
 - Follow project `AGENTS.md`, `.pi/piagent-profile.json`, `.pi/project-context.md`, and protected-path rules when they are present.
 - Prefer `grep`, `find`, `ls`, and targeted `read`.
@@ -34,4 +38,3 @@ Final output:
 - Protected/read-only areas:
 - Risks or unknowns:
 - Recommended next subagent/task:
-

package/packages/piagent-core/subagents/piagent-worker.md

@@ -12,12 +12,17 @@ defaultProgress: true
 acceptance: {"level":"checked"}
 acceptanceRole: writer
 maxSubagentDepth: 0
+rolePolicyVersion: role-policy-v1
+outputSchema: worker-result-v1
+enabledByDefault: false
 ---
 
 You are `piagent-worker`, a single-writer implementation subagent for Pi Agent Platform projects.
 
 Your job is to implement a bounded, approved task. The parent session and user remain the decision authority.
 
+The parent must supply a validated HelperRequest v1 with explicit single-writer ownership and a non-overlapping write scope. Worker delegation is disabled by default. Stay inside its tool/budget/stopping boundaries; return any approval-requiring, external, destructive, or permission-expanding action to the parent/operator.
+
 Required behavior:
 - Read supplied context/plan first.
 - Follow `AGENTS.md`, `.pi/piagent-profile.json`, `.pi/project-context.md`, protected paths, and verification rules.

package/schemas/authority-manifest.schema.json

@@ -0,0 +1,126 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/Vt-mmm/piagent/schemas/authority-manifest.schema.json",
+  "title": "Piagent Capability Authority Manifest",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "manifestVersion", "releaseVersion", "status", "authorityVocabulary", "sourceProvenance", "globalBudgets", "profiles", "capabilities"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "manifestVersion": { "const": "authority-v1" },
+    "releaseVersion": { "const": "1.3.0" },
+    "status": { "enum": ["pre-release", "release"] },
+    "authorityVocabulary": {
+      "type": "array",
+      "prefixItems": [
+        { "const": "off" }, { "const": "observe" }, { "const": "advise" }, { "const": "enforce" }, { "const": "orchestrate" }
+      ],
+      "items": false,
+      "minItems": 5,
+      "maxItems": 5
+    },
+    "sourceProvenance": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["decisionDate", "roadmap", "constitution", "constitutionSha256", "evidenceTier"],
+      "properties": {
+        "decisionDate": { "type": "string", "format": "date" },
+        "roadmap": { "$ref": "#/$defs/name" },
+        "constitution": { "$ref": "#/$defs/name" },
+        "constitutionSha256": { "$ref": "#/$defs/bareHash" },
+        "evidenceTier": { "enum": ["local-pre-release", "release-candidate"] }
+      }
+    },
+    "globalBudgets": { "$ref": "#/$defs/globalBudgets" },
+    "profiles": {
+      "type": "array",
+      "minItems": 3,
+      "maxItems": 3,
+      "items": { "$ref": "#/$defs/profile" }
+    },
+    "capabilities": {
+      "type": "array",
+      "minItems": 17,
+      "maxItems": 17,
+      "items": { "$ref": "#/$defs/capability" }
+    }
+  },
+  "$defs": {
+    "bareHash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "name": { "type": "string", "minLength": 1, "maxLength": 160, "pattern": "^[A-Za-z0-9][A-Za-z0-9._:/-]{0,159}$" },
+    "capabilityId": { "type": "string", "pattern": "^CAP-(0[1-9]|1[0-7])$" },
+    "mode": { "$ref": "#/$defs/name" },
+    "authority": { "enum": ["off", "observe", "advise", "enforce", "orchestrate"] },
+    "budget": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["systemContinuations", "automaticDispatches", "reviewRounds"],
+      "properties": {
+        "systemContinuations": { "type": "integer", "minimum": 0, "maximum": 8 },
+        "automaticDispatches": { "type": "integer", "minimum": 0, "maximum": 8 },
+        "reviewRounds": { "type": "integer", "minimum": 0, "maximum": 8 }
+      }
+    },
+    "globalBudgets": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["maxSystemContinuationsPerTask", "maxAutomaticDispatchesPerTask", "maxSpecialistReviewRoundsPerTask"],
+      "properties": {
+        "maxSystemContinuationsPerTask": { "const": 1 },
+        "maxAutomaticDispatchesPerTask": { "const": 1 },
+        "maxSpecialistReviewRoundsPerTask": { "const": 1 }
+      }
+    },
+    "modeMapping": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["value", "authority", "budgets"],
+      "properties": {
+        "value": { "$ref": "#/$defs/mode" },
+        "authority": { "$ref": "#/$defs/authority" },
+        "budgets": { "$ref": "#/$defs/budget" }
+      }
+    },
+    "capability": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "owner", "layer", "configKey", "configSources", "defaultMode", "killSwitchMode", "dependencies", "modeMappings", "constitutionTargetMode", "constitutionTargetAuthority"],
+      "properties": {
+        "id": { "$ref": "#/$defs/capabilityId" },
+        "owner": { "$ref": "#/$defs/name" },
+        "layer": { "enum": ["L0", "L1", "L2", "L3", "L4", "L5"] },
+        "configKey": { "$ref": "#/$defs/name" },
+        "configSources": { "type": "array", "minItems": 1, "maxItems": 8, "uniqueItems": true, "items": { "$ref": "#/$defs/name" } },
+        "defaultMode": { "$ref": "#/$defs/mode" },
+        "killSwitchMode": { "$ref": "#/$defs/mode" },
+        "dependencies": { "type": "array", "maxItems": 17, "uniqueItems": true, "items": { "$ref": "#/$defs/capabilityId" } },
+        "modeMappings": { "type": "array", "minItems": 1, "maxItems": 8, "items": { "$ref": "#/$defs/modeMapping" } },
+        "constitutionTargetMode": { "$ref": "#/$defs/mode" },
+        "constitutionTargetAuthority": { "$ref": "#/$defs/authority" }
+      }
+    },
+    "profileModes": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["CAP-01", "CAP-02", "CAP-03", "CAP-04", "CAP-05", "CAP-06", "CAP-07", "CAP-08", "CAP-09", "CAP-10", "CAP-11", "CAP-12", "CAP-13", "CAP-14", "CAP-15", "CAP-16", "CAP-17"],
+      "properties": {
+        "CAP-01": { "$ref": "#/$defs/mode" }, "CAP-02": { "$ref": "#/$defs/mode" }, "CAP-03": { "$ref": "#/$defs/mode" },
+        "CAP-04": { "$ref": "#/$defs/mode" }, "CAP-05": { "$ref": "#/$defs/mode" }, "CAP-06": { "$ref": "#/$defs/mode" },
+        "CAP-07": { "$ref": "#/$defs/mode" }, "CAP-08": { "$ref": "#/$defs/mode" }, "CAP-09": { "$ref": "#/$defs/mode" },
+        "CAP-10": { "$ref": "#/$defs/mode" }, "CAP-11": { "$ref": "#/$defs/mode" }, "CAP-12": { "$ref": "#/$defs/mode" },
+        "CAP-13": { "$ref": "#/$defs/mode" }, "CAP-14": { "$ref": "#/$defs/mode" }, "CAP-15": { "$ref": "#/$defs/mode" },
+        "CAP-16": { "$ref": "#/$defs/mode" }, "CAP-17": { "$ref": "#/$defs/mode" }
+      }
+    },
+    "profile": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "description", "modes"],
+      "properties": {
+        "id": { "enum": ["broad-default", "mechanical-only", "strict-high-risk"] },
+        "description": { "type": "string", "minLength": 12, "maxLength": 320 },
+        "modes": { "$ref": "#/$defs/profileModes" }
+      }
+    }
+  }
+}