@seanmozeik/tripwire 0.6.7 → 0.7.0

package/src/lib/bash.ts

@@ -7,12 +7,11 @@
 // Shell operators (`;`, `&&`, `||`, `|`, `&`, newline). Each segment
 // Records its head token, positional args, flags, and redirect targets.
 //
-// Limitations:
-//   - No variable expansion. `$HOME` stays literal — rules that care about
-//     Paths should either reject literal env-var references or accept them.
-//   - Command substitution `$(...)` is collapsed into a single opaque
-//     Token (`__tripwire_cmd_sub__`) so safe-path checks fail safely.
-//   - Glob expansion is not performed.
+// Parsing notes:
+//   - Shell variables stay literal. Path rules handle known home references.
+//   - Command substitutions are inspected as nested commands. The outer
+//     command keeps an opaque marker for safe path classification.
+//   - Glob entries are expanded with Bun.Glob before path classification.
 
 import { parse, quote, type ParseEntry } from 'shell-quote';
 
@@ -181,7 +180,7 @@ const parseSegment = (entries: readonly ParseEntry[], fdBudget: FdBudget): Segme
       const last = tokens.at(-1);
       if (last !== undefined && /^[0-9]+$/.test(last) && fdBudget.remaining > 0) {
         tokens.pop();
-        fdBudget.remaining--;
+        fdBudget.remaining -= 1;
       }
       const target = entries[i + 1];
       if (target !== undefined && isStringToken(target)) {
@@ -189,19 +188,19 @@ const parseSegment = (entries: readonly ParseEntry[], fdBudget: FdBudget): Segme
         i += 2;
         continue;
       }
-      i++;
+      i += 1;
       continue;
     }
     for (const t of entryToTokens(e)) {
       tokens.push(t);
     }
-    i++;
+    i += 1;
   }
 
   if (tokens.length === 0) {
     return null;
   }
