@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-4IDINPBE.js

@@ -0,0 +1,525 @@
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lint/import-graph.ts
+import path2 from "node:path";
+
+// scripts/lint/import-graph-store.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+var STORE_VERSION = 1;
+var STORE_NAME = `import-graph.v${String(STORE_VERSION)}.json`;
+var ENVIRONMENT_FILES = ["package.json", "pnpm-lock.yaml"];
+var EXTENSION = /(?:\.d)?\.[^./]+$/u;
+var INDEX = "index";
+var stored_dependency = z.tuple([z.string(), z.boolean()]);
+var stored_file = z.object({
+  hash: z.string(),
+  all: z.array(stored_dependency).optional(),
+  runtime: z.array(stored_dependency).optional()
+});
+var stored_graph = z.object({
+  version: z.literal(STORE_VERSION),
+  environment: z.string(),
+  files: z.record(z.string(), stored_file)
+});
+function store_path(root) {
+  const common = git_common_directory.repository(root);
+  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, STORE_NAME);
+}
+function environment_of(root, config_files) {
+  const relatives = [...config_files.map((file) => path.relative(root, file)), ...ENVIRONMENT_FILES];
+  const digests = Object.entries(input_fingerprint.of_files(root, relatives));
+  return input_fingerprint.of_entries(digests.map(([file, digest]) => `${file}:${digest}`));
+}
+function open(root, config_files) {
+  return {
+    root,
+    environment: environment_of(root, config_files),
+    file_path: store_path(root),
+    files: void 0,
+    seeded: /* @__PURE__ */ new Set(),
+    memo: { all: /* @__PURE__ */ new Map(), runtime: /* @__PURE__ */ new Map() },
+    unresolved: { all: /* @__PURE__ */ new Set(), runtime: /* @__PURE__ */ new Set() },
+    content_hashes: /* @__PURE__ */ new Map()
+  };
+}
+function remember(store, name, file, references) {
+  const found = references.filter((dependency) => dependency !== void 0);
+  if (found.length < references.length) store.unresolved[name].add(file);
+  store.memo[name].set(file, found);
+  return found;
+}
+function content_hash(store, file) {
+  const known = store.content_hashes.get(file);
+  if (known !== void 0) return known;
+  const computed = input_fingerprint.of_file(file);
+  store.content_hashes.set(file, computed);
+  return computed;
+}
+function read_files(store) {
+  const text = store.file_path === void 0 ? void 0 : file_reader.read_if_readable(store.file_path);
+  const stored = text === void 0 ? void 0 : json_value.parse_with(text, stored_graph);
+  return stored?.environment === store.environment ? stored.files : {};
+}
+function files_of(store) {
+  store.files ??= read_files(store);
+  return store.files;
+}
+function module_stem(file) {
+  const stem = file.replace(EXTENSION, "");
+  return path.basename(stem) === INDEX ? path.dirname(stem) : stem;
+}
+function added_stems(store, universe) {
+  const files = files_of(store);
+  const added = universe.filter((file) => !Object.hasOwn(files, path.relative(store.root, file)));
+  return new Set(added.map((file) => module_stem(file)));
+}
+function rebased(store, stored) {
+  return stored.map(([file, external]) => ({ file: path.join(store.root, file), external }));
+}
+function is_standing(dependency, seeding) {
+  return existsSync(dependency.file) && !seeding.added.has(module_stem(dependency.file));
+}
+function stored_edges(store, name, file, seeding) {
+  const entry = seeding.files[path.relative(store.root, file)];
+  const stored = entry?.hash === content_hash(store, file) ? entry[name] : void 0;
+  if (stored === void 0) return void 0;
+  const dependencies = rebased(store, stored);
+  return dependencies.every((dependency) => is_standing(dependency, seeding)) ? dependencies : void 0;
+}
+function seed(store, name, universe) {
+  if (store.seeded.has(name)) return [];
+  store.seeded.add(name);
+  const seeding = { files: files_of(store), added: added_stems(store, universe) };
+  const memo = store.memo[name];
+  return universe.filter((file) => {
+    const stored = stored_edges(store, name, file, seeding);
+    if (stored !== void 0 && !memo.has(file)) memo.set(file, stored);
+    return stored === void 0;
+  });
+}
+function entry_of(store, name, file) {
+  const dependencies = store.memo[name].get(file);
+  if (dependencies === void 0 || store.unresolved[name].has(file)) return void 0;
+  const hash = content_hash(store, file);
+  const known = files_of(store)[path.relative(store.root, file)];
+  const entry = known?.hash === hash ? { ...known } : { hash };
+  entry[name] = dependencies.map((dependency) => [
+    path.relative(store.root, dependency.file),
+    dependency.external
+  ]);
+  return entry;
+}
+function write(store, file_path) {
+  const files = Object.entries(files_of(store)).filter(
+    ([file]) => existsSync(path.join(store.root, file))
+  );
+  const graph = {
+    version: STORE_VERSION,
+    environment: store.environment,
+    files: Object.fromEntries(files)
+  };
+  atomic_write.replace_file(file_path, JSON.stringify(graph));
+}
+function keep(store, name, missing) {
+  if (missing.length === 0 || store.file_path === void 0) return;
+  const files = files_of(store);
+  for (const file of missing) {
+    const entry = entry_of(store, name, file);
+    if (entry !== void 0) files[path.relative(store.root, file)] = entry;
+  }
+  write(store, store.file_path);
+}
+var import_graph_store = { content_hash, keep, open, remember, seed, store_path };
+
+// scripts/test/test-inputs.ts
+var GLOBALS = /* @__PURE__ */ new Set([
+  "undefined",
+  "NaN",
+  "Infinity",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "BigInt",
+  "Symbol",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "JSON",
+  "RegExp",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "Promise",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite"
+]);
+var UNSAFE = /* @__PURE__ */ new Set([
+  "process",
+  "global",
+  "globalThis",
+  "eval",
+  "Function",
+  "require",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "vi",
+  "vitest",
+  "inject",
+  "provide",
+  "toMatchSnapshot",
+  "toMatchFileSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "matchSnapshot"
+]);
+function is_property(typescript, node) {
+  const { parent } = node;
+  return typescript.isPropertyAccessExpression(parent) && parent.name === node || (typescript.isPropertyAssignment(parent) || typescript.isMethodDeclaration(parent)) && parent.name === node;
+}
+function is_unsafe_syntax(typescript, node) {
+  return [
+    typescript.isNamespaceImport(node),
+    typescript.isElementAccessExpression(node),
+    node.kind === typescript.SyntaxKind.ThisKeyword,
+    typescript.isMetaProperty(node)
+  ].includes(true);
+}
+function is_dynamic_import(typescript, node) {
+  return typescript.isCallExpression(node) && node.expression.kind === typescript.SyntaxKind.ImportKeyword;
+}
+function is_unknown_identifier(typescript, node, checker) {
+  if (UNSAFE.has(node.text)) return true;
+  return !is_property(typescript, node) && checker.getSymbolAtLocation(node) === void 0 && !GLOBALS.has(node.text);
+}
+function is_unknown(typescript, node, checker) {
+  if (is_unsafe_syntax(typescript, node) || is_dynamic_import(typescript, node)) return true;
+  if (!typescript.isIdentifier(node)) return false;
+  return is_unknown_identifier(typescript, node, checker);
+}
+function is_closed(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest, true);
+  const host = typescript.createCompilerHost({});
+  host.getSourceFile = (name) => name === file ? source : void 0;
+  const program = typescript.createProgram([file], { noLib: true, noResolve: true }, host);
+  const checker = program.getTypeChecker();
+  function unknown(node) {
+    if (typescript.isTypeNode(node)) return false;
+    return is_unknown(typescript, node, checker) || typescript.forEachChild(node, unknown) === true;
+  }
+  return program.getSyntacticDiagnostics(source).length === 0 && !unknown(source);
+}
+var test_inputs = { is_closed };
+
+// scripts/lint/type-only-imports.ts
+function declaration_of(typescript, statement) {
+  if (typescript.isImportDeclaration(statement)) return statement;
+  if (typescript.isExportDeclaration(statement)) return statement;
+  return void 0;
+}
+function is_type_only(typescript, declaration) {
+  if (typescript.isExportDeclaration(declaration)) return declaration.isTypeOnly;
+  return declaration.importClause?.phaseModifier === typescript.SyntaxKind.TypeKeyword;
+}
+function type_only_position(typescript, source, statement) {
+  const declaration = declaration_of(typescript, statement);
+  if (declaration === void 0 || !is_type_only(typescript, declaration)) return void 0;
+  const specifier = declaration.moduleSpecifier;
+  if (specifier === void 0 || !typescript.isStringLiteral(specifier)) return void 0;
+  return specifier.getStart(source);
+}
+function runtime_specifiers(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const type_only = new Set(
+    source.statements.map((statement) => type_only_position(typescript, source, statement))
+  );
+  return typescript.preProcessFile(content, true, true).importedFiles.filter((reference) => !type_only.has(reference.pos)).map((reference) => reference.fileName);
+}
+function strings(typescript, file) {
+  const content = file_reader.read_if_readable(file) ?? "";
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const found = [];
+  function visit(node) {
+    if (typescript.isStringLiteralLike(node) || typescript.isTemplateLiteralToken(node)) {
+      found.push(node.text);
+    }
+    typescript.forEachChild(node, visit);
+  }
+  visit(source);
+  return found;
+}
+var type_only_imports = { runtime_specifiers, strings };
+
+// scripts/lint/import-test-inputs.ts
+var DECLARATION_EXTENSION = /\.d\.[cm]?ts$/u;
+var TYPESCRIPT_EXTENSION = /\.[cm]?tsx?$/u;
+var JAVASCRIPT_EXTENSIONS = ["js", "jsx", "mjs", "cjs"];
+function is_runtime_source(typescript, file) {
+  if (DECLARATION_EXTENSION.test(file)) return false;
+  if (!TYPESCRIPT_EXTENSION.test(file)) return true;
+  return JAVASCRIPT_EXTENSIONS.every(
+    (extension) => !typescript.sys.fileExists(file.replace(TYPESCRIPT_EXTENSION, () => `.${extension}`))
+  );
+}
+function dependencies_of(typescript, resolve, file, content) {
+  const specifiers = type_only_imports.runtime_specifiers(typescript, file, content);
+  const dependencies = specifiers.filter((name) => name !== "vitest").map((name) => name.startsWith(".") ? resolve(name, file) : void 0);
+  if (dependencies.some((dependency) => dependency === void 0 || dependency.external)) {
+    return void 0;
+  }
+  return dependencies.flatMap((dependency) => dependency?.file ?? []);
+}
+function read_source(typescript, resolve, file) {
+  if (!is_runtime_source(typescript, file)) return void 0;
+  const content = file_reader.read_if_readable(file);
+  if (content === void 0 || !test_inputs.is_closed(typescript, file, content)) return void 0;
+  return dependencies_of(typescript, resolve, file, content);
+}
+function unvisited(file, reached, read) {
+  return reached.has(file) ? [] : read(file);
+}
+function closure(file, read) {
+  const reached = /* @__PURE__ */ new Set();
+  const pending = [file];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    const dependencies = unvisited(current, reached, read);
+    if (dependencies === void 0) return void 0;
+    reached.add(current);
+    pending.push(...dependencies);
+  }
+  return [...reached];
+}
+function create(typescript, resolve) {
+  const cache = /* @__PURE__ */ new Map();
+  function read(file) {
+    if (!cache.has(file)) cache.set(file, read_source(typescript, resolve, file));
+    return cache.get(file);
+  }
+  return (file) => closure(file, read);
+}
+var import_test_inputs2 = { create };
+
+// scripts/lint/import-graph.ts
+var TSCONFIG = "tsconfig.json";
+var NODE_MODULES = "node_modules";
+var MODULE_STATEMENT = /^(?:import|export)\b/mu;
+var GLOBAL_DECLARATION = /^declare (?:global|module|namespace)\b/mu;
+async function load_typescript() {
+  try {
+    const module = await import("typescript");
+    return module.default;
+  } catch {
+    return void 0;
+  }
+}
+function parsed_config(typescript, root) {
+  const config_file = path2.join(root, TSCONFIG);
+  if (!typescript.sys.fileExists(config_file)) return void 0;
+  const source = typescript.readJsonConfigFile(config_file, typescript.sys.readFile);
+  const parsed = typescript.parseJsonSourceFileConfigFileContent(
+    source,
+    typescript.sys,
+    root,
+    void 0,
+    config_file
+  );
+  return {
+    options: parsed.options,
+    file_names: parsed.fileNames,
+    config_files: [config_file, ...source.extendedSourceFiles ?? []]
+  };
+}
+function is_installed(file) {
+  return file.split(path2.sep).includes(NODE_MODULES);
+}
+function as_dependency(file, external) {
+  if (file === void 0) return void 0;
+  return { file, external: external === true && is_installed(file) };
+}
+function relative_to(specifier, file) {
+  return { file: path2.resolve(path2.dirname(file), specifier), external: false };
+}
+function resolve_module(context, specifier, file) {
+  const { typescript, options, resolution_cache } = context;
+  const resolved = typescript.resolveModuleName(
+    specifier,
+    file,
+    options,
+    typescript.sys,
+    resolution_cache
+  ).resolvedModule;
+  if (resolved !== void 0) {
+    return as_dependency(resolved.resolvedFileName, resolved.isExternalLibraryImport);
+  }
+  if (!specifier.startsWith(".")) return void 0;
+  return relative_to(specifier, file);
+}
+function resolve_type(resolver, name, file) {
+  const { typescript, options } = resolver;
+  const resolved = typescript.resolveTypeReferenceDirective(
+    name,
+    file,
+    options,
+    typescript.sys
+  ).resolvedTypeReferenceDirective;
+  return as_dependency(resolved?.resolvedFileName, resolved?.isExternalLibraryImport);
+}
+function references_of(context, file, content) {
+  const processed = context.typescript.preProcessFile(content, true, true);
+  return [
+    ...processed.importedFiles.map(
+      (reference) => resolve_module(context, reference.fileName, file)
+    ),
+    ...processed.referencedFiles.map((reference) => relative_to(reference.fileName, file)),
+    ...processed.typeReferenceDirectives.map(
+      (reference) => resolve_type(context, reference.fileName, file)
+    )
+  ];
+}
+function direct_dependencies(context, file) {
+  const known = context.store.memo.all.get(file);
+  if (known !== void 0) return known;
+  const references = references_of(context, file, file_reader.read_if_readable(file) ?? "");
+  return import_graph_store.remember(context.store, "all", file, references);
+}
+function runtime_dependencies(context, file) {
+  const known = context.store.memo.runtime.get(file);
+  if (known !== void 0) return known;
+  const content = file_reader.read_if_readable(file) ?? "";
+  const references = type_only_imports.runtime_specifiers(context.typescript, file, content).map((specifier) => resolve_module(context, specifier, file));
+  return import_graph_store.remember(context.store, "runtime", file, references);
+}
+function is_ambient(file) {
+  const content = file_reader.read_if_readable(file) ?? "";
+  return GLOBAL_DECLARATION.test(content) || !MODULE_STATEMENT.test(content);
+}
+function ambient_of(resolver, root, config) {
+  const config_file = path2.join(root, TSCONFIG);
+  const declarations = [
+    ...config.file_names.filter((file) => is_ambient(file)),
+    ...config.config_files
+  ].map((file) => ({ file, external: false }));
+  const types = resolver.typescript.getAutomaticTypeDirectiveNames(resolver.options, resolver.typescript.sys).map((name) => resolve_type(resolver, name, config_file)).filter((dependency) => dependency !== void 0);
+  return [...declarations, ...types];
+}
+function is_unvisited(dependency, start, reached) {
+  return dependency.file !== start && !reached.has(dependency.file);
+}
+function join(dependencies, start, reached) {
+  const next = dependencies.filter((dependency) => is_unvisited(dependency, start, reached));
+  for (const dependency of next) reached.set(dependency.file, dependency);
+  return next.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function reachable(context, file) {
+  const reached = /* @__PURE__ */ new Map();
+  const pending = [file, ...join(context.ambient, file, reached)];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    pending.push(...join(direct_dependencies(context, current), file, reached));
+  }
+  return reached;
+}
+function token_of(context, dependency) {
+  const name = path2.relative(context.root, dependency.file);
+  if (dependency.external) return name;
+  return `${name}:${import_graph_store.content_hash(context.store, dependency.file)}`;
+}
+function closure_hash(context, file) {
+  const tokens = [...reachable(context, file).values()].map(
+    (dependency) => token_of(context, dependency)
+  );
+  return input_fingerprint.of_entries(tokens);
+}
+function closure2(context, file) {
+  return [...reachable(context, file).values()].filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function imports(context, file, content) {
+  const dependencies = content === void 0 ? direct_dependencies(context, file) : references_of(context, file, content).filter((dependency) => dependency !== void 0);
+  return dependencies.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function append(map, key, value) {
+  const known = map.get(key);
+  if (known === void 0) map.set(key, [value]);
+  else known.push(value);
+}
+function reverse_edges(context, universe, edges) {
+  const reverse = /* @__PURE__ */ new Map();
+  const missing = import_graph_store.seed(context.store, edges.name, universe);
+  for (const file of universe) {
+    for (const dependency of edges.of(context, file)) {
+      append(reverse, dependency.file, file);
+    }
+  }
+  import_graph_store.keep(context.store, edges.name, missing);
+  return reverse;
+}
+function importers(context, files, universe, edges) {
+  const reverse = reverse_edges(context, universe, edges);
+  const reached = new Set(files);
+  const pending = [...files];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    const next = (reverse.get(current) ?? []).filter((file) => !reached.has(file));
+    for (const file of next) reached.add(file);
+    pending.push(...next);
+  }
+  return reached;
+}
+function project_module(context, specifier, file) {
+  const dependency = resolve_module(context, specifier, file);
+  if (dependency === void 0) return void 0;
+  const relative = path2.relative(context.root, dependency.file);
+  return relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative) ? void 0 : dependency;
+}
+function graph_of(context) {
+  return {
+    // Type-checker suffixes need not select the source the runner executes.
+    test_inputs: context.options.moduleSuffixes === void 0 ? import_test_inputs2.create(
+      context.typescript,
+      (specifier, file) => project_module(context, specifier, file)
+    ) : void 0,
+    closure: (file) => closure2(context, file),
+    closure_hash: (file) => closure_hash(context, file),
+    imports: (file, content) => imports(context, file, content),
+    importers: (files, universe) => importers(context, files, universe, { name: "all", of: direct_dependencies }),
+    runtime_importers: (files, universe) => importers(context, files, universe, { name: "runtime", of: runtime_dependencies }),
+    strings: (file) => type_only_imports.strings(context.typescript, file)
+  };
+}
+async function create2(root) {
+  const typescript = await load_typescript();
+  if (typescript === void 0) return void 0;
+  const parsed = parsed_config(typescript, root);
+  if (parsed === void 0) return void 0;
+  return graph_of({
+    root,
+    typescript,
+    options: parsed.options,
+    resolution_cache: typescript.createModuleResolutionCache(root, (name) => name, parsed.options),
+    ambient: ambient_of({ typescript, options: parsed.options }, root, parsed),
+    store: import_graph_store.open(root, parsed.config_files)
+  });
+}
+var import_graph = { create: create2 };
+
+export {
+  import_graph
+};

