@garygentry/system1 0.3.1 → 0.4.0

package/dist/bundle/chunks/{chunk-JD7HVXW5.mjs → chunk-WZIVOY5Q.mjs}

@@ -70,7 +70,13 @@ var EXIT = {
   egressRefused: 3,
   budgetGuard: 4,
   providerError: 5,
-  replayMiss: 6
+  replayMiss: 6,
+  /**
+   * The check ran and did not pass: `spec check --strict` (an example missed),
+   * or `spec lint` (an error-level finding or invalid spec; with `--strict`, any
+   * warning).
+   */
+  checkFailed: 7
 };
 var BY_CODE = {
   "invalid-request": EXIT.usage,
@@ -145,7 +151,7 @@ function extractFormat(argv, fallback) {
 }
 
 // ../core/dist/version.js
-var VERSION = "0.3.1";
+var VERSION = "0.4.0";
 var CLI_PACKAGE = "@garygentry/system1";
 
 export {

package/dist/bundle/chunks/{chunk-X2CYN5PB.mjs → chunk-XNRV73UE.mjs}

@@ -2,10 +2,10 @@ import { createRequire as __decideRequire } from "node:module"; const require =
 import {
   parseFileRef,
   parseQuestionSet
-} from "./chunk-O6BSAJIH.mjs";
+} from "./chunk-QYUSJUFX.mjs";
 import {
   DecisionsError
-} from "./chunk-JD7HVXW5.mjs";
+} from "./chunk-WZIVOY5Q.mjs";
 
 // src/args.ts
 import { readFileSync } from "node:fs";
@@ -23,9 +23,11 @@ var DECIDE_OPTIONS = {
   staged: { type: "boolean" },
   text: { type: "string" },
   stdin: { type: "boolean" },
+  exclude: { type: "string", multiple: true },
   "allow-outside": { type: "boolean" },
   split: { type: "string" },
   keep: { type: "string", multiple: true },
+  "keep-any": { type: "string", multiple: true },
   sort: { type: "string" },
   limit: { type: "string" },
   fields: { type: "string" },
@@ -104,8 +106,10 @@ function buildInput(values, readStdin, cwd = process.cwd()) {
     );
   }
   if (sources.length) input.sources = sources;
+  set("exclude", values.exclude?.length ? values.exclude : void 0);
   set("split", values.split);
   set("keep", values.keep?.length ? values.keep : void 0);
