@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-D6CF5QGM.js

@@ -0,0 +1,80 @@
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  run_liveness
+} from "./chunk-DHJRFBKO.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-report.ts
+var NO_LANES = "No lanes are open.";
+var OPEN_STATE = "open";
+var STRANDED_STATE = "stranded";
+var UNREADABLE_STATE = "unreadable";
+var UNKNOWN_VALUE = "-";
+var COLUMN_SEPARATOR = "  ";
+function lane_state(lane) {
+  if (lane.is_stranded) return STRANDED_STATE;
+  if (lane.seat_problem !== void 0) return lane.seat_problem;
+  if (lane.seat_held === false) return "seat released";
+  return lane.seat === void 0 ? UNREADABLE_STATE : OPEN_STATE;
+}
+function value_or_unknown(value) {
+  return value === void 0 ? UNKNOWN_VALUE : String(value);
+}
+function output_column(output) {
+  return `output ${output ?? UNKNOWN_VALUE}`;
+}
+function profile_column(lane) {
+  return `profile ${lane.profile === void 0 ? UNKNOWN_VALUE : agent_role_profile.describe(lane.profile)}`;
+}
+function event_column(lane) {
+  if (lane.output === void 0) return "agent -";
+  const state = run_liveness.describe_agent_state(lane.output);
+  return state ?? "agent -";
+}
+var PLAIN_CITE = issue_cite.citer(void 0, /* @__PURE__ */ new Map());
+function describe_lane(lane, cite = PLAIN_CITE) {
+  return [
+    cite(lane.issue),
+    `seat ${value_or_unknown(lane.seat)}`,
+    `dev ${value_or_unknown(lane.development_port)}`,
+    `preview ${value_or_unknown(lane.preview_port)}`,
+    lane.branch,
+    lane_state(lane),
+    lane.directory,
+    output_column(lane.output),
+    profile_column(lane),
+    event_column(lane)
+  ].join(COLUMN_SEPARATOR);
+}
+function describe_lanes(lanes, cite = PLAIN_CITE) {
+  if (lanes.length === 0) return NO_LANES;
+  return lanes.map((lane) => describe_lane(lane, cite)).join("\n");
+}
+function describe_ports(lane) {
+  if (lane.seat === void 0) return "no lane seat could be read";
+  return `seat ${String(lane.seat)}, dev ${value_or_unknown(lane.development_port)}, preview ${value_or_unknown(lane.preview_port)}`;
+}
+function describe_opened(lane) {
+  return `Opened a lane for ${session_cite.issue(lane.issue)} on ${lane.branch}: ${describe_ports(lane)}.`;
+}
+var lane_report = {
+  NO_LANES,
+  OPEN_STATE,
+  STRANDED_STATE,
+  UNREADABLE_STATE,
+  describe_lane,
+  describe_lanes,
+  describe_opened,
+  lane_state
+};
+
+export {
+  lane_report
+};

package/dist/commands/chunk-DACNQAXC.js

@@ -0,0 +1,20 @@
+import {
+  MAX_SCANNED
+} from "./chunk-TEXUEBGE.js";
+
+// scripts/git/listing-cutoff.ts
+function cutoff_of(row_count, limit, is_capped) {
+  if (row_count >= limit) return "row_limit";
+  return is_capped ? "page_ceiling" : "none";
+}
+var PAGE_CEILING_CAUSE = `stopped at the ${String(MAX_SCANNED)}-issue page ceiling`;
+function cutoff_cause(cutoff, row_limit_cause) {
+  if (cutoff === "row_limit") return row_limit_cause;
+  return cutoff === "page_ceiling" ? PAGE_CEILING_CAUSE : void 0;
+}
+
+export {
+  cutoff_of,
+  PAGE_CEILING_CAUSE,
+  cutoff_cause
+};

package/dist/commands/chunk-DDOS32JU.js

