@fro.bot/systematic 3.15.0 → 3.16.0

package/dist/cli.js

@@ -1,20 +1,53 @@
 #!/usr/bin/env node
 // @bun
 import {
+  parseFrontmatter,
+  parse,
+  parseTree,
+  modify,
   applyEdits,
-  discoverSkills,
-  exports_external,
+  _isoDateTime,
+  _isoDate,
+  _isoTime,
+  _isoDuration,
+  string,
+  ZodISODateTime,
+  ZodISODate,
+  ZodISOTime,
+  ZodISODuration,
+  number,
+  boolean,
+  array,
+  object,
+  union,
+  discriminatedUnion,
+  _enum,
+  literal,
   extractString,
+  toSourcedPiSubagentsOverlays,
+  resolveRouting,
+  loadConfigWithSources,
+  collectRoutingTargets,
+  getConfigPaths,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
-  getConfigPaths,
-  loadConfigWithSources,
-  modify,
-  parse,
-  parseFrontmatter,
-  parseTree
-} from "./index-0stf3ag0.js";
+  discoverSkills
+} from "./index-ae6mhwth.js";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 
 // src/cli.ts
 import fs6 from "fs";
@@ -29,7 +62,15 @@ function buildAgentCatalog(agentsDir) {
   const entries = [];
   for (const info of infos) {
     const content = fs.readFileSync(info.file, "utf8");
-    const entry = parseValidatedAgentEntry(content, info.file);
+    const parsed = parseValidatedAgentEntry(content, info.file);
+    const category = info.category ?? "";
+    const key = info.name;
+    const entry = {
+      ...parsed,
+      key,
+      category,
+      id: category ? `${category}/${key}` : key
+    };
     try {
       resolveToolAllowlist(entry.toolsSource);
     } catch (error) {
@@ -38,9 +79,9 @@ function buildAgentCatalog(agentsDir) {
     }
     const existing = byName.get(entry.name);
     if (existing) {
-      existing.push(info.category ?? "(root)");
+      existing.push(category);
     } else {
-      byName.set(entry.name, [info.category ?? "(root)"]);
+      byName.set(entry.name, [category]);
     }
     entries.push(entry);
   }
@@ -144,14 +185,19 @@ var CONFIG_AUTHORITY_FIELD_PATHS = [
 ];
 var CONFIG_PROTECTED_FIELD_PATHS = [
   "workflow_guard",
+  "profiles",
   "agents.*.model",
   "agents.*.permission",
   "agents.*.skills",
   "agents.*.variant",
+  "agents.*.opencode",
+  "agents.*.pi",
   "categories.*.model",
   "categories.*.permission",
   "categories.*.skills",
-  "categories.*.variant"
+  "categories.*.variant",
+  "categories.*.opencode",
+  "categories.*.pi"
 ];
 var CONFIG_SOURCE_ERROR_CODES = [
   "parse-failed",
@@ -409,7 +455,14 @@ function configErrorCode(errorCode) {
 }
 function normalizeConfigObservation(config) {
   assertRecord(config, "config");
-  assertAllowedKeys(config, ["authorities", "protectedFields", "sources"], "config");
+  assertAllowedKeys(config, [
+    "authorities",
+    "protectedFields",
+    "sources",
+    "activeProfile",
+    "profileSelectorSource",
+    "profileFallback"
+  ], "config");
   if (!Array.isArray(config.sources)) {
     throw new TypeError("config.sources must be an array");
   }
@@ -778,7 +831,30 @@ function buildCapabilitySnapshot(options) {
   options.outputSink?.(serialized);
   return snapshot;
 }
-
+// node_modules/.bun/zod@4.5.4/node_modules/zod/v4/classic/iso.js
+var exports_iso = {};
+__export(exports_iso, {
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  date: () => date,
+  datetime: () => datetime,
+  duration: () => duration,
+  time: () => time
+});
+function datetime(params) {
+  return _isoDateTime(ZodISODateTime, params);
+}
+function date(params) {
+  return _isoDate(ZodISODate, params);
+}
+function time(params) {
+  return _isoTime(ZodISOTime, params);
+}
+function duration(params) {
+  return _isoDuration(ZodISODuration, params);
+}
 // src/lib/pi-subagents-export.ts
 import * as crypto2 from "crypto";
 import * as fs3 from "fs";
@@ -1424,10 +1500,10 @@ function ownedFilenames(manifest) {
 function parseSourceCategoryAndKey(sourceRelPath) {
   const parts = sourceRelPath.split("/");
   if (parts.length >= 3 && parts[0] === "agents") {
-    const fileName2 = parts.at(-1) ?? "";
+    const fileName = parts.at(-1) ?? "";
     return {
       category: parts[1],
-      agentKey: fileName2.replace(/\.md$/, "")
+      agentKey: fileName.replace(/\.md$/, "")
     };
   }
   const fileName = parts.at(-1) ?? sourceRelPath;
@@ -1443,21 +1519,19 @@ function lookupOverlay(map, category, agentKey) {
   }
   return map[agentKey];
 }
-function resolveModel(config, category, agentKey) {
-  const agentOverlay = lookupOverlay(config.agents, category, agentKey);
-  if (agentOverlay && Object.hasOwn(agentOverlay, "model")) {
-    const value = agentOverlay.model;
-    return typeof value === "string" ? value : undefined;
-  }
-  const categoryOverlay = category ? config.categories?.[category] : undefined;
-  if (categoryOverlay && Object.hasOwn(categoryOverlay, "model")) {
-    const value = categoryOverlay.model;
-    return typeof value === "string" ? value : undefined;
-  }
-  return;
+function resolveRoutedFields(overlays, piSubagentsOverlays, category, agentKey) {
+  const resolution = resolveRouting({
+    overlays,
+    piSubagentsOverlays,
+    target: { agentKey, category: category ?? "" },
+    harness: "pi"
+  });
+  return {
+    model: typeof resolution.model === "string" ? resolution.model : undefined,
+    thinking: resolution.qualifier
+  };
 }
-var PI_SUBAGENTS_FRONTMATTER_FIELDS = [
-  "thinking",
+var OTHER_PI_SUBAGENTS_FRONTMATTER_FIELDS = [
   "max_turns",
   "tools",
   "skills"
@@ -1466,7 +1540,7 @@ function resolvePiSubagentsFields(config, category, agentKey) {
   const categoryOverlay = category ? config.pi_subagents?.categories?.[category] : undefined;
   const agentOverlay = lookupOverlay(config.pi_subagents?.agents, category, agentKey);
   const result = {};
-  for (const field of PI_SUBAGENTS_FRONTMATTER_FIELDS) {
+  for (const field of OTHER_PI_SUBAGENTS_FRONTMATTER_FIELDS) {
     if (agentOverlay && Object.hasOwn(agentOverlay, field)) {
       result[field] = agentOverlay[field];
     } else if (categoryOverlay && Object.hasOwn(categoryOverlay, field)) {
@@ -1475,19 +1549,21 @@ function resolvePiSubagentsFields(config, category, agentKey) {
   }
   return result;
 }
-function applyConfigToContent(content, config, category, agentKey) {
+function applyConfigToContent(content, config, overlays, piSubagentsOverlays, category, agentKey) {
   const { data, body } = parseFrontmatter(content);
-  const model = resolveModel(config, category, agentKey);
-  const piSubagentsFields = resolvePiSubagentsFields(config, category, agentKey);
+  const { model, thinking } = resolveRoutedFields(overlays, piSubagentsOverlays, category, agentKey);
+  const otherFields = resolvePiSubagentsFields(config, category, agentKey);
   const frontmatter = {};
   if (typeof data.description === "string") {
     frontmatter.description = data.description;
   }
   if (model !== undefined)
     frontmatter.model = model;
-  for (const field of PI_SUBAGENTS_FRONTMATTER_FIELDS) {
-    if (Object.hasOwn(piSubagentsFields, field)) {
-      frontmatter[field] = piSubagentsFields[field];
+  if (thinking !== undefined)
+    frontmatter.thinking = thinking;
+  for (const field of OTHER_PI_SUBAGENTS_FRONTMATTER_FIELDS) {
+    if (Object.hasOwn(otherFields, field)) {
+      frontmatter[field] = otherFields[field];
     }
   }
   let frontmatterBlock;
@@ -1506,12 +1582,12 @@ ${lines}
 
 ${trimmedBody}`;
 }
-function applyConfigToEntries(entries, config) {
+function applyConfigToEntries(entries, config, overlays, piSubagentsOverlays) {
   return entries.map((entry) => {
     if (entry.status === "excluded-critical" || !entry.content)
       return entry;
     const { category, agentKey } = parseSourceCategoryAndKey(entry.sourceRelPath);
-    const content = applyConfigToContent(entry.content, config, category, agentKey);
+    const content = applyConfigToContent(entry.content, config, overlays, piSubagentsOverlays, category, agentKey);
     const hash = crypto2.createHash("sha256").update(content).digest("hex");
     return { ...entry, content, hash };
   });
@@ -1520,10 +1596,11 @@ function generateEntries(repoRoot, configOptions) {
   const entries = generateAll(repoRoot);
   if (!configOptions)
     return entries;
-  const config = loadConfigWithSources(configOptions.cwd, {
+  const { config, overlays } = loadConfigWithSources(configOptions.cwd, {
     includeProject: configOptions.scope === "project"
-  }).config;
-  return applyConfigToEntries(entries, config);
+  });
+  const piSubagentsOverlays = toSourcedPiSubagentsOverlays(config.pi_subagents);
+  return applyConfigToEntries(entries, config, overlays, piSubagentsOverlays);
 }
 function findPackageRoot() {
   const thisFile = fileURLToPath(import.meta.url);
@@ -1949,7 +2026,7 @@ function cleanup(agentsRoot, configOptions) {
       ...targets.map((t) => t.path),
       ...manifestPath ? [manifestPath] : []
     ];
-    const tx2 = runWithRollback(pathsToWatch, [
+    const tx = runWithRollback(pathsToWatch, [
       ...targets.map(({ path: p, filename, hash }) => () => {
         if (fs3.existsSync(p)) {
           assertHashMatchesOrThrow(p, hash, filename, "delete");
@@ -1963,7 +2040,7 @@ function cleanup(agentsRoot, configOptions) {
         }
       ] : []
     ]);
-    return { kind: "tx", tx: tx2 };
+    return { kind: "tx", tx };
   });
   if (!lockResult.locked) {
     if (lockResult.isContention)
@@ -2010,8 +2087,8 @@ function hasParentDirectoryTraversal(input) {
 }
 function pathContainsSymlink(candidate) {
   let current = path3.parse(candidate).root;
-  const relative2 = path3.relative(current, candidate);
-  for (const segment of relative2.split(path3.sep)) {
+  const relative = path3.relative(current, candidate);
+  for (const segment of relative.split(path3.sep)) {
     if (!segment)
       continue;
     current = path3.join(current, segment);
@@ -2025,8 +2102,8 @@ function pathContainsSymlink(candidate) {
   return false;
 }
 function isWithinDirectory(candidate, directory) {
-  const relative2 = path3.relative(directory, candidate);
-  return relative2 !== "" && relative2 !== ".." && !relative2.startsWith(`..${path3.sep}`) && !path3.isAbsolute(relative2);
+  const relative = path3.relative(directory, candidate);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path3.sep}`) && !path3.isAbsolute(relative);
 }
 function resolveReviewArtifactPath(input, cwd) {
   if (hasParentDirectoryTraversal(input)) {
@@ -2096,14 +2173,14 @@ var REVIEW_ARTIFACT_CUSTOM_MESSAGES = [
   "unsatisfied risk coverage must not cite an input finding ID",
   "passed validation must not include a reason; non-passed validation requires a reason"
 ];
-var boundedText = (maxLength) => exports_external.string().min(1).max(maxLength).regex(/\S/);
-var DispatchOutcomeSchema = exports_external.enum([
+var boundedText = (maxLength) => string().min(1).max(maxLength).regex(/\S/);
+var DispatchOutcomeSchema = _enum([
   "findings",
   "empty",
   "malformed",
   "never_returned"
 ]);
-var DispositionSchema = exports_external.enum([
+var DispositionSchema = _enum([
   "surviving",
   "merged",
   "suppressed",
@@ -2111,12 +2188,12 @@ var DispositionSchema = exports_external.enum([
   "rejected"
 ]);
 var AdmittedDispositionSchema = DispositionSchema.exclude(["rejected"]);
-var HarnessSchema = exports_external.enum(["opencode", "pi", "claude-code"]);
+var HarnessSchema = _enum(["opencode", "pi", "claude-code"]);
 var RepoRelativePathSchema = boundedText(256).regex(/^(?!\/)(?![A-Za-z]:[\\/])(?!\\).+/);
 var ReviewerSchema = boundedText(MAX_REVIEWER_LENGTH);
-var BranchSchema = exports_external.string().max(MAX_BRANCH_LENGTH);
-var HeadShaSchema = exports_external.string().regex(/^[0-9a-f]{40}$/);
-var CompletedAtSchema = exports_external.iso.datetime({ offset: false });
+var BranchSchema = string().max(MAX_BRANCH_LENGTH);
+var HeadShaSchema = string().regex(/^[0-9a-f]{40}$/);
+var CompletedAtSchema = exports_iso.datetime({ offset: false });
 var ReasonSchema = boundedText(MAX_REASON_LENGTH);
 var RISK_CRITICAL_PERSONAS = [
   "security",
@@ -2125,42 +2202,42 @@ var RISK_CRITICAL_PERSONAS = [
   "reliability",
   "performance"
 ];
-var RiskCriticalPersonaSchema = exports_external.enum(RISK_CRITICAL_PERSONAS);
+var RiskCriticalPersonaSchema = _enum(RISK_CRITICAL_PERSONAS);
 var FindingTitleSchema = boundedText(256);
-var SeveritySchema = exports_external.enum(["P0", "P1", "P2", "P3", "unknown"]);
+var SeveritySchema = _enum(["P0", "P1", "P2", "P3", "unknown"]);
 var FindingSeveritySchema = SeveritySchema.exclude(["unknown"]);
-var AutofixClassSchema = exports_external.enum([
+var AutofixClassSchema = _enum([
   "safe_auto",
   "gated_auto",
   "manual",
   "advisory"
 ]);
-var OwnerSchema = exports_external.enum([
+var OwnerSchema = _enum([
   "review-fixer",
   "downstream-resolver",
   "human",
   "release"
 ]);
 var BoundedEvidenceStringSchema = boundedText(500).regex(/^(?!\/)(?![A-Za-z]:[\\/])(?!\\).+/);
-var OverflowEvidenceSchema = exports_external.object({
-  overflow: exports_external.literal(true),
+var OverflowEvidenceSchema = object({
+  overflow: literal(true),
   excerpt: BoundedEvidenceStringSchema
 }).strict();
-var EvidenceSchema = exports_external.array(exports_external.union([BoundedEvidenceStringSchema, OverflowEvidenceSchema])).min(1).max(5);
-var AdmittedInputFindingSchema = exports_external.object({
-  record_type: exports_external.literal("admitted"),
+var EvidenceSchema = array(union([BoundedEvidenceStringSchema, OverflowEvidenceSchema])).min(1).max(5);
+var AdmittedInputFindingSchema = object({
+  record_type: literal("admitted"),
   input_id: boundedText(MAX_INPUT_ID_LENGTH),
   reviewer: ReviewerSchema,
-  confidence: exports_external.number().min(0).max(1),
+  confidence: number().min(0).max(1),
   disposition: AdmittedDispositionSchema,
   reason: ReasonSchema
 }).strict();
-var RejectedInputFindingSchema = exports_external.object({
-  record_type: exports_external.literal("rejected_summary"),
+var RejectedInputFindingSchema = object({
+  record_type: literal("rejected_summary"),
   reviewer: ReviewerSchema,
   dispatch_outcome: DispatchOutcomeSchema,
-  rejected_finding_count: exports_external.number().int().positive().max(MAX_FINDINGS),
-  rejected_severities: exports_external.array(SeveritySchema).max(MAX_FINDINGS),
+  rejected_finding_count: number().int().positive().max(MAX_FINDINGS),
+  rejected_severities: array(SeveritySchema).max(MAX_FINDINGS),
   disposition: DispositionSchema.extract(["rejected"]),
   reason: ReasonSchema
 }).strict().superRefine((row, ctx) => {
@@ -2172,31 +2249,31 @@ var RejectedInputFindingSchema = exports_external.object({
     });
   }
 });
-var InputFindingSchema = exports_external.discriminatedUnion("record_type", [
+var InputFindingSchema = discriminatedUnion("record_type", [
   AdmittedInputFindingSchema,
   RejectedInputFindingSchema
 ]);
-var ProvenanceSchema = exports_external.object({
+var ProvenanceSchema = object({
   fingerprint: boundedText(512),
-  submitters: exports_external.array(ReviewerSchema).max(MAX_PERSONAS),
-  agreement_credit: exports_external.array(ReviewerSchema).max(MAX_PERSONAS)
+  submitters: array(ReviewerSchema).max(MAX_PERSONAS),
+  agreement_credit: array(ReviewerSchema).max(MAX_PERSONAS)
 }).strict();
-var SynthesizedFindingFieldsSchema = exports_external.object({
+var SynthesizedFindingFieldsSchema = object({
   title: FindingTitleSchema,
   severity: FindingSeveritySchema,
   file: RepoRelativePathSchema,
-  line: exports_external.number().int().positive(),
+  line: number().int().positive(),
   why_it_matters: boundedText(2048),
   autofix_class: AutofixClassSchema,
   owner: OwnerSchema,
-  requires_verification: exports_external.boolean(),
-  confidence: exports_external.number().min(0).max(1),
+  requires_verification: boolean(),
+  confidence: number().min(0).max(1),
   evidence: EvidenceSchema,
-  pre_existing: exports_external.boolean(),
-  suggested_fix: exports_external.string().max(2048).nullable().optional(),
-  validated: exports_external.boolean().optional(),
+  pre_existing: boolean(),
+  suggested_fix: string().max(2048).nullable().optional(),
+  validated: boolean().optional(),
   validation_reason: ReasonSchema.optional(),
-  input_finding_ids: exports_external.array(boundedText(MAX_INPUT_ID_LENGTH)).min(1).max(MAX_FINDINGS),
+  input_finding_ids: array(boundedText(MAX_INPUT_ID_LENGTH)).min(1).max(MAX_FINDINGS),
   provenance: ProvenanceSchema
 }).strict();
 var SynthesizedFindingSchema = SynthesizedFindingFieldsSchema.superRefine((finding, ctx) => {
@@ -2208,12 +2285,12 @@ var SynthesizedFindingSchema = SynthesizedFindingFieldsSchema.superRefine((findi
     });
   }
 });
-var DispatchSchema = exports_external.object({
+var DispatchSchema = object({
   persona: ReviewerSchema,
   dispatch_outcome: DispatchOutcomeSchema,
-  input_finding_count: exports_external.number().int().nonnegative().max(MAX_FINDINGS),
+  input_finding_count: number().int().nonnegative().max(MAX_FINDINGS),
   rejection_reason: ReasonSchema.optional(),
-  selection_surface: exports_external.array(RepoRelativePathSchema).max(MAX_FINDINGS).optional(),
+  selection_surface: array(RepoRelativePathSchema).max(MAX_FINDINGS).optional(),
   selection_reason: ReasonSchema.optional()
 }).strict().superRefine((dispatch, ctx) => {
   if (RISK_CRITICAL_PERSONAS.includes(dispatch.persona) && (!dispatch.selection_surface || dispatch.selection_surface.length === 0)) {
@@ -2224,29 +2301,29 @@ var DispatchSchema = exports_external.object({
     });
   }
 });
-var DispositionCountsSchema = exports_external.object({
-  surviving: exports_external.number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
-  merged: exports_external.number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
-  suppressed: exports_external.number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
-  filtered: exports_external.number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
-  rejected: exports_external.number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS)
+var DispositionCountsSchema = object({
+  surviving: number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
+  merged: number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
+  suppressed: number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
+  filtered: number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS),
+  rejected: number().int().nonnegative().max(MAX_FINDINGS * MAX_PERSONAS)
 }).strict();
-var CoverageSchema = exports_external.object({
-  reviewers: exports_external.number().int().nonnegative().max(MAX_PERSONAS).optional(),
-  validators: exports_external.number().int().nonnegative().max(MAX_PERSONAS).optional(),
-  residual_risks: exports_external.array(ReasonSchema).max(MAX_PERSONAS),
-  testing_gaps: exports_external.array(ReasonSchema).max(MAX_PERSONAS),
-  failed_reviewers: exports_external.array(ReviewerSchema).max(MAX_PERSONAS),
-  validator_failures: exports_external.array(ReasonSchema).max(MAX_PERSONAS),
-  intent_uncertainty: exports_external.array(ReasonSchema).max(MAX_PERSONAS)
+var CoverageSchema = object({
+  reviewers: number().int().nonnegative().max(MAX_PERSONAS).optional(),
+  validators: number().int().nonnegative().max(MAX_PERSONAS).optional(),
+  residual_risks: array(ReasonSchema).max(MAX_PERSONAS),
+  testing_gaps: array(ReasonSchema).max(MAX_PERSONAS),
+  failed_reviewers: array(ReviewerSchema).max(MAX_PERSONAS),
+  validator_failures: array(ReasonSchema).max(MAX_PERSONAS),
+  intent_uncertainty: array(ReasonSchema).max(MAX_PERSONAS)
 }).strict();
-var DeclinedMergeSchema = exports_external.object({
+var DeclinedMergeSchema = object({
   file: RepoRelativePathSchema,
-  input_finding_ids: exports_external.array(boundedText(MAX_INPUT_ID_LENGTH)).min(2).max(MAX_FINDINGS),
+  input_finding_ids: array(boundedText(MAX_INPUT_ID_LENGTH)).min(2).max(MAX_FINDINGS),
   reason: ReasonSchema
 }).strict();
-var ValidationSchema = exports_external.object({
-  status: exports_external.enum([
+var ValidationSchema = object({
+  status: _enum([
     "passed",
     "failed",
     "unavailable",
@@ -2269,9 +2346,9 @@ var ValidationSchema = exports_external.object({
     });
   }
 });
-var RiskCoverageSchema = exports_external.object({
+var RiskCoverageSchema = object({
   persona: RiskCriticalPersonaSchema,
-  satisfied: exports_external.boolean(),
+  satisfied: boolean(),
   input_finding_id: boundedText(MAX_INPUT_ID_LENGTH).optional()
 }).strict().superRefine((coverage, ctx) => {
   if (coverage.satisfied && coverage.input_finding_id === undefined) {
@@ -2289,14 +2366,14 @@ var RiskCoverageSchema = exports_external.object({
     });
   }
 });
-var ReviewArtifactSchema = exports_external.object({
-  schema_version: exports_external.literal(1),
+var ReviewArtifactSchema = object({
+  schema_version: literal(1),
   run_id: boundedText(MAX_RUN_ID_LENGTH),
   branch: BranchSchema,
   head_sha: HeadShaSchema,
-  mode: exports_external.enum(["interactive", "autofix", "headless"]),
+  mode: _enum(["interactive", "autofix", "headless"]),
   harness: HarnessSchema,
-  run_status: exports_external.enum([
+  run_status: _enum([
     "in_progress",
     "completed",
     "degraded",
@@ -2304,15 +2381,15 @@ var ReviewArtifactSchema = exports_external.object({
   ]),
   verdict: boundedText(256),
   completed_at: CompletedAtSchema,
-  dispatches: exports_external.array(DispatchSchema).max(MAX_PERSONAS),
-  input_findings: exports_external.array(InputFindingSchema).max(MAX_FINDINGS * MAX_PERSONAS),
-  findings: exports_external.array(SynthesizedFindingSchema).max(MAX_FINDINGS),
-  declined_merges: exports_external.array(DeclinedMergeSchema).max(MAX_FINDINGS).optional(),
-  risk_coverage: exports_external.array(RiskCoverageSchema).max(MAX_PERSONAS).optional(),
+  dispatches: array(DispatchSchema).max(MAX_PERSONAS),
+  input_findings: array(InputFindingSchema).max(MAX_FINDINGS * MAX_PERSONAS),
+  findings: array(SynthesizedFindingSchema).max(MAX_FINDINGS),
+  declined_merges: array(DeclinedMergeSchema).max(MAX_FINDINGS).optional(),
+  risk_coverage: array(RiskCoverageSchema).max(MAX_PERSONAS).optional(),
   disposition_counts: DispositionCountsSchema,
-  applied_fixes: exports_external.array(ReasonSchema).max(MAX_FINDINGS),
-  residual_actionable_work: exports_external.array(ReasonSchema).max(MAX_FINDINGS),
-  advisory_outputs: exports_external.array(ReasonSchema).max(MAX_FINDINGS),
+  applied_fixes: array(ReasonSchema).max(MAX_FINDINGS),
+  residual_actionable_work: array(ReasonSchema).max(MAX_FINDINGS),
+  advisory_outputs: array(ReasonSchema).max(MAX_FINDINGS),
   coverage: CoverageSchema,
   validation: ValidationSchema.optional()
 }).strict();
@@ -2365,8 +2442,8 @@ function lstatOrNull(targetPath) {
 function assertRealpathUnderCwd(dir, cwd) {
   const realDir = fs5.realpathSync(dir);
   const realCwd = fs5.realpathSync(cwd);
-  const relative2 = path4.relative(realCwd, realDir);
-  if (relative2.startsWith("..") || path4.isAbsolute(relative2)) {
+  const relative = path4.relative(realCwd, realDir);
+  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
     throw createSetupError(`Refusing to write under ${dir}: resolved directory escapes the project root`);
   }
 }
@@ -2459,8 +2536,8 @@ function writeTempAndRename(destPath, content, mode, preserveExactMode, ops) {
     throw error;
   }
 }
-function makeTempPath(parentDir, basename2) {
-  return path4.join(parentDir, `.${basename2}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+function makeTempPath(parentDir, basename) {
+  return path4.join(parentDir, `.${basename}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
 }
 function cleanupTemp(tempPath, ops) {
   if (!fs5.existsSync(tempPath))
@@ -2515,8 +2592,8 @@ function setupOpenCode(cwd, ops) {
     throw createSetupError(`Invalid OpenCode config in ${targetPath}: \`plugins\` (plural) is not supported by OpenCode's schema; use singular \`plugin\``);
   }
   if (!Object.hasOwn(parsed, "plugin")) {
-    const edits2 = modify(rawText, ["plugin"], [SYSTEMATIC_PACKAGE_NAME], {});
-    atomicWrite(targetPath, applyEdits(rawText, edits2), existing.bytes, existing.mode, ops);
+    const edits = modify(rawText, ["plugin"], [SYSTEMATIC_PACKAGE_NAME], {});
+    atomicWrite(targetPath, applyEdits(rawText, edits), existing.bytes, existing.mode, ops);
     return { status: "configured", targetPath };
   }
   const existingValue = parsed.plugin;
@@ -2577,8 +2654,8 @@ function setupPi(cwd, ops) {
   }
   const existingPackages = parsed.packages;
   if (existingPackages === undefined) {
-    const edits2 = modify(rawText, ["packages"], [PI_PACKAGE_IDENTIFIER], {});
-    atomicWrite(targetPath, applyEdits(rawText, edits2), existing.bytes, existing.mode, ops);
+    const edits = modify(rawText, ["packages"], [PI_PACKAGE_IDENTIFIER], {});
+    atomicWrite(targetPath, applyEdits(rawText, edits), existing.bytes, existing.mode, ops);
     return { status: "configured", targetPath };
   }
   if (!Array.isArray(existingPackages)) {
@@ -2650,7 +2727,7 @@ Commands:
                                Exit statuses: 0 valid artifact, 1 validation failure,
                                2 operational failure, 3 legacy artifact with no schema_version
   config [subcommand]          Configuration management
-    show                       Show configuration
+    show [--json]              Show configuration (--json for a machine-readable resolved view)
     path                       Print config file locations
   setup --harness opencode|pi  Configure a harness to load Systematic (project-local only)
   pi-subagents <subcommand>    Manage Systematic persona export for pi-subagents
@@ -2669,6 +2746,7 @@ Examples:
   systematic validate-review-artifact .context/systematic/ce-review/review-summary.json
   systematic list agents
   systematic config show
+  systematic config show --json
   systematic setup --harness opencode
   systematic setup --harness pi
   systematic pi-subagents preview
@@ -2677,6 +2755,13 @@ Examples:
   systematic pi-subagents refresh
   systematic pi-subagents cleanup
 `;
+var CONFIG_SHOW_USAGE = `Usage: systematic config show [--json]
+
+Options:
+  --json    Print a machine-readable resolved view (active profile, fallback,
+            and per-agent/harness routing) instead of prose. No raw file
+            contents in JSON mode.
+`;
 var PI_SUBAGENTS_USAGE = `Usage: systematic pi-subagents <subcommand> [--scope project|global]
 
 Subcommands:
@@ -2952,7 +3037,130 @@ function listItems(type) {
     console.log(`  ${item.name}`);
   }
 }
-function configShow() {
+function formatRoutingModel(model) {
+  if (model === undefined)
+    return "(unset)";
+  if (model === null)
+    return "null (inherit)";
+  return model;
+}
+function formatRoutingQualifier(qualifier) {
+  return qualifier === undefined ? "(none)" : qualifier;
+}
+function formatRoutingSource(source) {
+  return source === undefined ? "(n/a)" : `${source.level}/${source.form}`;
+}
+function printProfileSummary(metadata) {
+  const activeLabel = metadata.activeProfile ?? "none";
+  const selectedByLabel = metadata.profileSelectorSource ?? "(none)";
+  console.log(`  Active profile: ${activeLabel}`);
+  console.log(`  Selected by:    ${selectedByLabel}`);
+  if (metadata.profileFallback) {
+    const usedLabel = metadata.profileFallback.usedDefault ? `your default profile "${metadata.profileFallback.usedDefault}"` : "base configuration (no default profile is set)";
+    console.log(`  Fallback:       requested "${metadata.profileFallback.requested}" is not defined; used ${usedLabel}`);
+  }
+}
+function disabledAgentsSet(loaded) {
+  return new Set(loaded.config.disabled_agents ?? []);
+}
+function printRoutingTable(loaded) {
+  const targets = collectRoutingTargets(loaded.overlays, disabledAgentsSet(loaded)).sort((left, right) => `${left.category}/${left.agentKey}`.localeCompare(`${right.category}/${right.agentKey}`));
+  if (targets.length === 0) {
+    console.log("  No per-agent or per-category overlays are defined.");
+    return;
+  }
+  for (const target of targets) {
+    console.log(`  ${target.agentKey} (${target.category}):`);
+    for (const harness of ["opencode", "pi"]) {
+      const resolution = resolveRouting({
+        harness,
+        overlays: loaded.overlays,
+        piSubagentsOverlays: loaded.piSubagentsOverlays,
+        target
+      });
+      const qualifierName = harness === "opencode" ? "variant" : "thinking";
+      console.log(`    ${harness}: model=${formatRoutingModel(resolution.model)} (${formatRoutingSource(resolution.source.model)}), ` + `${qualifierName}=${formatRoutingQualifier(resolution.qualifier)} (${formatRoutingSource(resolution.source.qualifier)})`);
+    }
+  }
+}
+function printResolvedSection() {
+  let loaded;
+  try {
+    loaded = loadConfigWithSources(process.cwd());
+  } catch {
+    console.log(`
+Resolved configuration: unavailable (the configuration failed to load).`);
+    return;
+  }
+  const { metadata, overlays } = loaded;
+  const hasProfileSelection = metadata.activeProfile !== null || metadata.profileSelectorSource !== null;
+  const hasOverlays = Object.keys(overlays.agents).length > 0 || Object.keys(overlays.categories).length > 0;
+  console.log(`
+Resolved configuration:`);
+  if (!hasProfileSelection && !hasOverlays) {
+    console.log("  No profiles are selected and no per-agent/category overlays are defined.");
+    return;
+  }
+  printProfileSummary(metadata);
+  console.log("");
+  console.log("  Routing:");
+  printRoutingTable(loaded);
+}
+function toJsonRoutingResolution(resolution) {
+  return {
+    model: resolution.model,
+    qualifier: resolution.qualifier,
+    source: resolution.source
+  };
+}
+function buildConfigShowJson() {
+  const paths = getConfigPaths(process.cwd());
+  const locations = {
+    user: paths.userConfig,
+    project: paths.projectConfig,
+    custom: paths.customConfig ?? null
+  };
+  let loaded;
+  try {
+    loaded = loadConfigWithSources(process.cwd());
+  } catch (error) {
+    return {
+      locations,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const targets = collectRoutingTargets(loaded.overlays, disabledAgentsSet(loaded)).sort((left, right) => `${left.category}/${left.agentKey}`.localeCompare(`${right.category}/${right.agentKey}`));
+  const routing = targets.map((target) => ({
+    target,
+    opencode: toJsonRoutingResolution(resolveRouting({
+      harness: "opencode",
+      overlays: loaded.overlays,
+      piSubagentsOverlays: loaded.piSubagentsOverlays,
+      target
+    })),
+    pi: toJsonRoutingResolution(resolveRouting({
+      harness: "pi",
+      overlays: loaded.overlays,
+      piSubagentsOverlays: loaded.piSubagentsOverlays,
+      target
+    }))
+  }));
+  return {
+    locations,
+    activeProfile: loaded.metadata.activeProfile,
+    profileSelectorSource: loaded.metadata.profileSelectorSource,
+    profileFallback: loaded.metadata.profileFallback,
+    routing
+  };
+}
+function configShow(options) {
+  if (options.json) {
+    const output = buildConfigShowJson();
+    console.log(JSON.stringify(output, null, 2));
+    if ("error" in output)
+      process.exit(1);
+    return;
+  }
   const paths = getConfigPaths(process.cwd());
   console.log(`Configuration locations:
 `);
@@ -2968,6 +3176,20 @@ Project configuration:`);
 User configuration:`);
     console.log(fs6.readFileSync(paths.userConfig, "utf-8"));
   }
+  printResolvedSection();
+}
+function parseConfigShowArgs(rest) {
+  let json = false;
+  for (const arg of rest) {
+    if (arg === "--json") {
+      json = true;
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      console.error(CONFIG_SHOW_USAGE);
+      process.exit(1);
+    }
+  }
+  return { json };
 }
 function configPath() {
   const paths = getConfigPaths(process.cwd());
@@ -3166,7 +3388,7 @@ function runLegacyCli(args) {
       switch (args[1]) {
         case "show":
         case undefined:
-          configShow();
+          configShow(parseConfigShowArgs(args.slice(2)));
           break;
         case "path":
           configPath();