+  set("keepAny", values["keep-any"]?.length ? values["keep-any"] : void 0);
   set("sort", values.sort);
   set("limit", int(values.limit, "--limit"));
   set(

package/dist/bundle/chunks/{config-QMTA6YOP.mjs → config-KXGUNAJR.mjs}

@@ -1,18 +1,20 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
   typedParse
-} from "./chunk-X2CYN5PB.mjs";
+} from "./chunk-XNRV73UE.mjs";
 import {
   DEFAULT_EXCLUDES,
+  activeTriggers,
+  allProfiles,
   createContext,
   loadConfig,
   repoConfigPath,
   setConsent
-} from "./chunk-O6BSAJIH.mjs";
+} from "./chunk-QYUSJUFX.mjs";
 import {
   DecisionsError,
   emit
-} from "./chunk-JD7HVXW5.mjs";
+} from "./chunk-WZIVOY5Q.mjs";
 
 // src/commands/config.ts
 function runConfigCommand(argv, io, format) {
@@ -49,12 +51,17 @@ function body(argv, io) {
       if (!io.interactive && !values.confirm) {
         throw new DecisionsError(
           "egress-refused",
-          "Egress consent is the user's decision. Ask the user to run `decide config egress allow` themselves (in Claude Code: `! decide config egress allow`)."
+          "Egress consent is the user's decision. An agent must not grant it, with or without --confirm: show the user this message instead. The user grants it by typing `decide config egress allow` in a terminal at the repo root. If they run it through their agent prompt's shell escape instead (not as a chat message), there is no terminal, so they add --confirm to say the decision is theirs."
         );
       }
       return {
         egress: {
-          consent: setConsent(config.repoRoot, true, values.by ?? "decide config"),
+          // Record which route granted it: a terminal, or --confirm without one.
+          consent: setConsent(
+            config.repoRoot,
+            true,
+            values.by ?? (io.interactive ? "decide config" : "decide config --confirm")
+          ),
           file,
           changed: true
         }
@@ -82,6 +89,7 @@ function show(io, cwd) {
     model: config.model,
     endpoint: config.endpoint,
     concurrency: config.concurrency,
+    timeoutMs: config.timeoutMs,
     budget: config.budget,
     egress: {
       consent: config.egress.consent,
@@ -92,8 +100,15 @@ function show(io, cwd) {
     replay: config.replay,
     session: config.session ?? null,
     sessionOrigin: config.sessionOrigin ?? null,
+    /**
+     * The profiles in effect for the ids the config files set, one per id: an
+     * override of a built-in shows once. Built-ins nobody overrides are not repeated.
+     */
+    profiles: allProfiles(config).filter((p) => config.profiles.some((c) => c.id === p.id)),
+    route: config.route,
     files: config.layers,
-    specDirs: ctx.specDirs
+    specDirs: ctx.specDirs,
+    warnings: config.warnings
   };
 }
 function brief(r) {
@@ -106,12 +121,24 @@ function brief(r) {
     `repo: ${r.repoRoot}`,
     `model: ${r.model} via ${r.endpoint}`,
     `key: ${r.apiKey}${r.replay ? " \xB7 SYSTEM1_REPLAY forces replay" : ""}`,
-    `egress consent: ${c.granted ? `granted ${c.at ?? ""}`.trim() : "not granted \u2014 run `decide config egress allow`"}`,
+    `egress consent: ${c.granted ? `granted ${c.at ?? ""}`.trim() : "not granted (the user grants it; see `decide doctor`)"}`,
     `excludes: ${r.egress.defaultExcludes} default${r.egress.exclude.length ? ` + ${r.egress.exclude.join(", ")}` : ""}`,
-    `budget: ${r.budget.maxCalls} calls / $${r.budget.maxUsd} per request \xB7 concurrency ${r.concurrency}`,
-    `session: ${r.session ? `${r.session} (${r.sessionOrigin === "env" ? "SYSTEM1_SESSION" : `detected from ${r.sessionOrigin}`})` : "none"}`
+    `budget: ${r.budget.maxCalls} calls / $${r.budget.maxUsd} per request \xB7 concurrency ${r.concurrency} \xB7 timeout ${r.timeoutMs} ms`,
+    ...r.profiles.length ? [`profiles: ${r.profiles.map((p) => p.id).join(", ")}`] : [],
+    `route: ${routeLine(r.route)}`,
+    `session: ${r.session ? `${r.session} (${r.sessionOrigin === "env" ? "SYSTEM1_SESSION" : `detected from ${r.sessionOrigin}`})` : "none"}`,
+    ...r.warnings.length ? [`ignored: ${r.warnings.join("; ")}`] : []
   ].join("\n");
 }
+function routeLine(route) {
+  if (!route.enabled) return "off";
+  try {
+    const names = activeTriggers(route).map((t) => t.name);
+    return `on \xB7 ${names.join(", ") || "no triggers"}`;
+  } catch (error) {
+    return `invalid (${error instanceof Error ? error.message : String(error)})`;
+  }
+}
 export {
   CONFIG_OPTIONS,
   runConfigCommand

package/dist/bundle/chunks/{decide-4QGC5ZEB.mjs → decide-HI5CUH3C.mjs}

@@ -2,21 +2,21 @@ import { createRequire as __decideRequire } from "node:module"; const require =
 import {
   briefAsk,
   briefMany
-} from "./chunk-5LVOFZF3.mjs";
+} from "./chunk-FU3D2MBS.mjs";
 import {
   buildInput,
   parseDecideFlags
-} from "./chunk-X2CYN5PB.mjs";
+} from "./chunk-XNRV73UE.mjs";
 import {
   createContext,
   runAsk,
   runMany
-} from "./chunk-O6BSAJIH.mjs";
+} from "./chunk-QYUSJUFX.mjs";
 import {
   DecisionsError,
   ENVELOPE_VERSION,
   emit
-} from "./chunk-JD7HVXW5.mjs";
+} from "./chunk-WZIVOY5Q.mjs";
 
 // src/commands/decide.ts
 import { readFileSync } from "node:fs";

package/dist/bundle/chunks/{doctor-JJIUAYN7.mjs → doctor-NDV3Y6T7.mjs}

@@ -1,10 +1,10 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
   runDoctor
-} from "./chunk-O6BSAJIH.mjs";
+} from "./chunk-QYUSJUFX.mjs";
 import {
   emit
-} from "./chunk-JD7HVXW5.mjs";
+} from "./chunk-WZIVOY5Q.mjs";
 
 // src/commands/doctor.ts
 import { execFile } from "node:child_process";

package/dist/bundle/chunks/{misc-U5ZFC6EC.mjs → misc-6SDKH2PI.mjs}

@@ -1,19 +1,22 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
   typedParse