@@ -0,0 +1,74 @@
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-plan-wait-event.ts
+var { EVENT_KIND } = run_event_stream;
+var START = "start";
+var END = "end";
+var TEXT = /^#(?<issue>[1-9]\d*) (?<phase>start|end) (?<holder>#[1-9]\d*)$/u;
+function text_of(pair, phase) {
+  return `${issue_cite.plain_for("program", pair.issue)} ${phase} ${issue_cite.plain_for("program", pair.holder)}`;
+}
+async function timed(pair, wait) {
+  await run_event_stream_emit.emit(EVENT_KIND.PLAN_WAIT, text_of(pair, START));
+  try {
+    return await wait();
+  } finally {
+    await run_event_stream_emit.emit(EVENT_KIND.PLAN_WAIT, text_of(pair, END));
+  }
+}
+function words_of(event) {
+  if (event.kind !== EVENT_KIND.PLAN_WAIT) return [];
+  return TEXT.exec(event.text)?.slice(1) ?? [];
+}
+function mark_of(event, issue) {
+  const [lane, phase = "", holder = ""] = words_of(event);
+  if (Number(lane) !== issue) return [];
+  return [{ at_ms: Date.parse(event.at), phase, holder }];
+}
+function pair_of(start, end) {
+  if (end.phase !== END || start?.phase !== START || start.holder !== end.holder) return [];
+  return [
+    {
+      from_ms: start.at_ms,
+      to_ms: end.at_ms,
+      name: `lane:plan wait (${end.holder})`
+    }
+  ];
+}
+function spans(events, issue) {
+  const marks = events.flatMap((event) => mark_of(event, issue)).toSorted((left, right) => left.at_ms - right.at_ms);
+  return marks.flatMap((mark, index) => pair_of(marks[index - 1], mark));
+}
+function inside_of(segment, waits) {
+  return waits.map((wait) => ({
+    ...wait,
+    from_ms: Math.max(segment.from_ms, wait.from_ms),
+    to_ms: Math.min(segment.to_ms, wait.to_ms)
+  })).filter((wait) => wait.to_ms > wait.from_ms);
+}
+function carved_one(segment, waits) {
+  const parts = [];
+  let { from_ms } = segment;
+  for (const wait of inside_of(segment, waits)) {
+    if (wait.from_ms > from_ms) parts.push({ ...segment, from_ms, to_ms: wait.from_ms });
+    parts.push({ ...segment, stage: wait.name, from_ms: wait.from_ms, to_ms: wait.to_ms });
+    from_ms = wait.to_ms;
+  }
+  return from_ms < segment.to_ms ? [...parts, { ...segment, from_ms }] : parts;
+}
+function carved(segments, waits) {
+  return segments.flatMap((segment) => carved_one(segment, waits));
+}
+var lane_plan_wait_event = { carved, spans, timed };
+
+export {
+  lane_plan_wait_event
+};

package/dist/commands/chunk-DDZVMXZD.js

