@garygentry/system1 0.1.0 → 0.3.0

package/dist/bundle/chunks/{bin-IIUCANF7.mjs → bin-TCIHP5PC.mjs}

@@ -6,7 +6,7 @@ import {
   VERSION,
   emit,
   extractFormat
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // src/bin.ts
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -50,7 +50,8 @@ Commands:
   usage     Measured spend from the ledger (--session, --since)
   config    Show resolved config; \`config egress allow|deny|status\` for consent
   spec      list | show <name> | validate [name|path] | check <name> [--live]
-  schema    Print the JSON Schema of a tool's input (ask, many, usage, spec-check)
+  schema    Print the JSON Schema of a tool's input (ask, many, usage, spec-check, route)
+  route     Does a prompt call for the ask skill? (--text|--stdin|--hook; local, sends nothing)
   ping      Check the endpoint is reachable (no key, no spend)
   doctor    Check decide works from this shell; prints the fix for each problem
   version   Print the version
@@ -91,21 +92,23 @@ async function main(argv, io) {
   }
   switch (command) {
     case "ask":
-      return (await import("./decide-PW7REJ6Y.mjs")).runAskCommand(rest, io, format);
+      return (await import("./decide-XVVRKQ3V.mjs")).runAskCommand(rest, io, format);
     case "many":
-      return (await import("./decide-PW7REJ6Y.mjs")).runManyCommand(rest, io, format);
+      return (await import("./decide-XVVRKQ3V.mjs")).runManyCommand(rest, io, format);
     case "usage":
-      return (await import("./misc-6VZKJEN4.mjs")).runUsageCommand(rest, io, format);
+      return (await import("./misc-FHOVQJ2G.mjs")).runUsageCommand(rest, io, format);
     case "config":
-      return (await import("./config-QR35VKVT.mjs")).runConfigCommand(rest, io, format);
+      return (await import("./config-REALJZDR.mjs")).runConfigCommand(rest, io, format);
     case "spec":
-      return (await import("./spec-Z2LZJ5EZ.mjs")).runSpecCommand(rest, io, format);
+      return (await import("./spec-734MPBKB.mjs")).runSpecCommand(rest, io, format);
     case "schema":
-      return (await import("./misc-6VZKJEN4.mjs")).runSchemaCommand(rest, io, format);
+      return (await import("./misc-FHOVQJ2G.mjs")).runSchemaCommand(rest, io, format);
+    case "route":
+      return (await import("./route-NMFOTXLI.mjs")).runRouteCommand(rest, io, format);
     case "ping":
-      return (await import("./misc-6VZKJEN4.mjs")).runPingCommand(io, format);
+      return (await import("./misc-FHOVQJ2G.mjs")).runPingCommand(io, format);
     case "doctor":
-      return (await import("./doctor-HAT6XVTW.mjs")).runDoctorCommand(io, format);
+      return (await import("./doctor-TKFVFCZV.mjs")).runDoctorCommand(io, format);
     case "version":
     case "--version":
     case "-v":

package/dist/bundle/chunks/{chunk-A7ODZFMY.mjs → chunk-4BSTNWLV.mjs}

@@ -2,10 +2,10 @@ import { createRequire as __decideRequire } from "node:module"; const require =
 import {
   parseFileRef,
   parseQuestionSet
-} from "./chunk-V7OTO67I.mjs";
+} from "./chunk-S5AIBUL7.mjs";
 import {
   DecisionsError
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // src/args.ts
 import { readFileSync } from "node:fs";

package/dist/bundle/chunks/{chunk-7LVHD6A5.mjs → chunk-NUIZJRI6.mjs}

@@ -145,7 +145,7 @@ function extractFormat(argv, fallback) {
 }
 
 // ../core/dist/version.js
-var VERSION = "0.1.0";
+var VERSION = "0.3.0";
 var CLI_PACKAGE = "@garygentry/system1";
 
 export {

package/dist/bundle/chunks/{chunk-V7OTO67I.mjs → chunk-S5AIBUL7.mjs}

@@ -9,7 +9,7 @@ import {
   __require,
   __toESM,
   isDecisionsError
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
@@ -9165,6 +9165,107 @@ function escapeRegExp(text) {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// ../core/dist/route/route.js
+var ROUTE_DEFAULTS = {
+  enabled: true,
+  builtin: true,
+  disable: [],
+  triggers: [],
+  ignore: []
+};
+var both = (...parts) => `^${parts.map((p) => `(?=[\\s\\S]*?(${p}))`).join("")}`;
+var ITEMS = "tickets?|reviews?|commits?|failures?|errors?|lines|rows?|entries|items?|issues?|comments?|messages?|emails?|commands?|records?|files?|tests?|alerts?|findings?|results?|prs?|pull requests?|responses?|reports?|incidents?|warnings?|changes?|hunks?|packages?|candidates?";
+var FILE = "\\b[\\w./-]+\\.(?:jsonl|ndjson|csv|tsv|txt|log|sh)\\b";
+var BATCH = `\\b(?:each|every|all\\s+(?:the\\s+|of\\s+the\\s+)?(?:\\d+\\s+)?(?:${ITEMS})|line\\s+by\\s+line|one\\s+by\\s+one)\\b|\\b\\d{2,}\\s+(?:[\\w-]+\\s+){0,2}(?:${ITEMS})\\b`;
+var RULESET = "\\b(?:rules?|criteri(?:a|on)|requirements?|checklist|polic(?:y|ies)|guidelines?|conventions?|standards?|our\\s+bar|TASK\\.md)\\b";
+var EVIDENCE = "\\b(?:diff|uncommitted|working\\s+tree|staged|changes?|patch|pr|pull\\s+request|branch|test[-\\s]output(?:\\.log)?|test\\s+results?|TASK\\.md)\\b";
+var GATES = "commit|merge|push|ship|release|approve|deploy|land|run";
+var BUILTIN_TRIGGERS = [
+  {
+    // "triage every CI failure", "go through tickets.jsonl and flag any where…",
+    // "which of these would pass on a rerun", "the ones complaining about…"
+    name: "batch-judgement",
+    pattern: both(
+      // A verb glued to a hyphen is another word: "rate-limit", "score-board".
+      `\\b(?:(?:classify|categori[sz]e|label|triage|bucket|grade|rate|score|rank|screen|vet|judge|assess)(?!-)|sort\\s+out|route\\s+(?:each|every|all|these|those|the)|flag\\s+(?:any|all|every|each|which|the\\s+ones|anything)|mark\\s+(?:any|all|every|each|which|the\\s+ones)|split\\s+(?:\\w+\\s+)?into|pull\\s+out\\s+(?:the|any|all|every)|tell\\s+me\\s+which|which\\s+of\\s+(?:them|these|those|the\\s+\\w+)|which\\s+ones|which\\s+(?:${ITEMS})\\s+(?:could|would|might|should|are|is|will|look|seem|need)|the\\s+ones\\s+(?:that|where|which|who|with|about|complaining|mentioning)|anything\\s+that\\s+(?:looks|seems|sounds|reads)|is\\s+each|are\\s+any\\s+of|whether\\s+each|verdicts?)\\b`,
+      `${FILE}|${BATCH}`
+    )
+  },
+  {
+    // "250 packages. Which single one…", "which of the packages is the best fit"
+    name: "pick-from-many",
+    pattern: both("\\b(?:best\\s+(?:fit|match|one|option|choice)|which\\s+(?:single\\s+)?one|single\\s+best|pick\\s+(?:the|one)|choose\\s+(?:the|one))\\b", `${FILE}|\\b\\d{2,}\\s+(?:[\\w-]+\\s+){0,2}(?:${ITEMS}|libraries|options|helpers|modules|functions)\\b|\\bout\\s+of\\s+(?:all|the|these)\\b`)
+  },
+  {
+    // "check the diff against these rules", "does it meet the acceptance
+    // criteria", "grade each criterion pass or fail", "hold the diff to our rules"
+    name: "criteria-check",
+    pattern: both("\\b(?:against\\s+(?:our|the|these|this|my|each|every)?\\s*(?:[\\w-]+\\s+){0,2}(?:rules?|criteri(?:a|on)|requirements?|checklist|polic(?:y|ies)|guidelines?|conventions?|standards?|spec)|hold\\s+(?:it|this|them|the\\s+[\\w-]+(?:\\s+[\\w-]+)?)\\s+(?:up\\s+)?(?:to|against)|meets?|satisf(?:y|ies)|violat\\w*|compl(?:y|ies|iant)|pass(?:es)?\\s+(?:our|the)\\s+(?:bar|rules|checks?|checklist)|pass\\s+or\\s+fail|pass/fail|per[-\\s]criteri(?:on|a)|tick\\s+off|(?:one|a|separate)\\s+verdict|verdicts?\\s+(?:for|on)|grade\\s+(?:each|every|them|it)|(?:each|every)\\s+(?:acceptance\\s+)?(?:criteri(?:on|a)|rule|requirement|checklist\\s+item|item))\\b", RULESET)
+  },
+  {
+    // "is the task actually done?", "am i done?", "ready to merge?", "can I ship this"
+    name: "done-check",
+    pattern: both("\\b(?:am\\s+i\\s+(?:actually\\s+|really\\s+)?done|are\\s+we\\s+(?:actually\\s+|really\\s+)?done|is\\s+(?:it|this|that|(?:the|my|our)\\s+\\w+(?!\\s+(?:description|message|title|name|docs?|readme|summary|text|comment)))(?:\\s+[\\w.]+){0,4}?\\s+(?:actually\\s+|really\\s+|fully\\s+|truly\\s+)?(?:done|complete|finished)|(?:ready|good|ok|safe)\\s+to\\s+(?:merge|ship|commit|push|land|release)|can\\s+(?:i|we)\\s+(?:ship|merge|land|commit|push)\\s+(?:this|it)|(?:about|going)\\s+to\\s+(?:open\\s+a\\s+pr|merge|ship|push|commit|release))\\b", `${EVIDENCE}|${FILE}`, "\\?|\\b(?:check|verify|confirm|tell\\s+me|make\\s+sure|grade|hold)\\b")
+  },
+  {
+    // "before I commit… is it safe?", "which commands could lose data before the bot runs it"
+    name: "gate-check",
+    pattern: both(`\\bbefore\\s+(?:i|we|the\\s+\\w+)\\s+(?:${GATES})s?\\b`, `${RULESET}|\\b(?:safe|destructive|verdict|violat\\w*|could\\s+(?:lose|break|delete|destroy|wipe))\\b`)
+  }
+];
+var BUILTIN_IGNORE = [
+  "\\b(?:don'?t|do\\s+not|without)\\s+(?:use\\s+|using\\s+)?(?:system\\s?1|decide)\\b"
+];
+var DEFAULT_MESSAGE = "System 1 routing hint ({triggers}): the user wants closed verdicts over text. Load the system1:ask skill now, before you read the files or the diff, and let `decide` give the verdicts; do not grade them yourself. Skip this only if the user said not to use System 1.";
+function compilePattern(pattern, where) {
+  try {
+    return new RegExp(pattern, "i");
+  } catch (error) {
+    throw new DecisionsError("config-error", `${where}: invalid regular expression ${JSON.stringify(pattern)}: ${error.message}`, { pattern });
+  }
+}
+function activeTriggers(config) {
+  const unknown = config.disable.filter((n) => !BUILTIN_TRIGGERS.some((t) => t.name === n));
+  if (unknown.length > 0) {
+    throw new DecisionsError("config-error", `route.disable names unknown built-in trigger(s): ${unknown.join(", ")}. Built-ins: ${BUILTIN_TRIGGERS.map((t) => t.name).join(", ")}`);
+  }
+  const builtins = config.builtin ? BUILTIN_TRIGGERS.filter((t) => !config.disable.includes(t.name)) : [];
+  return [
+    ...builtins.map((t) => ({ ...t, source: "builtin" })),
+    ...config.triggers.map((t) => ({ ...t, source: "config" }))
+  ];
+}
+function route(prompt, config) {
+  const triggers = activeTriggers(config);
+  const ignore = [...config.builtin ? BUILTIN_IGNORE : [], ...config.ignore];
+  const compiled = triggers.map((t) => ({
+    ...t,
+    re: compilePattern(t.pattern, `route trigger "${t.name}"`)
+  }));
+  const vetoes = ignore.map((p) => ({ p, re: compilePattern(p, "route.ignore") }));
+  if (!config.enabled)
+    return { enabled: false, matched: false, triggers: [] };
+  const hits = [];
+  for (const t of compiled) {
+    const m = t.re.exec(prompt);
+    const text = m?.[0] || m?.slice(1).filter(Boolean).join(" \u2026 ");
+    if (m)
+      hits.push({ name: t.name, source: t.source, text: (text ?? "").slice(0, 120) });
+  }
+  if (hits.length === 0)
+    return { enabled: true, matched: false, triggers: [] };
+  const veto = vetoes.find((v) => v.re.test(prompt));
+  if (veto)
+    return { enabled: true, matched: false, triggers: hits, ignoredBy: veto.p };
+  const names = hits.map((h) => h.name).join(", ");
+  return {
+    enabled: true,
+    matched: true,
+    triggers: hits,
+    message: (config.message ?? DEFAULT_MESSAGE).replaceAll("{triggers}", names)
+  };
+}
+
 // ../core/dist/model/validate.js
 function assertQuestionSet(questions) {
   const problems = [];
@@ -9423,7 +9524,8 @@ var DEFAULTS = {
   timeoutMs: DEFAULT_TIMEOUT_MS,
   budget: { maxCalls: 200, maxUsd: 0.05 },
   egress: { consent: { granted: false }, exclude: [] },
-  profiles: []
+  profiles: [],
+  route: ROUTE_DEFAULTS
 };
 function findRepoRoot(cwd) {
   let dir = resolve(cwd);
@@ -9470,7 +9572,8 @@ function loadConfig(options = {}) {
         ...stringList(repo, "egress.exclude", repoFile)
       ]
     },
-    profiles: [...profileList(user, userFile), ...profileList(repo, repoFile)]
+    profiles: [...profileList(user, userFile), ...profileList(repo, repoFile)],
+    route: readRoute(user, userFile, repo, repoFile, env)
   };
   const key = resolveApiKey(env, userDir);
   const session = detectSession(env);
@@ -9520,9 +9623,9 @@ function pick(key, type, ...layers2) {
   }
   return void 0;
 }
-function pickIn(section, key, ...layers2) {
+function pickIn(section2, key, ...layers2) {
   for (const layer of layers2) {
-    const value = layer?.[section]?.[key];
+    const value = layer?.[section2]?.[key];
     if (typeof value === "number" && value >= 0)
       return value;
   }
@@ -9580,6 +9683,69 @@ function profileList(layer, file) {
     };
   });
 }
+function readRoute(user, userFile, repo, repoFile, env) {
+  const sections = [
+    { layer: section(user, "route", userFile), file: userFile },
+    { layer: section(repo, "route", repoFile), file: repoFile }
+  ];
+  const known = ["enabled", "builtin", "disable", "triggers", "ignore", "message"];
+  const route2 = { ...ROUTE_DEFAULTS, disable: [], triggers: [], ignore: [] };
+  for (const { layer, file } of sections) {
+    if (!layer)
+      continue;
+    const extra = Object.keys(layer).filter((k) => !known.includes(k));
+    if (extra.length > 0) {
+      throw new DecisionsError("config-error", `${file}: unknown route key(s) ${extra.join(", ")}. Known: ${known.join(", ")}`, { file });
+    }
+    for (const key of ["enabled", "builtin"]) {
+      const v = layer[key];
+      if (v === void 0)
+        continue;
+      if (typeof v !== "boolean")
+        throw new DecisionsError("config-error", `${file}: route.${key} must be true or false`, {
+          file
+        });
+      route2[key] = v;
+    }
+    if (layer.message !== void 0) {
+      if (typeof layer.message !== "string" || !layer.message.trim())
+        throw new DecisionsError("config-error", `${file}: route.message must be text`, { file });
+      route2.message = layer.message;
+    }
+    for (const key of ["disable", "ignore"]) {
+      const v = layer[key];
+      if (v === void 0)
+        continue;
+      if (!Array.isArray(v) || !v.every((x) => typeof x === "string"))
+        throw new DecisionsError("config-error", `${file}: route.${key} must be a list of strings`, { file });
+      route2[key].push(...v);
+    }
+    if (layer.triggers !== void 0)
+      route2.triggers.push(...triggerList(layer.triggers, file));
+  }
+  if (/^(0|off|false|no)$/i.test(env.SYSTEM1_ROUTE ?? ""))
+    route2.enabled = false;
+  return route2;
+}
+function section(layer, key, file) {
+  const value = layer?.[key];
+  if (value === void 0 || value === null)
+    return void 0;
+  if (typeof value !== "object" || Array.isArray(value))
+    throw new DecisionsError("config-error", `${file}: ${key} must be a mapping`, { file });
+  return value;
+}
+function triggerList(value, file) {
+  if (!Array.isArray(value))
+    throw new DecisionsError("config-error", `${file}: route.triggers must be a list`, { file });
+  return value.map((t, i) => {
+    const { name, pattern } = t ?? {};
+    if (typeof name !== "string" || !name.trim() || typeof pattern !== "string" || !pattern) {
+      throw new DecisionsError("config-error", `${file}: route.triggers[${i}] needs a name and a pattern (a regular expression)`, { file });
+    }
+    return { name, pattern };
+  });
+}
 function resolveApiKey(env, userDir) {
   const fromEnv = nonEmpty2(env.OPENROUTER_API_KEY);
   if (fromEnv)
@@ -9618,7 +9784,7 @@ function setConsent(repoRoot, granted, by, now = /* @__PURE__ */ new Date()) {
 function assertConsent(consent, repoRoot) {
   if (consent.granted)
     return;
-  throw new DecisionsError("egress-refused", `This repo has not agreed to send content to the decision model's provider. Run \`decide config egress allow\` in ${repoRoot} (or use the setup skill) to consent. Replay of recorded answers works without consent.`, { repoRoot });
+  throw new DecisionsError("egress-refused", `This repo has not agreed to send content to the decision model's provider. Consent is the user's: they run \`decide config egress allow\` in ${repoRoot} themselves (the setup skill explains what gets sent). Replay of recorded answers works without consent.`, { repoRoot });
 }
 
 // ../core/dist/egress/exclude.js
