@fro.bot/systematic 3.15.0 → 3.15.1

package/dist/cli.js

@@ -1,20 +1,50 @@
 #!/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,
+  loadConfigWithSources,
+  getConfigPaths,
   extractString,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
-  getConfigPaths,
-  loadConfigWithSources,
-  modify,
-  parse,
-  parseFrontmatter,
-  parseTree
-} from "./index-0stf3ag0.js";
+  discoverSkills
+} from "./index-7cyxcwf5.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";
@@ -778,7 +808,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 +1477,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;
@@ -1949,7 +2002,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 +2016,7 @@ function cleanup(agentsRoot, configOptions) {
         }
       ] : []
     ]);
-    return { kind: "tx", tx: tx2 };
+    return { kind: "tx", tx };
   });
   if (!lockResult.locked) {
     if (lockResult.isContention)
@@ -2010,8 +2063,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 +2078,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 +2149,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 +2164,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 +2178,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 +2225,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 +2261,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 +2277,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 +2322,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 +2342,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 +2357,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 +2418,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 +2512,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 +2568,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 +2630,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)) {