-} from "./chunk-X2CYN5PB.mjs";
+} from "./chunk-XNRV73UE.mjs";
 import {
   TOOL_SCHEMAS,
   createContext,
+  loadConfig,
   ping,
+  probeUrl,
   resolveConnection,
   runUsage
-} from "./chunk-O6BSAJIH.mjs";
+} from "./chunk-QYUSJUFX.mjs";
 import {
   DecisionsError,
   EXIT,
-  emit
-} from "./chunk-JD7HVXW5.mjs";
+  emit,
+  isDecisionsError
+} from "./chunk-WZIVOY5Q.mjs";
 
 // src/commands/misc.ts
 function runSchemaCommand(argv, io, format) {
@@ -55,7 +58,20 @@ async function runPingCommand(io, format) {
     "ping",
     format,
     async () => {
-      const result = await ping(resolveConnection(io.env), io.fetch ? { fetch: io.fetch } : {});
+      const { config, configError } = connection(io);
+      try {
+        probeUrl(config);
+      } catch {
+        throw new DecisionsError(
+          "config-error",
+          `endpoint ${config.endpoint} is not a URL: correct SYSTEM1_ENDPOINT or \`endpoint\` in the config file`,
+          { endpoint: config.endpoint }
+        );
+      }
+      const result = {
+        ...await ping(config, io.fetch ? { fetch: io.fetch } : {}),
+        ...configError ? { configError } : {}
+      };
       failed = !result.ok;
       if (!result.ok && format !== "brief") {
         throw new DecisionsError("provider-unreachable", result.error ?? "unreachable", {
@@ -67,11 +83,28 @@ async function runPingCommand(io, format) {
     (r, f) => {
       if (f !== "brief") return void 0;
       const key = r.keyPresent ? "key: present" : "key: absent (replay only)";
-      return r.ok ? `decide ping: ok \u2014 ${r.model} reachable in ${r.latencyMs} ms (${key})` : `decide ping: FAILED \u2014 ${r.probe}: ${r.error} (${key})`;
+      const line = r.ok ? `decide ping: ok \u2014 ${r.model} reachable in ${r.latencyMs} ms (${key})` : `decide ping: FAILED \u2014 ${r.probe}: ${r.error} (${key})`;
+      return r.configError ? `${line}
+config not loaded, so this used the environment only: ${r.configError}` : line;
     }
   );
   return failed ? EXIT.providerError : code;
 }
+function connection(io) {
+  try {
+    const config = loadConfig({
+      cwd: io.cwd ?? process.cwd(),
+      env: io.env,
+      ...io.home ? { home: io.home } : {}
+    });
+    const { endpoint, model, apiKey, replay } = config;
+    return { config: { endpoint, model, apiKey, replay } };
+  } catch (error) {
+    if (isDecisionsError(error) && error.code === "config-error")
+      return { config: resolveConnection(io.env), configError: error.message };
+    throw error;
+  }
+}
 export {
   USAGE_OPTIONS,
   runPingCommand,

package/dist/bundle/chunks/opportunities-ONEIYAG3.mjs

@@ -0,0 +1,144 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  typedParse
+} from "./chunk-XNRV73UE.mjs";
+import {
+  createContext,
+  runOpportunitiesAdd,
+  runOpportunitiesCheck,
+  runOpportunitiesList
+} from "./chunk-QYUSJUFX.mjs";
+import {
+  DecisionsError,
+  emit
+} from "./chunk-WZIVOY5Q.mjs";
+
+// src/commands/opportunities.ts
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+var OPPORTUNITIES_OPTIONS = {
+  file: { type: "string" },
+  keep: { type: "string", multiple: true },
+  sort: { type: "string" },
+  limit: { type: "string" },
+  fields: { type: "string" }
+};
+var USAGE = "Usage: decide opportunities add --file <candidates.json> | list [--keep \u2026] [--sort \u2026] [--limit N] [--fields a,b] | check";
+function runOpportunitiesCommand(argv, io, format) {
+  const [action, ...rest] = argv;
+  const ctx = () => createContext({ ...io, cwd: io.cwd ?? process.cwd(), env: io.env });
+  const cwd = io.cwd ?? process.cwd();
+  switch (action) {
+    case "add":
+      return emit(
+        io,
+        "opportunities",
+        format,
+        () => {
+          const { values } = parse(rest, ["file"]);
+          if (!values.file) throw new DecisionsError("invalid-request", USAGE);
+          return runOpportunitiesAdd(ctx(), {
+            candidates: readCandidates(resolve(cwd, values.file), values.file)
+          });
+        },
+        (r, f) => f === "brief" ? `decide opportunities add: ${r.added.length} added \xB7 ${r.updated.length} updated \xB7 ${r.staled.length} marked stale \xB7 ${r.total} in ${r.file}` : void 0
+      );
+    case "list":
+      return emit(
+        io,
+        "opportunities",
+        format,
+        () => {
+          const { values } = parse(rest, ["keep", "sort", "limit", "fields"]);
+          if (values.limit !== void 0 && !/^\d+$/.test(values.limit)) {
+            throw new DecisionsError("invalid-request", "--limit must be a whole number");
+          }
+          return runOpportunitiesList(ctx(), {
+            ...values.keep?.length ? { keep: values.keep } : {},
+            ...values.sort ? { sort: values.sort } : {},
+            ...values.limit !== void 0 ? { limit: Number(values.limit) } : {},
+            ...values.fields ? {
+              fields: values.fields.split(",").map((s) => s.trim()).filter(Boolean)
+            } : {}
+          });
+        },
+        (r, f) => f === "brief" ? briefList(r) : void 0
+      );
+    case "check":
+      return emit(
+        io,
+        "opportunities",
+        format,
+        () => {
+          parse(rest, []);
+          return runOpportunitiesCheck(ctx());
+        },
+        (r, f) => f === "brief" ? r.exists ? `decide opportunities check: valid \xB7 ${r.entries} entr${r.entries === 1 ? "y" : "ies"}${Object.keys(r.byStatus).length ? ` (${Object.entries(r.byStatus).map(([s, n]) => `${n} ${s}`).join(", ")})` : ""} \xB7 ${r.file}` : `decide opportunities check: no backlog yet (${r.file})` : void 0
+      );
+    default:
+      return emit(io, "opportunities", format, () => {
+        throw new DecisionsError("invalid-request", USAGE);
+      });
+  }
+}
+function parse(argv, allowed) {
+  const options = Object.fromEntries(allowed.map((k) => [k, OPPORTUNITIES_OPTIONS[k]]));
+  return typedParse({ args: argv, options, strict: true });
+}
+function readCandidates(path, ref) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    throw new DecisionsError("invalid-request", `--file: cannot read ${ref}`);
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    throw new DecisionsError(
+      "invalid-request",
+      `--file ${ref}: not JSON (${error.message})`
+    );
+  }
+  if (Array.isArray(value)) return value;
+  if (value && typeof value === "object" && "candidates" in value) {
+    const extra = Object.keys(value).filter((k) => k !== "candidates");
+    if (extra.length) {
+      throw new DecisionsError(
+        "invalid-request",
+        `--file ${ref}: unknown key(s) ${extra.join(", ")}; only "candidates" is read`
+      );
+    }
+    return value.candidates;
+  }
+  throw new DecisionsError(
+    "invalid-request",
+    `--file ${ref}: expected a JSON array of candidates, or {"candidates": [...]}`
+  );
+}
+function briefList(r) {
+  const lines = [
+    `decide opportunities list: ${r.opportunities.length} shown \xB7 ${r.matched} matched \xB7 ${r.total} total \xB7 savings projected`
+  ];
+  for (const o of r.opportunities) {
+    const where = o.location ? `${o.location.path}${o.location.lines ? `:${o.location.lines.start}-${o.location.lines.end}` : ""}` : "";
+    const saving = o.projected ? ` \xB7 $${o.projected.savingUsd} per ${o.projected.per} (projected)` : "";
+    const head = [
+      o.id,
+      o.status,
+      o.mode,
+      o.shape,
+      o.benefit,
+      o.risk ? `risk ${o.risk.level}` : void 0
+    ].filter(Boolean).join(" \xB7 ");
+    lines.push(`  ${head}${saving}${where ? `  ${where}` : ""}`);
+    if (o.mechanism) lines.push(`      ${o.mechanism}`);
+    if (o.statusReason) lines.push(`      ${o.status}: ${o.statusReason}`);
+  }
+  return lines.join("\n");
+}
+export {
+  OPPORTUNITIES_OPTIONS,
+  runOpportunitiesCommand
+};

package/dist/bundle/chunks/{route-L3LIB4DZ.mjs → route-BF5J2NLU.mjs}

@@ -1,14 +1,14 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
   typedParse
-} from "./chunk-X2CYN5PB.mjs";
+} from "./chunk-XNRV73UE.mjs";
 import {
   runRoute
-} from "./chunk-O6BSAJIH.mjs";
+} from "./chunk-QYUSJUFX.mjs";
 import {
   DecisionsError,
   emit
-} from "./chunk-JD7HVXW5.mjs";
+} from "./chunk-WZIVOY5Q.mjs";
 
 // src/commands/route.ts
 import { readFileSync } from "node:fs";

