@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/dist/hooks/pretool-guard.js

@@ -1,32 +1,17 @@
 #!/usr/bin/env tsx
 import {
   pretool_guard
-} from "./chunk-IIGFYXKC.js";
-import "./chunk-YYPI7SJZ.js";
-import "./chunk-43ZHT22P.js";
-import "./chunk-IX6TTTI6.js";
-import "./chunk-EUMACUK2.js";
-import "./chunk-CDY4NFQG.js";
-import "./chunk-YHBZAJSV.js";
-import "./chunk-K4LMBQC2.js";
-import "./chunk-H5HVWYXK.js";
-import "./chunk-SHGPANFB.js";
+} from "./chunk-O2YBIDSI.js";
 import {
   hook_decision
-} from "./chunk-J47HU5H5.js";
-import "./chunk-AS74OU3D.js";
-import "./chunk-K4EOONYM.js";
-import "./chunk-E7OIKX5Z.js";
-import "./chunk-DGT54IH5.js";
+} from "./chunk-CWMBGKYW.js";
+import "./chunk-PT5R6UJD.js";
+import "./chunk-YCDOIR3I.js";
+import "./chunk-WR2KQAYZ.js";
+import "./chunk-AZX4FGQ3.js";
 
 // scripts/hooks/pretool-guard-cli.ts
-import { text } from "node:stream/consumers";
 import { fileURLToPath } from "node:url";
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("pretool:guard");
-  else {
-    const raw_payload = await text(process.stdin);
-    hook_decision.load_environment_file();
-    await pretool_guard.respond(raw_payload);
-  }
+  await hook_decision.respond_from_stdin("pretool:guard", pretool_guard.respond);
 }

package/dist/hooks/session-lang.js

@@ -1,32 +1,33 @@
 #!/usr/bin/env tsx
 import {
+  OBSERVATION_LEDGER_DIRECTORY,
   agent_role_profile,
   detached_launch,
-  git_common_directory,
-  issue_cite,
-  run_event_stream,
-  run_event_stream_emit,
+  distributed_paths,
+  josh_environment_file,
   run_headless,
   session_language
-} from "./chunk-EUMACUK2.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  josh_environment_file
-} from "./chunk-K4EOONYM.js";
+} from "./chunk-YCDOIR3I.js";
 import {
   agent_session_environment,
+  ancestor_directories,
+  file_reader,
+  git_common_directory,
+  issue_cite,
   json_value,
+  package_manifest,
   process_identity,
-  run_carry
-} from "./chunk-E7OIKX5Z.js";
+  run_carry,
+  run_event_stream,
+  run_event_stream_emit
+} from "./chunk-WR2KQAYZ.js";
 import {
+  error_text,
   stamp_file
-} from "./chunk-DGT54IH5.js";
+} from "./chunk-AZX4FGQ3.js";
 
-// scripts/josh/session-language-cli.ts
-import { fileURLToPath } from "node:url";
+// scripts/josh/session-language-main.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // scripts/backlog/backlogrun-launch.ts
 import { randomUUID } from "node:crypto";