-  for (let j = 1; j < tokens.length; j++) {
+  for (let j = 1; j < tokens.length; j += 1) {
     const t = tokens[j]!;
     if (t.startsWith('-') && t !== '-') {
       flags.push(t);
@@ -209,13 +208,9 @@ const parseSegment = (entries: readonly ParseEntry[], fdBudget: FdBudget): Segme
       args.push(t);
     }
   }
-  // Normalise the head to its basename so command-name rules match regardless
-  // Of whether the command was invoked via absolute path (/bin/rm), a
-  // Homebrew-prefixed path (/opt/homebrew/bin/gog), or a relative ./rm form.
-  // This fixes the containment hole where `/bin/rm <unsafe>` bypassed every
-  // Rule that compared `seg.head === 'rm'`.  The `tokens` array is left
-  // Unchanged (raw reconstruction stays accurate); only the canonical `head`
-  // Used for matching is normalised.
+  // Use the executable basename for command rules. Keep the original tokens
+  // so an absolute or relative command path cannot bypass a rule and raw
+  // reconstruction stays accurate.
   const rawHead = tokens[0]!;
   const slashIdx = rawHead.lastIndexOf('/');
   const head = slashIdx === -1 ? rawHead : rawHead.slice(slashIdx + 1);
@@ -233,13 +228,13 @@ const PRESERVE_ENV = (key: string): string => `$${key}`;
 // `&>` / `&>>` before segment splitting.
 const mergeAmpRedirects = (entries: readonly ParseEntry[]): ParseEntry[] => {
   const out: ParseEntry[] = [];
-  for (let i = 0; i < entries.length; i++) {
+  for (let i = 0; i < entries.length; i += 1) {
     const e = entries[i]!;
     const next = entries[i + 1];
     if (getOp(e) === '&' && next !== undefined && (getOp(next) === '>' || getOp(next) === '>>')) {
       const merged = { op: getOp(next) === '>' ? '&>' : '&>>' } as unknown as ParseEntry;
       out.push(merged);
-      i++;
+      i += 1;
       continue;
     }
     // `>|file` is bash's noclobber-override redirect. shell-quote splits
@@ -249,7 +244,7 @@ const mergeAmpRedirects = (entries: readonly ParseEntry[]): ParseEntry[] => {
     // It's a write redirect to the following target).
     if (getOp(e) === '>' && next !== undefined && getOp(next) === '|') {
       out.push({ op: '>' } as unknown as ParseEntry);
-      i++;
+      i += 1;
       continue;
     }
     out.push(e);
@@ -284,20 +279,19 @@ const heredocFeedsShell = (line: string): boolean => SHELL_STDIN_HEAD_RE.test(li
 const maskLiteralHeredocBodies = (cmd: string): string => {
   const lines = cmd.split('\n');
   const out: string[] = [];
-  for (let i = 0; i < lines.length; i++) {
+  for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i]!;
     out.push(line);
     const delimiter = heredocDelimiterFromLine(line);
     if (delimiter === null || heredocFeedsShell(line)) {
       continue;
     }
-    i++;
+    i += 1;
     while (i < lines.length && lines[i]!.trim() !== delimiter) {
-      i++;
+      i += 1;
     }
     if (i < lines.length) {
-      out.push('__HEREDOC_BODY__');
-      out.push(lines[i]!);
+      out.push('__HEREDOC_BODY__', lines[i]!);
     }
   }
   return out.join('\n');
@@ -313,17 +307,17 @@ const maskLiteralHeredocBodies = (cmd: string): string => {
 const collectHeredocBodies = (cmd: string): ReadonlyMap<string, string> => {
   const map = new Map<string, string>();
   const lines = cmd.split('\n');
-  for (let i = 0; i < lines.length; i++) {
+  for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i]!;
     const delimiter = heredocDelimiterFromLine(line);
     if (delimiter === null || heredocFeedsShell(line)) {
       continue;
     }
     const body: string[] = [];
-    i++;
+    i += 1;
     while (i < lines.length && lines[i]!.trim() !== delimiter) {
       body.push(lines[i]!);
-      i++;
+      i += 1;
     }
     if (!map.has(delimiter)) {
       map.set(delimiter, body.join('\n'));
@@ -335,17 +329,17 @@ const collectHeredocBodies = (cmd: string): ReadonlyMap<string, string> => {
 const extractShellHeredocCommands = (cmd: string): string[] => {
   const lines = cmd.split('\n');
   const out: string[] = [];
-  for (let i = 0; i < lines.length; i++) {
+  for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i]!;
     const delimiter = heredocDelimiterFromLine(line);
     if (delimiter === null || !heredocFeedsShell(line)) {
       continue;
     }
     const body: string[] = [];
-    i++;
+    i += 1;
     while (i < lines.length && lines[i]!.trim() !== delimiter) {
       body.push(lines[i]!);
-      i++;
+      i += 1;
     }
     if (body.length > 0) {
       out.push(body.join('\n'));
@@ -365,10 +359,10 @@ const extractShellHeredocCommands = (cmd: string): string[] => {
 // A literal). Process/command substitutions can nest arbitrarily — a depth
 // Counter handles the balanced parens.
 const findBacktickEnd = (cmd: string, start: number): number | null => {
-  for (let i = start; i < cmd.length; i++) {
+  for (let i = start; i < cmd.length; i += 1) {
     const ch = cmd[i]!;
     if (ch === '\\') {
-      i++;
+      i += 1;
       continue;
     }
     if (ch === '`') {
@@ -381,10 +375,10 @@ const findBacktickEnd = (cmd: string, start: number): number | null => {
 const findSubstitutionEnd = (cmd: string, start: number): number | null => {
   let depth = 1;
   let quote: 'single' | 'double' | null = null;
-  for (let j = start; j < cmd.length; j++) {
+  for (let j = start; j < cmd.length; j += 1) {
     const cj = cmd[j]!;
     if (cj === '\\') {
-      j++;
+      j += 1;
       continue;
     }
     if (quote === 'single') {
@@ -402,11 +396,11 @@ const findSubstitutionEnd = (cmd: string, start: number): number | null => {
       continue;
     }
     if (cj === '(') {
-      depth++;
+      depth += 1;
       continue;
     }
     if (cj === ')') {
-      depth--;
+      depth -= 1;
       if (depth === 0) {
         return j;
       }
@@ -418,10 +412,10 @@ const findSubstitutionEnd = (cmd: string, start: number): number | null => {
 const extractInnerCommands = (cmd: string): string[] => {
   const inner: string[] = [];
   let quote: 'single' | 'double' | null = null;
-  for (let i = 0; i < cmd.length; i++) {
+  for (let i = 0; i < cmd.length; i += 1) {
     const ch = cmd[i]!;
     if (ch === '\\') {
-      i++;
+      i += 1;
       continue;
     }
     if (quote === 'single') {
@@ -572,13 +566,13 @@ const pickFdSearchRoot = (tokens: readonly string[], execFlagIdx: number): strin
       continue;
     }
     if (t.startsWith('-')) {
-      i++;
+      i += 1;
       continue;
     }
     if (pathLikeToken(t)) {
       candidates.push(t);
     }
-    i++;
+    i += 1;
   }
   if (candidates.length === 0) {
     return '.';
@@ -593,7 +587,7 @@ const pickFdSearchRoot = (tokens: readonly string[], execFlagIdx: number): strin
 // Path-shaped in the prefix region as candidates.
 const pickFindSearchRoot = (tokens: readonly string[], execFlagIdx: number): string => {
   const candidates: string[] = [];
-  for (let i = 1; i < execFlagIdx; i++) {
+  for (let i = 1; i < execFlagIdx; i += 1) {
     const t = tokens[i]!;
     if (t.startsWith('-')) {
       break;
@@ -641,8 +635,8 @@ const extractExecCommands = (seg: Segment): string[] => {
     return [];
   }
   const out: string[] = [];
-  const tokens = seg.tokens;
-  for (let i = 1; i < tokens.length; i++) {
+  const { tokens } = seg;
+  for (let i = 1; i < tokens.length; i += 1) {
     if (!spec.execFlags.has(tokens[i]!)) {
       continue;
     }
@@ -657,7 +651,7 @@ const extractExecCommands = (seg: Segment): string[] => {
         break;
       }
       inner.push(t);
-      j++;
+      j += 1;
     }
     if (inner.length === 0) {
       continue;
@@ -739,8 +733,8 @@ const extractShellWrappedCommands = (seg: Segment): string[] => {
   if (!SHELL_WRAPPER_HEADS.has(seg.head)) {
     return [];
   }
-  const tokens = seg.tokens;
-  for (let i = 1; i < tokens.length; i++) {
+  const { tokens } = seg;
+  for (let i = 1; i < tokens.length; i += 1) {
     const t = tokens[i]!;
     if (t === '-c' && i + 1 < tokens.length) {
       return [tokens[i + 1]!];
@@ -854,7 +848,7 @@ const skipHeadRenamingPrefix = (tokens: readonly string[]): number => {
   while (i < tokens.length) {
     const token = tokens[i]!;
     if (head === 'env' && tokenLooksLikeEnvAssignment(token)) {
-      i++;
+      i += 1;
       continue;
     }
     if (valueFlags.has(token)) {
@@ -862,15 +856,15 @@ const skipHeadRenamingPrefix = (tokens: readonly string[]): number => {
       continue;
     }
     if (token.includes('=') && valueFlags.has(token.slice(0, token.indexOf('=')))) {
-      i++;
+      i += 1;
       continue;
     }
     if (token.startsWith('--') && token !== '--') {
-      i++;
+      i += 1;
       continue;
     }
     if (token.startsWith('-') && token !== '-') {
-      i++;
+      i += 1;
       continue;
     }
     break;
@@ -883,7 +877,7 @@ const extractHeadRenamingCommands = (seg: Segment): string[] => {
     return [];
   }
   if (seg.head === 'script') {
-    for (let i = 1; i < seg.tokens.length - 1; i++) {
+    for (let i = 1; i < seg.tokens.length - 1; i += 1) {
       const token = seg.tokens[i]!;
       if (token === '-c' || token === '--command') {
         return [seg.tokens[i + 1]!];
@@ -947,7 +941,7 @@ const skipRtkGlobalFlags = (tokens: readonly string[]): number => {
   while (i < tokens.length) {
     const t = tokens[i]!;
     if (t.startsWith('-') && t !== '-' && t !== '--') {
-      i++;
+      i += 1;
       continue;
     }
     break;
@@ -956,7 +950,7 @@ const skipRtkGlobalFlags = (tokens: readonly string[]): number => {
 };
 
 const dashCommandArg = (tokens: readonly string[], start: number): string | null => {
-  for (let k = start; k < tokens.length; k++) {
+  for (let k = start; k < tokens.length; k += 1) {
     const t = tokens[k]!;
     if ((t === '-c' || t === '--command') && k + 1 < tokens.length) {
       return tokens[k + 1]!;
@@ -989,11 +983,11 @@ const extractRtkCommands = (seg: Segment): string[] => {
     while (j < seg.tokens.length) {
       const t = seg.tokens[j]!;
       if (t === '--') {
-        j++;
+        j += 1;
         break;
       }
       if (t.startsWith('-') && t !== '-') {
-        j++;
+        j += 1;
         continue;
       }
       break;
@@ -1063,15 +1057,15 @@ const extractPrefixWrapperCommands = (seg: Segment): string[] => {
       continue;
     }
     if (t.includes('=') && spec.valueFlags.has(t.slice(0, t.indexOf('=')))) {
-      i++;
+      i += 1;
       continue;
     }
     if (t === '--') {
-      i++;
+      i += 1;
       break;
     }
     if (t.startsWith('-') && t !== '-') {
-      i++;
+      i += 1;
       continue;
     }
     break;
@@ -1081,6 +1075,28 @@ const extractPrefixWrapperCommands = (seg: Segment): string[] => {
   return inner === '' ? [] : [inner];
 };
 
+// Shell control keywords keep an executable command on the same token vector.
+// For example, `then rm -rf /` arrives as one segment headed by `then`, which
+// hides `rm` from every policy rule. Reparse the tail as a command so nested
+// conditions and loop bodies pass through the normal rule pipeline.
+const COMPOUND_COMMAND_HEADS: ReadonlySet<string> = new Set([
+  '!',
+  'if',
+  'elif',
+  'then',
+  'else',
+  'while',
+  'until',
+  'do',
+]);
+
+const extractCompoundKeywordCommand = (seg: Segment): string[] => {
+  if (!COMPOUND_COMMAND_HEADS.has(seg.head) || seg.tokens.length < 2) {
+    return [];
+  }
+  return [quote(seg.tokens.slice(1))];
+};
+
 // Each extractor pulls the inner command(s) a wrapper hides on its own arg
 // Vector, to be re-parsed as additional segments so every rule sees what
 // Actually runs. Order is irrelevant — all results are unioned into `out`.
@@ -1091,8 +1107,31 @@ const SEGMENT_EXTRACTORS: readonly ((seg: Segment) => string[])[] = [
   extractEvalCommands,
   extractRtkCommands,
   extractPrefixWrapperCommands,
+  extractCompoundKeywordCommand,
 ];
 
+const UNSUPPORTED_SHELL_HEAD = '__tripwire_unsupported_shell__';
+
+const unsupportedShellSegment = (raw: string): Segment => ({
+  head: UNSUPPORTED_SHELL_HEAD,
+  tokens: [UNSUPPORTED_SHELL_HEAD],
+  args: [],
+  flags: [],
+  redirects: [],
+  raw,
+});
+
+const containsUnsupportedShellStructure = (segments: readonly Segment[]): boolean =>
+  segments.some((segment) => {
+    if (segment.head === 'case' || segment.head === 'function' || segment.head === '{') {
+      return true;
+    }
+    if (segment.tokens.includes('__op_(__') || segment.tokens.includes('__op_)__')) {
+      return true;
+    }
+    return COMPOUND_COMMAND_HEADS.has(segment.head) && segment.tokens[1] === '{';
+  });
+
 const normalizeTopLevelNewlines = (cmd: string): string => {
   let out = '';
   let inSingle = false;
@@ -1131,7 +1170,7 @@ const parseCommand = (cmd: string): Segment[] => {
   try {
     entries = parse(cmdForParsing, PRESERVE_ENV);
   } catch {
-    return [];
+    return [unsupportedShellSegment(cmdForParsing)];
   }
   entries = mergeAmpRedirects(entries);
   const fdBudget: FdBudget = { remaining: countFdPrefixRedirects(cmdForParsing) };
@@ -1155,6 +1194,10 @@ const parseCommand = (cmd: string): Segment[] => {
     out.push(seg);
   }
 
+  if (containsUnsupportedShellStructure(out)) {
+    out.push(unsupportedShellSegment(cmdForParsing));
+  }
+
   // Recursively analyze any embedded commands as additional segments. The
   // Outer segment's args are already opaque sentinels (safe-path-failing);
   // This catches dangerous inner commands the outer call would otherwise
@@ -1174,7 +1217,7 @@ const parseCommand = (cmd: string): Segment[] => {
   // Loop, but should only scan the segments that existed pre-extraction
   // To avoid re-processing extracted ones.
   const preExtractLen = out.length;
-  for (let k = 0; k < preExtractLen; k++) {
+  for (let k = 0; k < preExtractLen; k += 1) {
     const seg = out[k]!;
     for (const extract of SEGMENT_EXTRACTORS) {
       for (const sub of extract(seg)) {
@@ -1270,11 +1313,12 @@ const safeScopesSummary = (
 // A legitimate bypass marker sits on the actual command line, which the
 // Mask leaves intact.
 const hasBypass = (cmd: string): boolean =>
-  /(?<prefix>^|\s)#\s*tripwire-allow\b/.test(maskLiteralHeredocBodies(cmd));
+  /(?<prefix>^|\s)#\s*tripwire-allow:[ \t]*\S[^\r\n]*/.test(maskLiteralHeredocBodies(cmd));
 
 export type { Redirect, Segment };
 export {
   EXEC_SPECS,
+  UNSUPPORTED_SHELL_HEAD,
   collectHeredocBodies,
   hasBypass,
   isSafePathTarget,

package/src/lib/config.ts

@@ -1,11 +1,11 @@
 // Config system using Effect Schema for validation and Effect for safe loading.
 // Config file: ~/.config/tripwire/config.json
-// Falls back to defaults if file doesn't exist or is invalid.
+// Falls back to defaults only if the file does not exist.
 
-import { accessSync, constants, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 
-import { Cause, Effect, Schema } from 'effect';
+import { Cause, Data, Effect, Schema } from 'effect';
 
 const BlockRuleSchema = Schema.Struct({
   pattern: Schema.String,
@@ -27,73 +27,102 @@ const SafePathsConfigSchema = Schema.Struct({
   absolute: Schema.optional(Schema.Array(Schema.String)),
 });
 
+const ToolPolicyMatchSchema = Schema.Struct({
+  argumentsIncludeAll: Schema.optional(Schema.Array(Schema.String)),
+  argumentsStartWith: Schema.optional(Schema.Array(Schema.String)),
+  shortFlagsIncludeAll: Schema.optional(Schema.Array(Schema.String)),
+});
+
+const ToolPolicySchema = Schema.Struct({
+  rule: Schema.String,
+  executables: Schema.Array(Schema.String),
+  action: Schema.Union([Schema.Literal('deny'), Schema.Literal('warn')]),
+  message: Schema.String,
+  match: Schema.optional(ToolPolicyMatchSchema),
+});
+
+const SecretScannerConfigSchema = Schema.Struct({
+  executable: Schema.String,
+  timeoutMs: Schema.Finite.check(Schema.isGreaterThan(0)),
+});
+
 const ConfigSchema = Schema.Struct({
   git: Schema.optional(GitConfigSchema),
   safePaths: Schema.optional(SafePathsConfigSchema),
+  toolPolicies: Schema.optional(Schema.Array(ToolPolicySchema)),
   blockedCommands: Schema.optional(Schema.Array(BlockRuleSchema)),
   allowedCommands: Schema.optional(Schema.Array(BlockRuleSchema)),
+  secretScanner: Schema.optional(SecretScannerConfigSchema),
 });
 
 const CONFIG_PATH = `${homedir()}/.config/tripwire/config.json`;
 
-const configExists = (path: string): Effect.Effect<boolean> =>
-  Effect.sync(() => {
-    try {
-      accessSync(path, constants.R_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  });
+class ConfigReadError extends Data.TaggedError('ConfigReadError')<{ readonly cause: unknown }> {}
+
+class ConfigParseError extends Data.TaggedError('ConfigParseError')<{ readonly cause: unknown }> {}
 
-const readConfigFile = (path: string): Effect.Effect<string, Error> =>
-  Effect.try({ try: () => readFileSync(path, 'utf8'), catch: (error) => error as Error });
+const isMissingFile = (cause: unknown): boolean =>
+  cause instanceof Error && 'code' in cause && cause.code === 'ENOENT';
+
+const readConfigFile = (path: string): Effect.Effect<string | null, ConfigReadError> =>
+  Effect.try({
+    try: () => readFileSync(path, 'utf8'),
+    catch: (cause) => new ConfigReadError({ cause }),
+  }).pipe(
+    Effect.catchTag('ConfigReadError', (error) =>
+      isMissingFile(error.cause) ? Effect.succeed(null) : Effect.fail(error),
+    ),
+  );
 
 const parseConfigJson = (raw: string): Effect.Effect<unknown, Error> =>
-  Effect.try({ try: () => JSON.parse(raw) as unknown, catch: (error) => error as Error });
+  Effect.try({
+    try: () => JSON.parse(raw) as unknown,
+    catch: (cause) => new ConfigParseError({ cause }),
+  });
 
-// `onExcessProperty: 'error'` rejects unknown keys (the default 'ignore' would
-// Silently strip them — a typo'd `blockedComands` would vanish unnoticed, the
-// Same silent-policy-drop class this whole change exists to kill). A stray key
-// Now fails loud, e.g. the `rtk` block that triggered MTA-137.
+// Reject unknown keys so a misspelled policy cannot disappear silently.
 const decodeConfig = (unknown: unknown): Effect.Effect<Config, Error> =>
   Schema.decodeUnknownEffect(ConfigSchema)(unknown, { onExcessProperty: 'error' });
 
-const getDefaultConfig = (): Config => ({
-  git: {
-    protectedBranches: ['main', 'master', 'develop', 'production', 'release'],
-    enforceConventionalCommits: true,
-  },
+const getDefaultConfig = (): ResolvedConfig => ({
+  git: { protectedBranches: [], enforceConventionalCommits: false },
   safePaths: {},
+  toolPolicies: [],
   blockedCommands: [],
   allowedCommands: [],
+  secretScanner: { executable: 'betterleaks', timeoutMs: 5000 },
 });
 
-const mergeWithDefaults = (partial: Config): Config => ({
-  git: partial.git ?? getDefaultConfig().git,
-  safePaths: partial.safePaths ?? getDefaultConfig().safePaths,
-  blockedCommands: partial.blockedCommands ?? getDefaultConfig().blockedCommands,
-  allowedCommands: partial.allowedCommands ?? getDefaultConfig().allowedCommands,
-});
-
-// A present-but-broken config (bad JSON, schema decode failure, timeout) must
-// Never be papered over with defaults — that silently drops all custom safety
-// Policy. `loadConfigResult` reports the failure as data so callers can fail
-// Closed loudly (see `loadConfig` and the dispatcher). A *missing* file is the
-// One legitimate defaults case.
+const mergeWithDefaults = (partial: Config): ResolvedConfig => {
+  const defaults = getDefaultConfig();
+  return {
+    git: {
+      protectedBranches: partial.git?.protectedBranches ?? defaults.git.protectedBranches,
+      enforceConventionalCommits:
+        partial.git?.enforceConventionalCommits ?? defaults.git.enforceConventionalCommits,
+    },
+    safePaths: { ...defaults.safePaths, ...partial.safePaths },
+    toolPolicies: partial.toolPolicies ?? defaults.toolPolicies,
+    blockedCommands: partial.blockedCommands ?? defaults.blockedCommands,
+    allowedCommands: partial.allowedCommands ?? defaults.allowedCommands,
+    secretScanner: partial.secretScanner ?? defaults.secretScanner,
+  };
+};
+
+// A present but invalid config must not fall back to defaults because that
+// would drop custom safety policy. Only a missing file selects defaults.
 type ConfigLoad =
-  | { readonly ok: true; readonly config: Config }
+  | { readonly ok: true; readonly config: ResolvedConfig }
   | { readonly ok: false; readonly error: string };
 
 export const loadConfigResult = (path: string = CONFIG_PATH): Effect.Effect<ConfigLoad> =>
-  Effect.gen(function* () {
-    const exists = yield* configExists(path);
-    if (!exists) {
+  Effect.gen(function* loadConfigResultEffect() {
+    const raw = yield* readConfigFile(path);
+    if (raw === null) {
       const result: ConfigLoad = { ok: true, config: getDefaultConfig() };
       return result;
     }
 
-    const raw = yield* readConfigFile(path);
     const parsed = yield* parseConfigJson(raw);
     const config = yield* decodeConfig(parsed);
     const result: ConfigLoad = { ok: true, config: mergeWithDefaults(config) };
@@ -106,10 +135,8 @@ export const loadConfigResult = (path: string = CONFIG_PATH): Effect.Effect<Conf
     }),
   );
 
-// Loud loader for library consumers (e.g. the shim daemon) that expect a
-// `Config`. A broken config dies rather than silently defaulting, so the
-// Consumer fails closed visibly until the file is fixed.
-export const loadConfig = (path: string = CONFIG_PATH): Effect.Effect<Config> =>
+// Library consumers get a loud failure instead of an unconfigured fallback.
+export const loadConfig = (path: string = CONFIG_PATH): Effect.Effect<ResolvedConfig> =>
   loadConfigResult(path).pipe(
     Effect.flatMap((result) =>
       result.ok
@@ -121,7 +148,27 @@ export const loadConfig = (path: string = CONFIG_PATH): Effect.Effect<Config> =>
 export type BlockRule = typeof BlockRuleSchema.Type;
 export type GitConfig = typeof GitConfigSchema.Type;
 export type SafePathsConfig = typeof SafePathsConfigSchema.Type;
+export type ToolPolicy = typeof ToolPolicySchema.Type;
+export type SecretScannerConfig = typeof SecretScannerConfigSchema.Type;
 export type Config = typeof ConfigSchema.Type;
 
+export interface ResolvedConfig {
+  readonly git: {
+    readonly protectedBranches: readonly string[];
+    readonly enforceConventionalCommits: boolean;
+  };
+  readonly safePaths: SafePathsConfig;
+  readonly toolPolicies: readonly ToolPolicy[];
+  readonly blockedCommands: readonly BlockRule[];
+  readonly allowedCommands: readonly BlockRule[];
+  readonly secretScanner: SecretScannerConfig;
+}
+
 export type { ConfigLoad };
-export { CONFIG_PATH, ConfigSchema, getDefaultConfig, mergeWithDefaults };
+export {
+  CONFIG_PATH,
+  ConfigSchema,
+  SecretScannerConfigSchema,
+  getDefaultConfig,
+  mergeWithDefaults,
+};