package/dist/bundle/chunks/{spec-Y52UMFEH.mjs → spec-GLTPEEON.mjs}

@@ -1,22 +1,25 @@
 import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
 import {
-  briefSpecCheck
-} from "./chunk-5LVOFZF3.mjs";
+  briefSpecCheck,
+  briefSpecLint
+} from "./chunk-FU3D2MBS.mjs";
 import {
   typedParse
-} from "./chunk-X2CYN5PB.mjs";
+} from "./chunk-XNRV73UE.mjs";
 import {
   assertExamples,
   createContext,
   exampleProblems,
   listSpecs,
   loadSpec,
-  runSpecCheck
-} from "./chunk-O6BSAJIH.mjs";
+  runSpecCheck,
+  runSpecLint
+} from "./chunk-QYUSJUFX.mjs";
 import {
   DecisionsError,
+  EXIT,
   emit
-} from "./chunk-JD7HVXW5.mjs";
+} from "./chunk-WZIVOY5Q.mjs";
 
 // src/commands/spec.ts
 function runSpecCommand(argv, io, format) {
@@ -70,29 +73,71 @@ function runSpecCommand(argv, io, format) {
         (r, f) => f === "brief" ? `valid: ${r.valid.join(", ") || "(none)"}` : void 0
       );
     case "check":
-      return emit(
-        io,
-        "spec",
-        format,
-        () => runSpecCheck(ctx(), checkInput(argv.slice(1))),
-        (r, f) => f === "brief" ? briefSpecCheck(r) : void 0
-      );
+      return check(argv.slice(1), io, format, ctx);
+    case "lint":
+      return lint(argv.slice(1), io, format, ctx);
     default:
       return emit(io, "spec", format, () => {
         throw new DecisionsError(
           "invalid-request",
-          `Unknown spec action "${action}". Use: list, show, validate, check`
+          `Unknown spec action "${action}". Use: list, show, validate, lint, check`
         );
       });
   }
 }