@@ -18822,7 +18988,12 @@ function resolvePath(cwd, path) {
     realAbsolute = realpathSync2(absolute);
   } catch {
   }
-  const real = toRel(cwd, realAbsolute);
+  let realCwd = cwd;
+  try {
+    realCwd = realpathSync2(cwd);
+  } catch {
+  }
+  const real = toRel(realCwd, realAbsolute);
   return {
     absolute,
     display: toRel(cwd, absolute),
@@ -18951,7 +19122,7 @@ function gitIgnored(cwd, paths) {
     if (error.status === 1)
       return [];
     if (error.signal === "SIGKILL") {
-      throw new DecisionsError("source-error", `git check-ignore did not answer within ${GIT_TIMEOUT_MS} ms. Name the files with --file, or run where git works.`);
+      throw new DecisionsError("source-error", `git check-ignore did not answer within ${GIT_TIMEOUT_MS} ms, which usually means a sandbox is blocking child processes (\`decide doctor\` prints the fix for Codex). Name the files with --file, or run where git works.`);
     }
     throw new DecisionsError("source-error", `git check-ignore failed: ${String(error)}`);
   }
@@ -19564,11 +19735,16 @@ var SpecCheckInput = typebox_exports.Object({
   /** Proceed past the spend guard. */
   confirm: typebox_exports.Optional(typebox_exports.Boolean())
 }, strict);
+var RouteInput = typebox_exports.Object({
+  /** The user's prompt, as the harness hook received it. */
+  prompt: typebox_exports.String()
+}, strict);
 var TOOL_SCHEMAS = {
   ask: AskInput,
   many: ManyInput,
   usage: UsageInput,
-  "spec-check": SpecCheckInput
+  "spec-check": SpecCheckInput,
+  route: RouteInput
 };
 
 // ../core/dist/tools/context.js
@@ -19756,7 +19932,8 @@ function createDecider(options) {
         const started = performance.now();
         const record = fixtures?.lookup(namespace, request);
         if (!record) {
-          throw new DecisionsError("replay-miss", `No recorded answer for this request (namespace "${namespace}", key ${key.slice(0, 12)}\u2026). Record it with a live call, or set OPENROUTER_API_KEY.`, { namespace, key });
+          const where = `(namespace "${namespace}", key ${key.slice(0, 12)}\u2026)`;
+          throw new DecisionsError("replay-miss", transport ? `No recorded answer for this request ${where}. Record it with a live call (without --replay or SYSTEM1_REPLAY).` : `No API key is set, so only recorded answers can be used, and this request has none ${where}. Set OPENROUTER_API_KEY for a live answer (the setup skill shows where it goes).`, { namespace, key });
         }
         log2("replay", profile.id, ZERO);
         return {
@@ -20217,6 +20394,31 @@ async function runAsk(ctx, rawInput) {
 // ../core/dist/tools/doctor.js
 import { accessSync, constants, statSync as statSync4 } from "node:fs";
 import { delimiter, join as join5 } from "node:path";
+function routeCheck(config) {
+  try {
+    route("", config);
+    if (!config.enabled) {
+      return {
+        name: "route",
+        status: "ok",
+        detail: "routing hints are off (route.enabled or SYSTEM1_ROUTE)"
+      };
+    }
+    const names = activeTriggers(config).map((t) => t.name);
+    return {
+      name: "route",
+      status: "ok",
+      detail: `routing hints on: ${names.length ? names.join(", ") : "no triggers"}`
+    };
+  } catch (error) {
+    return {
+      name: "route",
+      status: "warn",
+      detail: `routing hints are silent: ${error instanceof Error ? error.message : String(error)}`,
+      fix: 'correct route: in the config file (test it with `decide route --text "\u2026"`)'
+    };
+  }
+}
 var CODEX_RULE = 'prefix_rule(pattern = ["decide"], decision = "allow")';
 async function runDoctor(options) {
   const { env } = options;
@@ -20259,7 +20461,8 @@ async function runDoctor(options) {
     name: "key",
     status: "warn",
     detail: "no API key: only replay works",
-    fix: "set OPENROUTER_API_KEY, or write `openrouter_api_key: <key>` to ~/.config/system1/credentials (chmod 600)"
+    // The file this shell would read: XDG_CONFIG_HOME moves it.
+    fix: `set OPENROUTER_API_KEY, or write \`openrouter_api_key: <key>\` to ${join5(userConfigDir(env, options.home), "credentials")} (chmod 600)`
   });
   checks.push(config.egress.consent.granted ? { name: "consent", status: "ok", detail: `egress consent granted for ${config.repoRoot}` } : {
     name: "consent",
@@ -20267,6 +20470,7 @@ async function runDoctor(options) {
     detail: `no egress consent for ${config.repoRoot}: live calls are refused`,
     fix: "the user runs `decide config egress allow` in this repo, if they agree"
   });
+  checks.push(routeCheck(config.route));
   let reach;
   try {
     reach = await ping({
@@ -20387,6 +20591,33 @@ function which(name, path) {
   return void 0;
 }
 
+// ../core/dist/tools/route.js
+function runRoute(options, rawInput) {
+  const problems = checkRouteInput(rawInput);
+  if (problems.length > 0) {
+    throw new DecisionsError("invalid-request", `Invalid route input:
+  ${problems.join("\n  ")}`, {
+      problems
+    });
+  }
+  const input = rawInput;
+  const config = loadConfig(options);
+  const { user, repo } = config.layers;
+  return {
+    ...route(input.prompt, config.route),
+    files: { ...user ? { user } : {}, ...repo ? { repo } : {} }
+  };
+}
+function checkRouteInput(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input))
+    return ["/ must be an object"];
+  const extra = Object.keys(input).filter((k) => k !== "prompt");
+  return [
+    ...typeof input.prompt === "string" ? [] : ["/prompt must be a string"],
+    ...extra.map((k) => `/${k} is not allowed`)
+  ];
+}
+
 // ../core/dist/tools/spec-check.js
 async function runSpecCheck(ctx, rawInput) {
   const input = checkInput("spec-check", rawInput);
@@ -20577,6 +20808,7 @@ export {
   runMany,
   runAsk,
   runDoctor,
+  runRoute,
   runSpecCheck,
   runUsage,
   resolveConnection

package/dist/bundle/chunks/{config-QR35VKVT.mjs → config-REALJZDR.mjs}

@@ -1,18 +1,18 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
   typedParse
-} from "./chunk-A7ODZFMY.mjs";
+} from "./chunk-4BSTNWLV.mjs";
 import {
   DEFAULT_EXCLUDES,
   createContext,
   loadConfig,
   repoConfigPath,
   setConsent
-} from "./chunk-V7OTO67I.mjs";
+} from "./chunk-S5AIBUL7.mjs";
 import {
   DecisionsError,
   emit
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // src/commands/config.ts
 function runConfigCommand(argv, io, format) {
@@ -24,11 +24,12 @@ function runConfigCommand(argv, io, format) {
     (r, f) => f === "brief" ? brief(r) : void 0
   );
 }
+var CONFIG_OPTIONS = { confirm: { type: "boolean" }, by: { type: "string" } };
 function body(argv, io) {
   const { values, positionals } = typedParse({
     args: argv,
     allowPositionals: true,
-    options: { confirm: { type: "boolean" }, by: { type: "string" } }
+    options: CONFIG_OPTIONS
   });
   const [section = "show", action = "status"] = positionals;
   const cwd = io.cwd ?? process.cwd();
@@ -112,5 +113,6 @@ function brief(r) {
   ].join("\n");
 }
 export {
+  CONFIG_OPTIONS,
   runConfigCommand
 };

package/dist/bundle/chunks/{decide-PW7REJ6Y.mjs → decide-XVVRKQ3V.mjs}

@@ -6,17 +6,17 @@ import {
 import {
   buildInput,
   parseDecideFlags
-} from "./chunk-A7ODZFMY.mjs";
+} from "./chunk-4BSTNWLV.mjs";
 import {
   createContext,
   runAsk,
   runMany
-} from "./chunk-V7OTO67I.mjs";
+} from "./chunk-S5AIBUL7.mjs";
 import {
   DecisionsError,
   ENVELOPE_VERSION,
   emit
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // src/commands/decide.ts
 import { readFileSync } from "node:fs";

package/dist/bundle/chunks/{doctor-HAT6XVTW.mjs → doctor-TKFVFCZV.mjs}

@@ -1,10 +1,10 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
   runDoctor
-} from "./chunk-V7OTO67I.mjs";
+} from "./chunk-S5AIBUL7.mjs";
 import {
   emit
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // src/commands/doctor.ts
 import { execFile } from "node:child_process";
@@ -25,7 +25,7 @@ function runDoctorCommand(io, format) {
 }
 function brief(r) {
   const lines = [
-    `decide doctor: ${r.healthy ? "healthy" : "PROBLEMS FOUND"} \xB7 ${r.live ? "live ready" : "replay only"} \xB7 harness ${r.harness ?? "none"} \xB7 session ${r.session ?? "none"}`
+    `decide doctor: ${headline(r)} \xB7 ${r.live ? "live ready" : "replay only"} \xB7 harness ${r.harness ?? "none"} \xB7 session ${r.session ?? "none"}`
   ];
   for (const c of r.checks) {
     lines.push(`  ${c.status.padEnd(4)} ${c.name}: ${c.detail}`);
@@ -33,6 +33,11 @@ function brief(r) {
   }
   return lines.join("\n");
 }
+function headline(r) {
+  if (!r.healthy) return "PROBLEMS FOUND";
+  const missing = r.checks.filter((c) => c.status === "warn").map((c) => c.name);
+  return !r.live && missing.length > 0 ? `SETUP NEEDED (${missing.join(", ")})` : "healthy";
+}
 function probeVersion(path, env, timeoutMs = 2e3) {
   return new Promise((resolve) => {
     let settled = false;

package/dist/bundle/chunks/{misc-6VZKJEN4.mjs → misc-FHOVQJ2G.mjs}

@@ -1,19 +1,19 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
   typedParse
-} from "./chunk-A7ODZFMY.mjs";
+} from "./chunk-4BSTNWLV.mjs";
 import {
   TOOL_SCHEMAS,
   createContext,
   ping,
   resolveConnection,
   runUsage
-} from "./chunk-V7OTO67I.mjs";
+} from "./chunk-S5AIBUL7.mjs";
 import {
   DecisionsError,
   EXIT,
   emit
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // src/commands/misc.ts
 function runSchemaCommand(argv, io, format) {
@@ -28,6 +28,7 @@ function runSchemaCommand(argv, io, format) {
     return TOOL_SCHEMAS[tool];
   });
 }
+var USAGE_OPTIONS = { session: { type: "string" }, since: { type: "string" } };
 function runUsageCommand(argv, io, format) {
   return emit(
     io,
@@ -36,7 +37,7 @@ function runUsageCommand(argv, io, format) {
     () => {
       const { values } = typedParse({
         args: argv,
-        options: { session: { type: "string" }, since: { type: "string" } }
+        options: USAGE_OPTIONS
       });
       const ctx = createContext({ ...io, cwd: io.cwd ?? process.cwd(), env: io.env });
       return runUsage(ctx, {
@@ -72,6 +73,7 @@ async function runPingCommand(io, format) {
   return failed ? EXIT.providerError : code;
 }
 export {
+  USAGE_OPTIONS,
   runPingCommand,
   runSchemaCommand,
   runUsageCommand

package/dist/bundle/chunks/route-NMFOTXLI.mjs

@@ -0,0 +1,64 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  typedParse
+} from "./chunk-4BSTNWLV.mjs";
+import {
+  runRoute
+} from "./chunk-S5AIBUL7.mjs";
+import {
+  DecisionsError,
+  emit
+} from "./chunk-NUIZJRI6.mjs";
+
+// src/commands/route.ts
+import { readFileSync } from "node:fs";
+var ROUTE_OPTIONS = {
+  text: { type: "string" },
+  stdin: { type: "boolean" },
+  hook: { type: "boolean" }
+};
+function runRouteCommand(argv, io, format) {
+  return emit(
+    io,
+    "route",
+    format,
+    () => {
+      const { values } = typedParse({ args: argv, options: ROUTE_OPTIONS });
+      const given = [values.text !== void 0, values.stdin, values.hook].filter(Boolean).length;
+      if (given !== 1) {
+        throw new DecisionsError(
+          "invalid-request",
+          "Usage: decide route --text <prompt> | --stdin | --hook  (exactly one)"
+        );
+      }
+      const read = io.readStdin ?? (() => readFileSync(0, "utf8"));
+      let prompt = values.text;
+      let cwd = io.cwd ?? process.cwd();
+      if (values.stdin) prompt = read();
+      if (values.hook) {
+        const event = parseHookEvent(read());
+        prompt = event.prompt;
+        if (event.cwd) cwd = event.cwd;
+      }
+      return runRoute({ cwd, env: io.env, ...io.home ? { home: io.home } : {} }, { prompt });
+    },
+    (r, f) => f === "brief" ? r.message ?? "" : void 0
+  );
+}
+function parseHookEvent(text) {
+  let event;
+  try {
+    event = JSON.parse(text);
+  } catch {
+    throw new DecisionsError("invalid-request", "--hook expects a JSON hook event on stdin");
+  }
+  const { prompt, cwd } = event ?? {};
+  if (typeof prompt !== "string") {
+    throw new DecisionsError("invalid-request", "--hook: the event has no `prompt` string");
+  }
+  return { prompt, ...typeof cwd === "string" && cwd ? { cwd } : {} };
+}
+export {
+  ROUTE_OPTIONS,
+  runRouteCommand
+};

package/dist/bundle/chunks/{spec-Z2LZJ5EZ.mjs → spec-734MPBKB.mjs}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-5LVOFZF3.mjs";
 import {
   typedParse
-} from "./chunk-A7ODZFMY.mjs";
+} from "./chunk-4BSTNWLV.mjs";
 import {
   assertExamples,
   createContext,
@@ -12,11 +12,11 @@ import {
   listSpecs,
   loadSpec,
   runSpecCheck
-} from "./chunk-V7OTO67I.mjs";
+} from "./chunk-S5AIBUL7.mjs";
 import {
   DecisionsError,
   emit
-} from "./chunk-7LVHD6A5.mjs";
+} from "./chunk-NUIZJRI6.mjs";
 
 // src/commands/spec.ts
 function runSpecCommand(argv, io, format) {
@@ -105,19 +105,21 @@ function checkInput(argv) {
     ...values.model ? { model: values.model } : {}
   };
 }
+var SPEC_OPTIONS = {
+  live: { type: "boolean" },
+  replay: { type: "boolean" },
+  confirm: { type: "boolean" },
+  model: { type: "string" }
+};
 function parse(argv) {
   return typedParse({
     args: argv,
     allowPositionals: true,
     strict: true,
-    options: {
-      live: { type: "boolean" },
-      replay: { type: "boolean" },
-      confirm: { type: "boolean" },
-      model: { type: "string" }
-    }
+    options: SPEC_OPTIONS
   });
 }
 export {
+  SPEC_OPTIONS,
   runSpecCommand
 };

package/dist/bundle/decide.mjs

@@ -4,4 +4,4 @@ import { createRequire as __decideRequire } from "node:module"; const require =
 // src/entry.ts
 import module from "node:module";
 module.enableCompileCache?.();
-await import("./chunks/bin-IIUCANF7.mjs");
+await import("./chunks/bin-TCIHP5PC.mjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garygentry/system1",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "The `decide` CLI: typed, calibrated decisions for coding agents, hooks and CI.",
   "type": "module",
   "license": "MIT",
@@ -20,14 +20,14 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/garygentry/system1",
+    "url": "git+https://github.com/garygentry/system1.git",
     "directory": "packages/cli"
   },
   "engines": {
     "node": ">=22"
   },
   "bin": {
-    "decide": "./dist/bundle/decide.mjs"
+    "decide": "dist/bundle/decide.mjs"
   },
   "files": [
     "dist/bundle",