@@ -0,0 +1,481 @@
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/agent/agent-provider.ts
+import { z } from "zod";
+var EMPTY_LENGTH = 0;
+var PROVIDER_SCHEMA = z.enum(["anthropic", "openai"]);
+var ANTHROPIC_PROVIDER = "anthropic";
+var OPENAI_PROVIDER = "openai";
+var CODEX_SESSION_KEY = "CODEX_THREAD_ID";
+function trimmed(value) {
+  const result = value?.trim();
+  return result === void 0 || result.length === EMPTY_LENGTH ? void 0 : result;
+}
+function rejection(key, value, expected) {
+  return { kind: "rejected", note: `${key}=${value} ${expected}, so the agent was not started` };
+}
+function has_session(environment, keys) {
+  return keys.some((key) => trimmed(environment[key]) !== void 0);
+}
+var CONFLICTING_SESSIONS = {
+  kind: "rejected",
+  note: "both Codex and Claude Code sessions were detected"
+};
+var HANDED_PROVIDER_KEY = "JOSH_AGENT_PROVIDER";
+var DEFAULT_PROVIDER = {
+  kind: "provider",
+  provider: ANTHROPIC_PROVIDER,
+  is_default: true
+};
+var DEFAULT_NOTICE = ` No agent session or ${HANDED_PROVIDER_KEY} was found, so the provider defaulted to ${ANTHROPIC_PROVIDER} (Claude Code).`;
+function handed_provider(environment) {
+  const value = trimmed(environment[HANDED_PROVIDER_KEY]);
+  if (value === void 0) return DEFAULT_PROVIDER;
+  const parsed = PROVIDER_SCHEMA.safeParse(value);
+  return parsed.success ? { kind: "provider", provider: parsed.data } : rejection(HANDED_PROVIDER_KEY, value, "is not an allowed provider");
+}
+function detected_provider(environment) {
+  const has_codex = has_session(environment, [CODEX_SESSION_KEY]);
+  const has_claude = has_session(environment, agent_session_environment.PARENT_SESSION_KEYS);
+  if (has_codex === has_claude) return has_codex ? CONFLICTING_SESSIONS : void 0;
+  return { kind: "provider", provider: has_codex ? OPENAI_PROVIDER : ANTHROPIC_PROVIDER };
+}
+function resolve_provider(environment = process.env) {
+  return detected_provider(environment) ?? handed_provider(environment);
+}
+function default_notice(environment = process.env) {
+  const selected = resolve_provider(environment);
+  return selected.kind === "provider" && selected.is_default === true ? DEFAULT_NOTICE : "";
+}
+function warn_of_default(environment = process.env) {
+  const notice = default_notice(environment).trim();
+  if (notice !== "") console.error(notice);
+}
+function has_completion_callback(environment = process.env) {
+  const selected = resolve_provider(environment);
+  return selected.kind !== "provider" || selected.provider !== OPENAI_PROVIDER;
+}
+function handoff_environment(environment = process.env) {
+  const selected = resolve_provider(environment);
+  return selected.kind === "provider" ? { [HANDED_PROVIDER_KEY]: selected.provider } : {};
+}
+var agent_provider = {
+  ANTHROPIC_PROVIDER,
+  CODEX_SESSION_KEY,
+  HANDED_PROVIDER_KEY,
+  OPENAI_PROVIDER,
+  PROVIDER_SCHEMA,
+  default_notice,
+  handoff_environment,
+  has_completion_callback,
+  rejection,
+  resolve_provider,
+  trimmed,
+  warn_of_default
+};
+
+// scripts/cost-runtime/cost-transcript.ts
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+// scripts/time-runtime/time-instant.ts
+function parse_instant(raw) {
+  if (raw === null || raw === void 0) return void 0;
+  const parsed = Date.parse(raw);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+var time_instant = { parse_instant };
+
+// scripts/cost-runtime/cost-usage.ts
+import { z as z2 } from "zod";
+var CACHE_CREATION_SCHEMA = z2.object({
+  ephemeral_1h_input_tokens: z2.number().nullish(),
+  ephemeral_5m_input_tokens: z2.number().nullish()
+});
+var USAGE_SCHEMA = z2.object({
+  input_tokens: z2.number(),
+  cache_creation_input_tokens: z2.number().nullish(),
+  cache_read_input_tokens: z2.number().nullish(),
+  output_tokens: z2.number(),
+  output_tokens_details: z2.object({ thinking_tokens: z2.number().nullish() }).nullish(),
+  cache_creation: CACHE_CREATION_SCHEMA.nullish()
+});
+var MESSAGE_SCHEMA = z2.object({
+  id: z2.string().nullish(),
+  model: z2.string().nullish(),
+  usage: USAGE_SCHEMA.nullish()
+});
+var LINE_SCHEMA = z2.object({
+  type: z2.string(),
+  requestId: z2.string().nullish(),
+  uuid: z2.string().nullish(),
+  gitBranch: z2.string().nullish(),
+  timestamp: z2.string().nullish(),
+  message: MESSAGE_SCHEMA.nullish()
+});
+var SYNTHETIC_MODEL = "<synthetic>";
+var EMPTY_TOTALS = {
+  input_tokens: 0,
+  cache_write_5m_tokens: 0,
+  cache_write_1h_tokens: 0,
+  cache_read_tokens: 0,
+  output_tokens: 0,
+  thinking_tokens: 0,
+  thinking_measured: false
+};
+var UNKNOWN_MODEL = "unknown";
+var UNKNOWN_BRANCH = "";
+function split_cache_write(usage) {
+  const total = usage.cache_creation_input_tokens ?? 0;
+  const detail = usage.cache_creation;
+  if (!detail) return { write_5m: total, write_1h: 0 };
+  const write_1h = detail.ephemeral_1h_input_tokens ?? 0;
+  return { write_5m: detail.ephemeral_5m_input_tokens ?? total - write_1h, write_1h };
+}
+function thinking_usage(usage) {
+  const raw = usage.output_tokens_details?.thinking_tokens;
+  return { tokens: raw ?? 0, measured: raw !== null && raw !== void 0 };
+}
+function to_totals(usage) {
+  const { write_5m, write_1h } = split_cache_write(usage);
+  const thinking = thinking_usage(usage);
+  return {
+    input_tokens: usage.input_tokens,
+    cache_write_5m_tokens: write_5m,
+    cache_write_1h_tokens: write_1h,
+    cache_read_tokens: usage.cache_read_input_tokens ?? 0,
+    output_tokens: usage.output_tokens,
+    thinking_tokens: thinking.tokens,
+    thinking_measured: thinking.measured
+  };
+}
+function declared_id(data) {
+  return data.requestId ?? data.message?.id ?? data.uuid ?? void 0;
+}
+function request_id_of(data, usage) {
+  const fallback = `${data.timestamp ?? ""}-${String(usage.output_tokens)}`;
+  return declared_id(data) ?? fallback;
+}
+function to_record(data, usage) {
+  return {
+    request_id: request_id_of(data, usage),
+    model: data.message?.model ?? UNKNOWN_MODEL,
+    branch: data.gitBranch ?? UNKNOWN_BRANCH,
+    at_ms: time_instant.parse_instant(data.timestamp),
+    totals: to_totals(usage)
+  };
+}
+var ASSISTANT_TYPE = "assistant";
+function is_priced_line(data) {
+  return data.type === ASSISTANT_TYPE && data.message?.model !== SYNTHETIC_MODEL;
+}
+function classify(data) {
+  if (!is_priced_line(data)) return { kind: "skipped" };
+  const usage = data.message?.usage;
+  return usage ? { kind: "record", record: to_record(data, usage) } : { kind: "no_usage" };
+}
+function parse_line(line) {
+  if (line.trim() === "") return { kind: "skipped" };
+  const parsed = LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
+  return parsed.success ? classify(parsed.data) : { kind: "malformed" };
+}
+function later_instant(left, right) {
+  if (left === void 0) return right;
+  if (right === void 0) return left;
+  return Math.max(left, right);
+}
+function dedupe(records) {
+  const by_id = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const seen = by_id.get(record.request_id);
+    const at_ms = later_instant(seen?.at_ms, record.at_ms);
+    by_id.set(record.request_id, { ...seen ?? record, at_ms });
+  }
+  return [...by_id.values()];
+}
+function add_totals(left, right) {
+  return {
+    input_tokens: left.input_tokens + right.input_tokens,
+    cache_write_5m_tokens: left.cache_write_5m_tokens + right.cache_write_5m_tokens,
+    cache_write_1h_tokens: left.cache_write_1h_tokens + right.cache_write_1h_tokens,
+    cache_read_tokens: left.cache_read_tokens + right.cache_read_tokens,
+    output_tokens: left.output_tokens + right.output_tokens,
+    thinking_tokens: left.thinking_tokens + right.thinking_tokens,
+    thinking_measured: left.thinking_measured || right.thinking_measured
+  };
+}
+function sum_totals(records) {
+  let total = EMPTY_TOTALS;
+  for (const record of records) total = add_totals(total, record.totals);
+  return total;
+}
+function billed_input(totals) {
+  return totals.input_tokens + totals.cache_write_5m_tokens + totals.cache_write_1h_tokens + totals.cache_read_tokens;
+}
+var cost_usage = {
+  EMPTY_TOTALS,
+  UNKNOWN_MODEL,
+  SYNTHETIC_MODEL,
+  parse_line,
+  dedupe,
+  add_totals,
+  sum_totals,
+  billed_input
+};
+
+// scripts/cost-runtime/cost-transcript.ts
+var TRANSCRIPT_ROOT = path.join(".claude", "projects");
+var TRANSCRIPT_EXTENSION = ".jsonl";
+var SLUG_PATTERN = /[^a-zA-Z0-9-]/gu;
+var UNIT_DIRECTORY = "subagents";
+var UNIT_ID_SEPARATOR = "/";
+function project_slug(cwd) {
+  return cwd.replaceAll(SLUG_PATTERN, "-");
+}
+function transcript_directory(cwd, home = homedir()) {
+  return path.join(home, TRANSCRIPT_ROOT, project_slug(cwd));
+}
+var GIT_ENTRY = ".git";
+var GITDIR_PREFIX = "gitdir:";
+var WORKTREE_SEGMENT = `/${GIT_ENTRY}/worktrees/`;
+var NOT_FOUND = -1;
+function linked_worktree_gitdir(cwd) {
+  try {
+    const contents = readFileSync(path.join(cwd, GIT_ENTRY), "utf8").trim();
+    return contents.startsWith(GITDIR_PREFIX) ? contents.slice(GITDIR_PREFIX.length).trim() : "";
+  } catch {
+    return "";
+  }
+}
+function session_cwd(cwd) {
+  const gitdir = linked_worktree_gitdir(cwd);
+  const absolute = gitdir === "" ? "" : path.resolve(cwd, gitdir);
+  const segment = absolute.indexOf(WORKTREE_SEGMENT);
+  return segment === NOT_FOUND ? cwd : absolute.slice(0, segment);
+}
+function read_directory(directory) {
+  try {
+    return readdirSync(directory);
+  } catch {
+    return [];
+  }
+}
+function lane_transcript_directories(main_cwd, home) {
+  const projects = path.join(home, TRANSCRIPT_ROOT);
+  const prefix = `${project_slug(lane_paths.lane_root(main_cwd))}-`;
+  return read_directory(projects).filter(
+    (name) => name.startsWith(prefix) && issue_number_shape.ISSUE_NUMBER_PATTERN.test(name.slice(prefix.length))
+  ).map((name) => path.join(projects, name));
+}
+function transcript_directories(cwd, home = homedir()) {
+  const own = transcript_directory(cwd, home);
+  const lanes = session_cwd(cwd) === cwd ? lane_transcript_directories(cwd, home) : [];
+  return [.../* @__PURE__ */ new Set([own, ...lanes])];
+}
+var OWN_DEPTH = 0;
+function home_directory() {
+  return homedir();
+}
+function to_session_file(full_path, session_id, depth) {
+  try {
+    return {
+      session_id,
+      path: full_path,
+      modified_ms: statSync(full_path).mtimeMs,
+      is_delegated: depth > OWN_DEPTH,
+      depth
+    };
+  } catch {
+    return void 0;
+  }
+}
+function is_transcript(name) {
+  return name.endsWith(TRANSCRIPT_EXTENSION);
+}
+function without_extension(name) {
+  return name.slice(0, -TRANSCRIPT_EXTENSION.length);
+}
+function own_files(directory, names) {
+  return names.filter((name) => is_transcript(name)).map((name) => to_session_file(path.join(directory, name), without_extension(name), OWN_DEPTH)).filter((file) => file !== void 0);
+}
+function unit_directory(directory, session_id) {
+  return path.join(directory, session_id, UNIT_DIRECTORY);
+}
+var UNIT_DEPTH = 1;
+function level_units(subagents_directory, prefix, depth) {
+  return read_directory(subagents_directory).filter((name) => is_transcript(name)).map(
+    (name) => to_session_file(
+      path.join(subagents_directory, name),
+      `${prefix}${UNIT_ID_SEPARATOR}${without_extension(name)}`,
+      depth
+    )
+  ).filter((file) => file !== void 0);
+}
+function collect_units(subagents_directory, prefix, depth) {
+  const nested = read_directory(subagents_directory).filter((name) => !is_transcript(name)).flatMap(
+    (name) => collect_units(
+      unit_directory(subagents_directory, name),
+      `${prefix}${UNIT_ID_SEPARATOR}${name}`,
+      depth + 1
+    )
+  );
+  return [...level_units(subagents_directory, prefix, depth), ...nested];
+}
+function unit_files(directory, session_name) {
+  return collect_units(unit_directory(directory, session_name), session_name, UNIT_DEPTH);
+}
+function list_sessions(directory) {
+  const names = read_directory(directory);
+  const units = names.filter((name) => !is_transcript(name)).flatMap((name) => unit_files(directory, name));
+  return [...own_files(directory, names), ...units].toSorted(
+    (left, right) => right.modified_ms - left.modified_ms
+  );
+}
+function list_sessions_across(directories) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = directories.flatMap((directory) => list_sessions(directory));
+  const newest_first = merged.toSorted((left, right) => right.modified_ms - left.modified_ms);
+  const kept = [];
+  for (const file of newest_first) {
+    if (seen.has(file.session_id)) continue;
+    seen.add(file.session_id);
+    kept.push(file);
+  }
+  return kept;
+}
+function owning_session_id(file) {
+  const [owner] = file.session_id.split(UNIT_ID_SEPARATOR);
+  return owner ?? file.session_id;
+}
+function parent_session_id(file) {
+  const separator = file.session_id.lastIndexOf(UNIT_ID_SEPARATOR);
+  return separator === NOT_FOUND ? file.session_id : file.session_id.slice(0, separator);
+}
+function latest_own_index(files) {
+  const index = files.findIndex((file) => !file.is_delegated);
+  return index === -1 ? 0 : index;
+}
+function empty_session() {
+  return {
+    records: [],
+    no_usage_lines: 0,
+    malformed_lines: 0,
+    is_readable: false,
+    baseline_tokens: 0
+  };
+}
+function tally(content) {
+  const outcomes = content.split("\n").map((line) => cost_usage.parse_line(line));
+  const records = outcomes.flatMap(
+    (outcome) => outcome.kind === "record" ? [outcome.record] : []
+  );
+  const unique = cost_usage.dedupe(records);
+  const [first] = unique;
+  return {
+    records: unique,
+    no_usage_lines: outcomes.filter((outcome) => outcome.kind === "no_usage").length,
+    malformed_lines: outcomes.filter((outcome) => outcome.kind === "malformed").length,
+    is_readable: true,
+    baseline_tokens: first === void 0 ? 0 : cost_usage.billed_input(first.totals)
+  };
+}
+function read_session(file) {
+  const content = file_reader.read_if_readable(file.path);
+  if (content === void 0) return { session_id: file.session_id, ...empty_session() };
+  return { session_id: file.session_id, ...tally(content) };
+}
+function read_raw(file) {
+  return file_reader.read_if_readable(file.path) ?? "";
+}
+function read_optional(file) {
+  return file_reader.read_if_readable(file.path);
+}
+function directory_exists(directory) {
+  try {
+    return statSync(directory).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function searched_directories(directories) {
+  return directories.map((directory) => ({
+    path: directory,
+    exists: directory_exists(directory)
+  }));
+}
+function describe_searched(directory) {
+  return `  ${directory.path} \u2014 ${directory.exists ? "no transcripts here" : "no such directory"}`;
+}
+function missing_message(searched, session_id) {
+  const lead = session_id === void 0 ? "No transcripts found. Searched:" : `No transcript named ${session_id}. Searched:`;
+  const listed = searched.map((directory) => describe_searched(directory));
+  if (session_id !== void 0) return [lead, ...listed];
+  return [
+    lead,
+    ...listed,
+    "Claude Code writes them per project; run this from the project it ran in."
+  ];
+}
+var cost_transcript = {
+  TRANSCRIPT_EXTENSION,
+  TRANSCRIPT_ROOT,
+  UNIT_DIRECTORY,
+  project_slug,
+  transcript_directory,
+  transcript_directories,
+  session_cwd,
+  lane_transcript_directories,
+  unit_directory,
+  list_sessions,
+  list_sessions_across,
+  searched_directories,
+  owning_session_id,
+  parent_session_id,
+  latest_own_index,
+  tally,
+  read_session,
+  read_raw,
+  read_optional,
+  missing_message,
+  home_directory
+};
+
+// scripts/cost-runtime/own-session.ts
+var NOT_FOUND2 = -1;
+function session_id_of(environment) {
+  const value = environment[agent_session_environment.SESSION_ID_KEY];
+  return value === void 0 || value === "" ? void 0 : value;
+}
+function select_own_session(files, environment) {
+  const session_id = session_id_of(environment);
+  if (session_id === void 0) {
+    return { kind: "own", index: cost_transcript.latest_own_index(files) };
+  }
+  const index = files.findIndex((file) => file.session_id === session_id);
+  return index === NOT_FOUND2 ? { kind: "absent", session_id } : { kind: "own", index };
+}
+var own_session = {
+  session_id_of,
+  select_own_session
+};
+
+export {
+  agent_provider,
+  time_instant,
+  cost_usage,
+  cost_transcript,
+  own_session
+};

package/dist/commands/chunk-DF6QD4AF.js

@@ -0,0 +1,52 @@
+import {
+  epic_issue
+} from "./chunk-YEAE46TS.js";
+import {
+  git_gh_issue_read,
+  git_gh_issue_rest
+} from "./chunk-TFYYXETQ.js";
+import {
+  git_gh_etag_read
+} from "./chunk-IPS7EBE5.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+
+// scripts/epic/epic-live.ts
+async function child(number, repo) {
+  const json = await git_gh_issue_read.issue_view_json(
+    String(number),
+    "number,state,labels,body",
+    repo,
+    git_gh_etag_read.read
+  );
+  const parsed = epic_issue.parse_epic_issue(json);
+  if (parsed?.number !== number || !["OPEN", "CLOSED"].includes(parsed.state)) {
+    throw new Error(`Cannot read live issue ${session_cite.issue(number, void 0, repo)}`);
+  }
+  return {
+    number,
+    repo,
+    state: epic_issue.normalize_state(parsed.state),
+    labels: epic_issue.label_names(parsed),
+    body: parsed.body,
+    blocked_by: []
+  };
+}
+async function blockers(number, repo) {
+  const endpoint = git_gh_api_path.blocked_by_api_path(String(number), repo);
+  const json = await git_gh_etag_read.read_listing(
+    `${endpoint}${git_gh_api_path.FULL_PAGE_QUERY}`,
+    git_gh_api_path.FULL_PAGE_SIZE
+  );
+  const listing = git_gh_issue_rest.to_blocked_by(json);
+  return listing.nodes.map((blocker) => git_gh_issue_rest.reference_of_blocker(blocker, repo));
+}
+var epic_live = { child, blockers };
+
+export {
+  epic_live
+};