+async function check(argv, io, format, ctx) {
+  let failed = false;
+  const code = await emit(
+    io,
+    "spec",
+    format,
+    async () => {
+      const result = await runSpecCheck(ctx(), checkInput(argv));
+      failed = !result.passed;
+      return result;
+    },
+    (r, f) => f === "brief" ? briefSpecCheck(r) : void 0
+  );
+  return code === EXIT.ok && failed && parse(argv).values.strict ? EXIT.checkFailed : code;
+}
+async function lint(argv, io, format, ctx) {
+  let failed = false;
+  let strict = false;
+  const code = await emit(
+    io,
+    "spec",
+    format,
+    () => {
+      const { values, positionals } = typedParse({
+        args: argv,
+        allowPositionals: true,
+        strict: true,
+        options: LINT_OPTIONS
+      });
+      const [spec, extra] = positionals;
+      if (extra !== void 0) {
+        throw new DecisionsError(
+          "invalid-request",
+          "Usage: decide spec lint [name|path] [--strict]"
+        );
+      }
+      strict = values.strict ?? false;
+      const result = runSpecLint(ctx(), spec ? { spec } : {});
+      failed = !result.passed || strict && result.counts.warnings > 0;
+      return result;
+    },
+    (r, f) => f === "brief" ? briefSpecLint(r) : void 0
+  );
+  return code === EXIT.ok && failed ? EXIT.checkFailed : code;
+}
+var LINT_OPTIONS = { strict: { type: "boolean" } };
 function checkInput(argv) {
   const { values, positionals } = parse(argv);
   const [spec, extra] = positionals;
   if (!spec || extra !== void 0) {
     throw new DecisionsError(
       "invalid-request",
-      "Usage: decide spec check <name|path> [--live] [--confirm] [--model <id>]"
+      "Usage: decide spec check <name|path> [--live] [--confirm] [--model <id>] [--strict]"
     );
   }
   if (values.live && values.replay) {
@@ -109,7 +154,8 @@ var SPEC_OPTIONS = {
   live: { type: "boolean" },
   replay: { type: "boolean" },
   confirm: { type: "boolean" },
-  model: { type: "string" }
+  model: { type: "string" },
+  strict: { type: "boolean" }
 };
 function parse(argv) {
   return typedParse({

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-FN3DZQV3.mjs");
+await import("./chunks/bin-TIEUYIP3.mjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garygentry/system1",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "The `decide` CLI: typed, calibrated decisions for coding agents, hooks and CI.",
   "type": "module",
   "license": "MIT",