@@ -99,8 +100,331 @@ function check(profile, ports = default_ports) {
 var agent_diagnostics = { check };
 
 // scripts/agent/claude-agent-argv.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
+import path2 from "node:path";
+
+// scripts/agent/lane-instructions.ts
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// scripts/cost-runtime/cost-tokens.ts
+var ASCII_CHARS_PER_TOKEN = 3;
+var WIDE_TOKENS_PER_CHAR = 1;
+var ASCII_LIMIT = 128;
+function count_chars(text) {
+  let ascii_chars = 0;
+  let wide_chars = 0;
+  for (const char of text) {
+    if ((char.codePointAt(0) ?? 0) < ASCII_LIMIT) ascii_chars += 1;
+    else wide_chars += 1;
+  }
+  return { ascii_chars, wide_chars };
+}
+function estimate(text) {
+  const { ascii_chars, wide_chars } = count_chars(text);
+  return Math.round(ascii_chars / ASCII_CHARS_PER_TOKEN) + wide_chars * WIDE_TOKENS_PER_CHAR;
+}
+function ascii_bytes_to_tokens(bytes) {
+  return Math.round(bytes / ASCII_CHARS_PER_TOKEN);
+}
+var cost_tokens = {
+  ASCII_CHARS_PER_TOKEN,
+  count_chars,
+  estimate,
+  ascii_bytes_to_tokens
+};
+
+// scripts/document/document-scan.ts
+var COMMAND_PATTERN = /`(?:pnpm )?josh ([a-z][a-z0-9:-]+)/gu;
+var LABEL_PATTERN = /(?:labels\[\]=|\/labels\/|labels -f name=)([a-z][a-z0-9:_-]*)/gu;
+var SECTION_PATTERN = /(?<![\w./:`-])(?<tick>`?)(?<file>[\w./-]+\.md)\k<tick>\s*→\s*(?:§\w+,\s*)?["「](?<heading>[^"」]+)["」]/gu;
+var ADJACENT_PATTERN = /["「](?<heading>[^"「」]+)["」]\s+(?:above|below)\b/gu;
+var BARE_ARROW_PATTERN = /→\s*(?:§\w+,\s*)?["「](?<heading>[^"「」]+)["」]/gu;
+var LINK_TARGET_PATTERN = /\]\([^)\s]*\)/gu;
+var LINK_PATTERN = /\]\(([\w./-]+\.(?:md|png|jpe?g|gif|svg|webp))(?:#[\w-]+)?\)/gu;
+var PLACEHOLDER_FILES = /* @__PURE__ */ new Set(["x.md", "foo.md", "file.md", "path.md"]);
+function matches(text, pattern) {
+  return [...text.matchAll(pattern)];
+}
+function command_references(text) {
+  return matches(text, COMMAND_PATTERN).map((match) => match[1] ?? "").filter((name) => !name.endsWith(":"));
+}
+function is_real_label(token) {
+  return token.length > 0 && !token.endsWith(":") && !token.includes("<");
+}
+function label_references(text) {
+  return matches(text, LABEL_PATTERN).map((match) => match[1] ?? "").filter((token) => is_real_label(token));
+}
+function base_name(path4) {
+  return path4.split("/").at(-1) ?? path4;
+}
+function is_placeholder_file(name) {
+  return name.includes("<") || PLACEHOLDER_FILES.has(base_name(name).toLowerCase());
+}
+function section_references(text) {
+  return matches(text.replaceAll(LINK_TARGET_PATTERN, ""), SECTION_PATTERN).map(({ groups }) => ({ file: groups?.["file"] ?? "", heading: groups?.["heading"] ?? "" })).filter((reference) => !is_placeholder_file(reference.file));
+}
+function headings_matching(text, pattern) {
+  return matches(text, pattern).map(({ groups }) => groups?.["heading"] ?? "");
+}
+function adjacent_references(text) {
+  return headings_matching(text, ADJACENT_PATTERN);
+}
+function bare_arrow_references(text) {
+  const unfiled = text.replaceAll(LINK_TARGET_PATTERN, "").replaceAll(SECTION_PATTERN, "");
+  return headings_matching(unfiled, BARE_ARROW_PATTERN);
+}
+function link_targets(text) {
+  return matches(text, LINK_PATTERN).map((match) => match[1] ?? "").filter((file) => !is_placeholder_file(file));
+}
+function normalize_reference(heading) {
+  return heading.replaceAll("`", "").split(/\s+/u).filter((word) => word !== ">").join(" ");
+}
+function reference_forms(title) {
+  const normalized = normalize_reference(title);
+  return [normalized, normalized.replace(/^\d+[a-z]?\. /u, "")];
+}
+var document_scan = {
+  adjacent_references,
+  bare_arrow_references,
+  command_references,
+  label_references,
+  link_targets,
+  normalize_reference,
+  reference_forms,
+  section_references
+};
+
+// scripts/document/document-section.ts
+var HEADING_PATTERN = /^(?<hashes>#{1,6}) (?<title>.*)$/u;
+var FENCE = "```";
+var SINGLE_MATCH = 1;
+var BOLD_LABEL_PATTERN = /\*\*([^*]+?)\*\*/gu;
+var BOLD_DELIMITER = "**";
+var CODE_SPAN_PATTERN = /``[^\n]*?``|`[^`\n]*`/gu;
+var LABEL_LEVEL = 7;
+var LIST_ITEM_PATTERN = /^(?<indent>\s*)(?:[-*]|\d+\.) /u;
+function to_heading(line, index) {
+  const groups = HEADING_PATTERN.exec(line)?.groups;
+  if (groups === void 0) return void 0;
+  const { hashes = "", title = "" } = groups;
+  return { level: hashes.length, title: title.trim(), line: index };
+}
+function push_heading(found, line, index) {
+  const heading = to_heading(line, index);
+  if (heading !== void 0) found.push(heading);
+}
+function fenced_flags(lines) {
+  let is_inside_fence = false;
+  return lines.map(function is_fenced(line) {
+    if (!line.startsWith(FENCE)) return is_inside_fence;
+    is_inside_fence = !is_inside_fence;
+    return true;
+  });
+}
+function headings(markdown) {
+  const lines = markdown.split("\n");
+  const fenced = fenced_flags(lines);
+  const found = [];
+  for (const [index, line] of lines.entries()) {
+    if (fenced[index] !== true) push_heading(found, line, index);
+  }
+  return found;
+}
+function titles(markdown) {
+  return headings(markdown).map((heading) => heading.title);
+}
+function line_starts(markdown) {
+  return [...markdown.matchAll(/\n/gu)].map((match) => match.index + SINGLE_MATCH);
+}
+function line_of(starts, offset) {
+  return starts.filter((start2) => start2 <= offset).length;
+}
+function unfenced_text(markdown) {
+  const lines = markdown.split("\n");
+  const fenced = fenced_flags(lines);
+  return lines.map((line, index) => fenced[index] === true ? "" : line).join("\n");
+}
+function code_masked(text) {
+  return text.replaceAll(CODE_SPAN_PATTERN, (span) => span.replaceAll("*", " "));
+}
+function labels(markdown) {
+  const text = unfenced_text(markdown);
+  const starts = line_starts(text);
+  return [...code_masked(text).matchAll(BOLD_LABEL_PATTERN)].map((match) => ({
+    level: LABEL_LEVEL,
+    title: text.slice(
+      match.index + BOLD_DELIMITER.length,
+      match.index + match[0].length - BOLD_DELIMITER.length
+    ),
+    line: line_of(starts, match.index)
+  }));
+}
+function is_match(heading, wanted) {
+  return document_scan.reference_forms(heading.title).some((form) => form.startsWith(wanted));
+}
+function prefixed(found, wanted) {
+  const normalized = document_scan.normalize_reference(wanted);
+  return found.filter((heading) => is_match(heading, normalized));
+}
+function is_exact(heading, wanted) {
+  return document_scan.reference_forms(heading.title).includes(wanted);
+}
+function select(found, wanted) {
+  const normalized = document_scan.normalize_reference(wanted);
+  const exact = found.find((heading) => is_exact(heading, normalized));
+  if (exact !== void 0) return exact;
+  const near = prefixed(found, wanted);
+  return near.length === SINGLE_MATCH ? near[0] : void 0;
+}
+function last_line_of(found, chosen, total_lines) {
+  const next = found.find((heading) => heading.line > chosen.line && heading.level <= chosen.level);
+  return (next === void 0 ? total_lines : next.line) - SINGLE_MATCH;
+}
+function indent_of(line) {
+  return line.length - line.trimStart().length;
+}
+function is_sibling_item(line, depth) {
+  const { indent } = LIST_ITEM_PATTERN.exec(line)?.groups ?? {};
+  return indent !== void 0 && indent.length <= depth;
+}
+function ends_block(line, depth) {
+  if (line.trim() === "" || HEADING_PATTERN.test(line)) return true;
+  return is_sibling_item(line, depth);
+}
+function label_last_line(lines, label) {
+  const depth = indent_of(lines[label.line] ?? "");
+  const end = lines.findIndex((line, index) => index > label.line && ends_block(line, depth));
+  return (end === -1 ? lines.length : end) - SINGLE_MATCH;
+}
+function choose(markdown, wanted) {
+  const found = headings(markdown);
+  if (prefixed(found, wanted).length > 0) return select(found, wanted);
+  return select(labels(markdown), wanted);
+}
+function extent_of(markdown, chosen) {
+  const lines = markdown.split("\n");
+  if (chosen.level === LABEL_LEVEL) return label_last_line(lines, chosen);
+  return last_line_of(headings(markdown), chosen, lines.length);
+}
+function section(markdown, wanted) {
+  const chosen = choose(markdown, wanted);
+  if (chosen === void 0) return void 0;
+  const last_line = extent_of(markdown, chosen);
+  const lines = markdown.split("\n").slice(chosen.line, last_line + SINGLE_MATCH);
+  return {
+    title: chosen.title,
+    level: chosen.level,
+    first_line: chosen.line,
+    last_line,
+    text: lines.join("\n")
+  };
+}
+function candidates(markdown, wanted) {
+  const near = prefixed(headings(markdown), wanted);
+  const listed = near.length > 0 ? near : prefixed(labels(markdown), wanted);
+  return listed.map((heading) => heading.title);
+}
+function read_optional(file_path) {
+  return file_reader.read_if_readable(file_path);
+}
+var document_section = {
+  candidates,
+  headings,
+  read_optional,
+  section,
+  titles
+};
+
+// scripts/josh/package-directory.ts
+import { existsSync } from "node:fs";
+function find_package_directory(start_directory) {
+  return ancestor_directories.nearest(
+    start_directory,
+    (directory) => existsSync(package_manifest.manifest_path(directory))
+  ) ?? start_directory;
+}
+
+// scripts/agent/lane-instructions.ts
+var LANE_DOCUMENT = "prompts/collaboration-workflow/lane-instructions.md";
+var RULES_FILE = "CLAUDE.md";
+var POINTER_FILE = "AGENTS.md";
+var INCLUDE_PATTERN = /^<!-- include: CLAUDE\.md → "(?<wanted>.+)" -->$/u;
+var PROMPT_FILE_FLAG = "--append-system-prompt-file";
+var SETTINGS_FLAG = "--settings";
+var PROMPT_FILE_PREFIX = "josh-lane-instructions-";
+var PROMPT_FILE_SUFFIX = ".md";
+var PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(import.meta.url)));
+function expand_line(line, rules) {
+  const wanted = INCLUDE_PATTERN.exec(line)?.groups?.["wanted"];
+  if (wanted === void 0) return line;
+  return document_section.section(rules, wanted)?.text;
+}
+function compose(lane_markdown, rules) {
+  const expanded = lane_markdown.split("\n").map((line) => expand_line(line, rules));
+  if (expanded.includes(void 0)) return void 0;
+  return expanded.join("\n");
+}
+function rules_sources(cwd) {
+  const imported = distributed_paths.CLAUDE_MD_IMPORT_LINE.replace(/^@/u, "");
+  return [path.join(cwd, RULES_FILE), path.join(cwd, imported)];
+}
+function composed_from(lane_markdown, rules_path) {
+  const rules = document_section.read_optional(rules_path);
+  return rules === void 0 ? void 0 : compose(lane_markdown, rules);
+}
+function composed_set(cwd, package_directory) {
+  const lane_markdown = document_section.read_optional(path.join(package_directory, LANE_DOCUMENT));
+  if (lane_markdown === void 0) return void 0;
+  for (const rules_path of rules_sources(cwd)) {
+    const text = composed_from(lane_markdown, rules_path);
+    if (text !== void 0) return { text, rules_path };
+  }
+  return void 0;
+}
+function composed_in(cwd, package_directory = PACKAGE_DIRECTORY) {
+  return composed_set(cwd, package_directory)?.text;
+}
+function written(text) {
+  const file_path = stamp_file.stamp_path(PROMPT_FILE_PREFIX, text, PROMPT_FILE_SUFFIX);
+  if (stamp_file.read_stamp_text(file_path) === text) return file_path;
+  try {
+    return stamp_file.replace_text_stamp(file_path, text);
+  } catch {
+    return void 0;
+  }
+}
+function excluded_settings(rules_path, cwd) {
+  return JSON.stringify({ claudeMdExcludes: [rules_path, path.join(cwd, POINTER_FILE)] });
+}
+function flags(cwd = process.cwd()) {
+  const set = composed_set(cwd, PACKAGE_DIRECTORY);
+  const prompt_file = set === void 0 ? void 0 : written(set.text);
+  if (set === void 0 || prompt_file === void 0) return [];
+  return [PROMPT_FILE_FLAG, prompt_file, SETTINGS_FLAG, excluded_settings(set.rules_path, cwd)];
+}
+function tokens_of(text) {
+  return cost_tokens.estimate(text).toLocaleString("en-US");
+}
+function rules_tokens(rules_path) {
+  return tokens_of(document_section.read_optional(rules_path) ?? "");
+}
+function resident_line(cwd = process.cwd()) {
+  const set = composed_set(cwd, PACKAGE_DIRECTORY);
+  const rules = rules_tokens(set?.rules_path ?? path.join(cwd, RULES_FILE));
+  const lane_tokens = set === void 0 ? "not composed" : `${tokens_of(set.text)} tok`;
+  return `  resident: lane instructions ${lane_tokens} in place of ${RULES_FILE} ${rules} tok`;
+}
+var lane_instructions = {
+  PROMPT_FILE_FLAG,
+  SETTINGS_FLAG,
+  compose,
+  composed_in,
+  flags,
+  resident_line
+};
+
+// scripts/agent/claude-agent-argv.ts
 var AGENT_COMMAND = "claude";
 var PERMISSION_FLAGS = ["--permission-mode", "bypassPermissions"];
 var AGENT_FLAGS = [
@@ -137,23 +461,29 @@ function session_id_flags(session_id) {
   return session_id === void 0 ? [] : [SESSION_ID_FLAG, session_id];
 }
 function tool_flags(cwd = process.cwd()) {
-  const mcp_config = path.join(cwd, PROJECT_MCP_FILE);
-  const mcp_flags = existsSync(mcp_config) ? [STRICT_MCP_FLAG, MCP_CONFIG_FLAG, mcp_config] : [STRICT_MCP_FLAG];
+  const mcp_config = path2.join(cwd, PROJECT_MCP_FILE);
+  const mcp_flags = existsSync2(mcp_config) ? [STRICT_MCP_FLAG, MCP_CONFIG_FLAG, mcp_config] : [STRICT_MCP_FLAG];
   return [TOOLS_FLAG, LAUNCHED_TOOLS.join(","), ...mcp_flags];
 }
+function instruction_flags(profile, cwd) {
+  if (profile.role === agent_role_profile.SCHEDULER) return [];
+  return lane_instructions.flags(cwd);
+}
 function build(invocation, profile, session_id, cwd) {
   return {
     command: AGENT_COMMAND,
     args: [
       ...AGENT_FLAGS,
       ...tool_flags(cwd),
+      ...instruction_flags(profile, cwd),
       ...session_id_flags(session_id),
       MODEL_FLAG,
       profile.model,
       EFFORT_FLAG,
       profile.effort,
       invocation
-    ]
+    ],
+    ends_with_prompt: true
   };
 }
 function build_resume(invocation, profile, session_id, cwd) {
@@ -162,6 +492,7 @@ function build_resume(invocation, profile, session_id, cwd) {
     args: [
       ...AGENT_FLAGS,
       ...tool_flags(cwd),
+      ...instruction_flags(profile, cwd),
       RESUME_FLAG,
       session_id,
       MODEL_FLAG,
@@ -169,7 +500,8 @@ function build_resume(invocation, profile, session_id, cwd) {
       EFFORT_FLAG,
       profile.effort,
       invocation
-    ]
+    ],
+    ends_with_prompt: true
   };
 }
 function with_profile(invocation, profile) {
@@ -191,14 +523,7 @@ var claude_agent_argv = {
 
 // scripts/agent/codex-agent-argv.ts
 import { lstatSync, mkdirSync } from "node:fs";
-import path2 from "node:path";
-
-// scripts/observations/observation-ledger.ts
-var OBSERVATION_LEDGER_DIRECTORY = ".josh/observations";
-var LEDGER_FILE_EXTENSION = ".md";
-var LEGACY_LEDGER_FILE = `legacy${LEDGER_FILE_EXTENSION}`;
-
-// scripts/agent/codex-agent-argv.ts
+import path3 from "node:path";
 var AGENT_COMMAND2 = "codex";
 var AGENT_FLAGS2 = ["exec", "--sandbox", "workspace-write"];
 var MODEL_FLAG2 = "--model";
@@ -209,12 +534,12 @@ var SQLITE_CACHE_PATH = ["node_modules", ".cache", "josh", "openai"];
 var EPHEMERAL_FLAG = "--ephemeral";
 var ADD_DIRECTORY_FLAG = "--add-dir";
 var GIT_DIRECTORY = ".git";
-var LEDGER_DIRECTORY = path2.dirname(OBSERVATION_LEDGER_DIRECTORY);
+var LEDGER_DIRECTORY = path3.dirname(OBSERVATION_LEDGER_DIRECTORY);
 function effort_config(profile) {
   return `model_reasoning_effort="${profile.effort}"`;
 }
 function sqlite_config(cwd) {
-  return `sqlite_home=${JSON.stringify(path2.resolve(cwd, ...SQLITE_CACHE_PATH))}`;
+  return `sqlite_home=${JSON.stringify(path3.resolve(cwd, ...SQLITE_CACHE_PATH))}`;
 }
 function persistence_arguments(profile) {
   return profile.role === agent_role_profile.WORKER ? [] : [EPHEMERAL_FLAG];
@@ -227,10 +552,10 @@ function ensure_ledger_directory(directory) {
   }
 }
 function ledger_arguments(common_directory, profile) {
-  if (common_directory === void 0 || profile.role !== agent_role_profile.WORKER || path2.basename(common_directory) !== GIT_DIRECTORY) {
+  if (common_directory === void 0 || profile.role !== agent_role_profile.WORKER || path3.basename(common_directory) !== GIT_DIRECTORY) {
     return [];
   }
-  const directory = path2.join(path2.dirname(common_directory), LEDGER_DIRECTORY);
+  const directory = path3.join(path3.dirname(common_directory), LEDGER_DIRECTORY);
   ensure_ledger_directory(directory);
   return [ADD_DIRECTORY_FLAG, directory];
 }
@@ -259,7 +584,8 @@ function build2(invocation, profile, cwd) {
       ...cwd === void 0 ? [] : lane_arguments(cwd, profile),
       JSON_FLAG,
       invocation
-    ]
+    ],
+    ends_with_prompt: true
   };
 }
 var codex_agent_argv = { build: build2 };
@@ -297,13 +623,19 @@ function resume_argv(invocation, profile, phase, cwd) {
   const resolved = agent_role_profile.resolve(agent_role_profile.WORKER, process.env, phase);
   return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, cwd);
 }
-function resolve_in(invocation, role, cwd, environment = process.env) {
-  const resolved = agent_role_profile.resolve(role, environment);
+function profiled_in(invocation, resolved, cwd) {
   return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, cwd);
 }
+function resolve_in(invocation, role, cwd, environment = process.env) {
+  return profiled_in(invocation, agent_role_profile.resolve(role, environment), cwd);
+}
+function review_in(invocation, round, cwd, environment = process.env) {
+  return profiled_in(invocation, agent_role_profile.resolve_review(round, environment), cwd);
+}
 var agent_argv = {
   resolve: resolve2,
   resolve_in,
+  review_in,
   resume_argv,
   with_profile: with_profile2,
   with_profile_in,
@@ -452,6 +784,9 @@ function signal_parent(pid) {
     note_to_stderr(`process ${String(pid)} could not be signalled; its launch record is removed.`);
   }
 }
+function running_parent(git_directory) {
+  return live_launch(git_directory)?.pid;
+}
 function stop_parent(git_directory) {
   const record = live_launch(git_directory);
   stamp_file.remove_stamp(launch_path(git_directory));
@@ -492,6 +827,7 @@ var backlogrun_launch = {
   chosen_environment,
   is_running,
   pending_launch,
+  running_parent,
   start,
   started_for,
   stop_parent
@@ -519,8 +855,7 @@ async function is_run_live(ports = LIVE_PORTS) {
 function prompt_lines(resolution, is_live) {
   return [format_line(resolution), is_live ? BOARD_LINE : ""].filter((line) => line !== "");
 }
-async function main() {
-  josh_environment_file.load_environment_file();
+async function print_prompt_lines() {
   const lines = prompt_lines(resolve_session_lang(), await is_run_live());
   for (const line of lines) console.info(line);
 }
@@ -530,10 +865,13 @@ var session_language_cli = {
   ENV_KEY,
   format_line,
   is_run_live,
+  print_prompt_lines,
   prompt_lines,
   resolve_session_lang
 };
-if (process.argv[1] === fileURLToPath(import.meta.url)) await main();
-export {
-  session_language_cli
-};
+
+// scripts/josh/session-language-main.ts
+if (process.argv[1] === fileURLToPath2(import.meta.url)) {
+  josh_environment_file.load_environment_file();
+  await session_language_cli.print_prompt_lines();
+}