package/dist/commands/chunk-4NSIW3UB.js

@@ -0,0 +1,104 @@
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  time_transcript_line
+} from "./chunk-YSLGWRQN.js";
+import {
+  hook_context
+} from "./chunk-CUWT6UQO.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-ledger.ts
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var LEDGER_DIRECTORY = "hook-ledger";
+var LEDGER_EXTENSION = ".jsonl";
+var COMMAND_HEAD = 80;
+var RULE_HEAD = 48;
+var STOP_TOOL = "Stop";
+var COMMAND_FIELDS = ["command", "file_path", "pattern", "url", "prompt"];
+var input_schema = z.record(z.string(), z.unknown());
+var payload_schema = z.object({
+  tool_name: z.string().catch(STOP_TOOL),
+  tool_input: z.unknown().optional(),
+  transcript_path: z.string().catch("")
+});
+var EMPTY_PAYLOAD = payload_schema.parse({});
+var block_schema = z.object({ decision: z.literal("block"), reason: z.string() });
+function rule_of(reason) {
+  const guard = time_transcript_line.guard_from_refusal(reason);
+  return guard === "" ? reason.trim().slice(0, RULE_HEAD) : guard;
+}
+function command_of(input) {
+  const fields = input_schema.safeParse(input).data ?? {};
+  const value = COMMAND_FIELDS.map((key) => fields[key]).find((field) => typeof field === "string");
+  return typeof value === "string" ? value.slice(0, COMMAND_HEAD) : "";
+}
+function entry_of(refusal, branch, now, environment) {
+  const payload = json_value.parse_with(refusal.raw_payload, payload_schema) ?? EMPTY_PAYLOAD;
+  return {
+    at: now.toISOString(),
+    hook: refusal.hook,
+    rule: rule_of(refusal.reason),
+    tool: payload.tool_name,
+    role: environment[agent_session_role.KEY] ?? "",
+    issue: git_branch.issue_from_branch(branch),
+    session: payload.transcript_path,
+    command: command_of(payload.tool_input)
+  };
+}
+function ledger_directory(context = hook_context.from_process()) {
+  if (context.env["VITEST"] !== void 0) return void 0;
+  const common = git_common_directory.repository(context.cwd);
+  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, LEDGER_DIRECTORY);
+}
+async function append(entry, directory) {
+  const day = observation_ledger_home.ledger_date(new Date(entry.at));
+  await mkdir(directory, { recursive: true });
+  await appendFile(path.join(directory, `${day}${LEDGER_EXTENSION}`), `${JSON.stringify(entry)}
+`);
+}
+async function record(refusal, directory = ledger_directory(), context = hook_context.from_process()) {
+  if (directory === void 0) return;
+  try {
+    const branch = await git_spawn.read(["-C", context.cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+    await append(entry_of(refusal, branch, /* @__PURE__ */ new Date(), context.env), directory);
+  } catch {
+  }
+}
+async function record_reason(hook, reason, raw_payload, context = hook_context.from_process()) {
+  if (reason !== void 0) {
+    await record({ hook, reason, raw_payload }, ledger_directory(context), context);
+  }
+}
+function blocked_reason(envelope) {
+  return json_value.parse_with(envelope, block_schema)?.reason;
+}
+var hook_ledger = {
+  blocked_reason,
+  command_of,
+  ledger_directory,
+  record,
+  record_reason,
+  rule_of
+};
+
+export {
+  hook_ledger
+};

package/dist/commands/chunk-4YTKV6WV.js

@@ -0,0 +1,37 @@
+import {
+  run_retrospective
+} from "./chunk-IAB6LCJL.js";
+import {
+  doctor_consumer
+} from "./chunk-S4OZJIXD.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+
+// scripts/backlog/backlog-drive-retrospective.ts
+var STOP_VERDICT = "stop";
+var EXHAUSTED_ANSWER = "exhausted";
+var RETROSPECTIVE_REASON = "retrospective";
+function is_owed(carry) {
+  const root = find_package_directory(process.cwd());
+  return run_retrospective.is_owed({
+    is_retrospective_enabled: run_retrospective.is_enabled(),
+    is_lane_child: false,
+    is_retrospective_done: carry.retrospective === true,
+    is_consumer: doctor_consumer.is_kit_consumer(root)
+  });
+}
+function is_drain_owed(read, state, verdict) {
+  return read.verdict === verdict && read.answer === EXHAUSTED_ANSWER && state.in_flight.length === 0 && read.is_retrospective_owed === true;
+}
+async function ran(result, read, ports) {
+  if (result.kind === "end" || !is_drain_owed(read, result.state, STOP_VERDICT)) return result;
+  if (await ports.retrospective()) return result;
+  const end = { reason: RETROSPECTIVE_REASON, token: RETROSPECTIVE_REASON, issue: void 0 };
+  return { kind: "end", end, state: result.state };
+}
+var backlog_drive_retrospective = { is_drain_owed, is_owed, ran };
+
+export {
+  backlog_drive_retrospective
+};