@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-CDK7QZWG.js

@@ -0,0 +1,44 @@
+import {
+  acceptance_map
+} from "./chunk-5PCK53WP.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/review/acceptance-map-check.ts
+var ISSUE_SEPARATOR = "#";
+async function is_found(deferral) {
+  const [repo, number = ""] = deferral.issue.split(ISSUE_SEPARATOR);
+  const read = await git_gh_command.issue_get_body_classified(
+    number,
+    repo === "" ? void 0 : repo
+  );
+  return read.kind === "read";
+}
+async function absent_deferrals(deferrals) {
+  const found = await Promise.all(deferrals.map(async (deferral) => await is_found(deferral)));
+  return deferrals.filter((_deferral, index) => found[index] !== true).map((deferral) => `- \`${deferral.id}\` names ${deferral.issue}`);
+}
+function unreadable_message(issue) {
+  return `Issue ${session_cite.issue(issue)} could not be re-read to check its acceptance criteria, so the merge is refused; re-run once it can be.`;
+}
+async function body_refusal(issue, pr_body) {
+  const issue_read = await git_gh_command.issue_get_body_classified(issue);
+  if (issue_read.kind !== "read") return unreadable_message(issue);
+  const criteria = acceptance_map.criteria_of(issue_read.text);
+  const comparison = acceptance_map.compare(criteria, acceptance_map.rows_of(pr_body));
+  const absent = await absent_deferrals(comparison.deferrals);
+  if (comparison.missing.length === 0 && absent.length === 0) return void 0;
+  return acceptance_map.refusal_message(issue, comparison, absent);
+}
+async function refusal(issue, branch_name) {
+  return await body_refusal(issue, await git_gh_command.pr_get_body(branch_name));
+}
+var acceptance_map_check = { body_refusal, refusal };
+
+export {
+  acceptance_map_check
+};

package/dist/commands/chunk-CDYFUCDC.js

@@ -0,0 +1,72 @@
+import {
+  npm_registry,
+  release_age
+} from "./chunk-5GI5GLC4.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/version/version-remote.ts
+var TIMES_PAGE_SIZE = 100;
+var TIMES_JQ = "[.[] | {(.name): .created_at}] | add";
+function require_endpoint(versions_endpoint, package_name) {
+  if (versions_endpoint !== void 0 && versions_endpoint.trim() !== "") return versions_endpoint;
+  throw new Error(
+    `Could not derive a versions endpoint for ${package_name}; check its version-command config.`
+  );
+}
+function read_github_name(endpoint, package_name) {
+  try {
+    return git_gh_exec.exec_gh_api_sync({ path: endpoint, jq_filter: ".[0].name" }).trim();
+  } catch (error) {
+    const detail = error_text.message_of(error);
+    throw new Error(
+      `Failed to fetch latest version for ${package_name} via ${endpoint}: ${detail}`,
+      {
+        cause: error
+      }
+    );
+  }
+}
+function read_github_latest(endpoint, package_name) {
+  const name = read_github_name(endpoint, package_name);
+  const version = npm_registry.valid_version(name);
+  if (version !== void 0) return version;
+  throw new Error(
+    `Refused latest version for ${package_name} via ${endpoint}: ${JSON.stringify(name)} is not a semver version`
+  );
+}
+function fetch_latest_version(versions_endpoint, package_name) {
+  const endpoint = require_endpoint(versions_endpoint, package_name);
+  return npm_registry.read_latest(package_name) ?? read_github_latest(endpoint, package_name);
+}
+function with_page_size(endpoint, page_size) {
+  const separator = endpoint.indexOf("?");
+  const path_part = separator === -1 ? endpoint : endpoint.slice(0, separator);
+  const query = new URLSearchParams(separator === -1 ? "" : endpoint.slice(separator + 1));
+  query.set("per_page", String(page_size));
+  return `${path_part}?${query.toString()}`;
+}
+function read_github_release_times(versions_endpoint) {
+  const endpoint = with_page_size(versions_endpoint, TIMES_PAGE_SIZE);
+  const stdout = git_gh_exec.read_gh_api_sync({ path: endpoint, jq_filter: TIMES_JQ });
+  if (stdout === void 0) return void 0;
+  const parsed = release_age.release_times_schema.safeParse(json_value.parse_or_undefined(stdout));
+  return parsed.success ? parsed.data : void 0;
+}
+function fetch_release_times(versions_endpoint, package_name) {
+  if (versions_endpoint === void 0 || versions_endpoint.trim() === "") return void 0;
+  return npm_registry.read_release_times(package_name) ?? read_github_release_times(versions_endpoint);
+}
+
+export {
+  fetch_latest_version,
+  with_page_size,
+  fetch_release_times
+};

package/dist/commands/chunk-CEADAQIL.js

@@ -0,0 +1,170 @@
+import {
+  backlog_drive_unit
+} from "./chunk-2E6PSONB.js";
+import {
+  run_event_setup
+} from "./chunk-OKN63ZH5.js";
+import {
+  run_carry
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+import {
+  MS_PER_MINUTE
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/backlog/backlog-drive-retrospective-unit.ts
+function brief_of(owner) {
+  return [
+    "Run the backlogrun retrospective as the run parent would: `pnpm josh doc:read retrospective.md`;",
+    "its digest is `pnpm josh retrospective`.",
+    `Close with \`pnpm josh run:carry --retrospective --summary "<result>" --owner ${owner}\`:`,
+    "the run record is held by that process, not this session.",
+    "Nobody answers this session: a question for a person ends it, written as the final message."
+  ].join(" ");
+}
+var LOG_LABEL = "retrospective";
+function request_of(ports, git_directory, owner) {
+  const log = backlog_drive_unit.log_path(git_directory, LOG_LABEL, ports.now());
+  return backlog_drive_unit.request_of(brief_of(owner), ports, log);
+}
+function production_ports() {
+  return {
+    repository_directory: run_carry.repository_directory,
+    emit: run_event_setup.emit,
+    launch_attached: backlog_drive_unit.launch_attached,
+    is_marked: (git_directory) => run_carry.retrospective_done_of(run_carry.read_carry(run_carry.carry_path(git_directory))),
+    environment: process.env,
+    cwd: process.cwd(),
+    now: () => Date.now()
+  };
+}
+async function run(owner, ports = production_ports()) {
+  const git_directory = await ports.repository_directory();
+  if (git_directory === void 0) return false;
+  const request = request_of(ports, git_directory, owner);
+  if (request === void 0) return false;
+  await ports.emit(run_event_setup.STAGE.RETROSPECTIVE);
+  await ports.launch_attached(request);
+  return ports.is_marked(git_directory);
+}
+var backlog_drive_retrospective_unit = { brief_of, run };
+
+// scripts/backlog/backlog-drive-args.ts
+var LIST_SEPARATOR = ",";
+var USAGE = "Usage: josh backlog:drive [--owner <pid>] [--active <ISO-8601>] [--max <n>] [--idle <minutes>] [--only] [--exclude <n>[,<n>...]] [--await <n>[,<n>...]] [--window <minutes>] [--stopped <n>]";
+var OPTIONS = {
+  active: { type: "string" },
+  await: { type: "string" },
+  exclude: { type: "string" },
+  idle: { type: "string" },
+  max: { type: "string" },
+  only: { type: "boolean" },
+  owner: { type: "string" },
+  stopped: { type: "string" },
+  "triage-owed": { type: "boolean" },
+  "triage-pid": { type: "string" },
+  "triage-start": { type: "string" },
+  window: { type: "string" }
+};
+var START_SPACE = " ";
+var START_SPACE_TOKEN = "_";
+function beside_session(values) {
+  const pid = cli_flags.to_count(values["triage-pid"]);
+  if (pid === void 0) return {};
+  const start = values["triage-start"]?.split(START_SPACE_TOKEN).join(START_SPACE);
+  return start === void 0 ? { triage_pid: pid } : { triage_pid: pid, triage_start: start };
+}
+function triage_flags(values) {
+  const owed = values["triage-owed"] === true ? { is_triage_owed: true } : {};
+  return { ...owed, ...beside_session(values) };
+}
+function read_values(argv) {
+  return cli_flags.parse_or_undefined({ args: [...argv], options: OPTIONS, strict: true })?.values;
+}
+function to_issues(raw) {
+  if (raw === void 0) return [];
+  const issues = raw.split(LIST_SEPARATOR);
+  return issues.some((issue) => !issue_number_shape.is_issue_number(issue)) ? void 0 : issues;
+}
+function forwarded_of(values) {
+  const pairs = ["max", "idle"].filter((name) => values[name] !== void 0);
+  if (pairs.some((name) => cli_flags.to_count(values[name]) === void 0)) return void 0;
+  return pairs.flatMap((name) => [`--${name}`, values[name] ?? ""]);
+}
+function window_of(raw) {
+  return raw === void 0 ? void 0 : Number(raw) * MS_PER_MINUTE;
+}
+function is_count_or_absent(raw) {
+  return raw === void 0 || cli_flags.to_count(raw) !== void 0;
+}
+function is_valid_single(values) {
+  const is_valid_stopped = values.stopped === void 0 || issue_number_shape.ISSUE_NUMBER_PATTERN.test(values.stopped);
+  const is_valid_counts = is_count_or_absent(values.window) && is_count_or_absent(values["triage-pid"]);
+  return is_valid_stopped && is_valid_counts;
+}
+function owner_of(values) {
+  const owner = values?.owner ?? agent_session_environment.own_session_pid()?.toString();
+  return cli_flags.to_count(owner) === void 0 ? void 0 : owner;
+}
+function to_context(values, owner) {
+  if (!is_valid_single(values)) return void 0;
+  const forwarded = forwarded_of(values);
+  const exclude = to_issues(values.exclude);
+  const awaited = to_issues(values.await);
+  if (forwarded === void 0 || exclude === void 0 || awaited === void 0) return void 0;
+  const window_ms = window_of(values.window);
+  return {
+    owner,
+    active: values.active,
+    forwarded,
+    exclude,
+    awaited,
+    window_ms,
+    window: values.window,
+    is_only: values.only === true,
+    stopped: values.stopped,
+    ...triage_flags(values)
+  };
+}
+function parse(argv) {
+  const values = read_values(argv);
+  const owner = owner_of(values);
+  return values === void 0 || owner === void 0 ? void 0 : to_context(values, owner);
+}
+function beside_flags(pid, start) {
+  if (pid === void 0) return [];
+  const named = ["--triage-pid", String(pid)];
+  if (start === void 0) return named;
+  return [...named, "--triage-start", start.split(START_SPACE).join(START_SPACE_TOKEN)];
+}
+function triage_line_flags(state) {
+  const owed = state.is_triage_owed === true ? ["--triage-owed"] : [];
+  return [...owed, ...beside_flags(state.triage_pid, state.triage_start)];
+}
+function resume_line(state, context) {
+  const exclude = [.../* @__PURE__ */ new Set([...context.exclude, ...state.exclude])];
+  const flags = ["--owner", context.owner, "--active", state.active, ...context.forwarded];
+  if (exclude.length > 0) flags.push("--exclude", exclude.join(LIST_SEPARATOR));
+  if (context.window !== void 0) flags.push("--window", context.window);
+  if (state.stopped_by !== void 0) flags.push("--stopped", state.stopped_by);
+  return `resume: ${[...flags, ...triage_line_flags(state)].join(" ")}`;
+}
+var backlog_drive_args = {
+  USAGE,
+  beside_flags,
+  parse,
+  resume_line
+};
+
+export {
+  backlog_drive_retrospective_unit,
+  backlog_drive_args
+};

package/dist/commands/chunk-CNL3SLM6.js

@@ -0,0 +1,116 @@
+import {
+  lane_implement_stats
+} from "./chunk-A3JYZWBS.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  delegation_policy
+} from "./chunk-6I2JM5UX.js";
+import {
+  run_event_scope
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/lane/lane-implement-signals.ts
+import path from "node:path";
+var LABEL = "signals";
+var KIND = run_event_stream.EVENT_KIND.LANE_PHASE;
+var PAIR_SEPARATOR = "=";
+var WORD_SEPARATOR = " ";
+var LABEL_INDEX = 1;
+var FIELDS = {
+  edits: "edits",
+  test_related: "test-related",
+  lint_related: "lint-related",
+  investigations: "investigations",
+  unplanned: "unplanned"
+};
+var OUTSIDE_PREFIXES = ["..", ".josh/"];
+var TEST_RELATED = /(?:^|[;&|(]\s*)(?:pnpm )?josh test:related(?![\w:-])/u;
+var LINT_RELATED = /(?:^|[;&|(]\s*)(?:pnpm )?josh lint:related(?![\w:-])/u;
+var EDIT_BAR = 8;
+var RERUN_BAR = 2;
+var INVESTIGATION_BAR = 1;
+var FIELD_ORDER = [
+  "edits",
+  "test_related",
+  "lint_related",
+  "investigations",
+  "unplanned"
+];
+var KEYS = [
+  { field: "unplanned", bar: 0, key: "plan divergence" },
+  { field: "edits", bar: EDIT_BAR, key: "edited files" },
+  { field: "test_related", bar: RERUN_BAR, key: "test:related reruns" },
+  { field: "lint_related", bar: RERUN_BAR, key: "lint:related reruns" },
+  { field: "investigations", bar: INVESTIGATION_BAR, key: "investigation units" }
+];
+function edited_files(calls, root) {
+  const files = calls.filter((call) => lane_implement_stats.EDIT_TOOLS.has(call.tool ?? "")).map((call) => call.file_path).filter((file) => file !== void 0).map((file) => path.relative(root, file));
+  return [...new Set(files)].filter(
+    (file) => OUTSIDE_PREFIXES.every((prefix) => !file.startsWith(prefix))
+  );
+}
+function command_count(calls, pattern) {
+  return calls.filter((call) => pattern.test(call.command ?? "")).length;
+}
+function is_investigator(call) {
+  return call.subagent?.type.split(":").at(-1) === delegation_policy.INVESTIGATOR_AGENT;
+}
+function counts_of(calls, planned, root) {
+  const edits = edited_files(calls, root);
+  const plan = new Set(planned);
+  const outside = edits.filter((file) => !plan.has(file) && !test_declared_logic.is_test_file(file));
+  return {
+    edits: edits.length,
+    test_related: command_count(calls, TEST_RELATED),
+    lint_related: command_count(calls, LINT_RELATED),
+    investigations: calls.filter((call) => is_investigator(call)).length,
+    unplanned: outside.length
+  };
+}
+function text_of(issue, signals) {
+  const pairs = FIELD_ORDER.map(
+    (field) => `${FIELDS[field]}${PAIR_SEPARATOR}${String(signals[field])}`
+  );
+  return [issue_cite.plain_for("program", issue), LABEL, ...pairs].join(WORD_SEPARATOR);
+}
+function is_signals_of(event, issue) {
+  const label = event.text.split(WORD_SEPARATOR)[LABEL_INDEX];
+  return event.kind === KIND && label === LABEL && run_event_scope.issue_named(event) === String(issue);
+}
+function pair_of(word) {
+  const [name = "", value = ""] = word.split(PAIR_SEPARATOR);
+  return [name, value];
+}
+function parse(text) {
+  const pairs = new Map(text.split(WORD_SEPARATOR).map((word) => pair_of(word)));
+  function read(field) {
+    return Number(pairs.get(FIELDS[field]) ?? 0);
+  }
+  return {
+    edits: read("edits"),
+    test_related: read("test_related"),
+    lint_related: read("lint_related"),
+    investigations: read("investigations"),
+    unplanned: read("unplanned")
+  };
+}
+function signals_of(events, issue) {
+  const event = events.findLast((candidate) => is_signals_of(candidate, issue));
+  return event === void 0 ? void 0 : parse(event.text);
+}
+function keys_of(signals) {
+  return KEYS.filter(({ field, bar }) => signals[field] > bar).map(({ key }) => key);
+}
+var lane_implement_signals = { KIND, counts_of, is_signals_of, keys_of, signals_of, text_of };
+
+export {
+  lane_implement_signals
+};

package/dist/commands/chunk-CNQ7D2GZ.js

@@ -0,0 +1,104 @@
+import {
+  git_worktree
+} from "./chunk-WNBJK6QE.js";
+import {
+  IGNORED_CACHE_FILES
+} from "./chunk-TBIX5FRN.js";
+import {
+  ENV_FILE_NAME
+} from "./chunk-IGD6QJPH.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/git/git-remote-branch.ts
+async function ask(branch_name) {
+  try {
+    const heads = await git_worktree.ls_remote_branch(branch_name);
+    return heads.trim() === "" ? "absent" : "present";
+  } catch {
+    return "unreachable";
+  }
+}
+var git_remote_branch = {
+  ask
+};
+
+// scripts/lane/lane-leftover.ts
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync, rmSync } from "node:fs";
+import path from "node:path";
+var REGENERATED_PATHS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ENV_FILE_NAME,
+  ...IGNORED_CACHE_FILES
+]);
+var GIT_POINTER = ".git";
+var GITDIR_PREFIX = "gitdir: ";
+var NAMED_PATH_LIMIT = 10;
+function parse_objects(listing) {
+  return new Set(listing.split("\n").map((line) => line.split(" ", 1)[0] ?? ""));
+}
+async function recoverable_objects() {
+  return parse_objects(await git_spawn.read(["rev-list", "--objects", "--all"]));
+}
+function blob_id(file) {
+  const content = lstatSync(file).isSymbolicLink() ? Buffer.from(readlinkSync(file)) : readFileSync(file);
+  return createHash("sha1").update(`blob ${String(content.length)}\0`).update(content).digest("hex");
+}
+function walk_files(directory, relative) {
+  return readdirSync(path.join(directory, relative), { withFileTypes: true }).flatMap((entry) => {
+    const child = relative === "" ? entry.name : `${relative}/${entry.name}`;
+    return entry.isDirectory() ? walk_files(directory, child) : child;
+  });
+}
+function list_files(directory) {
+  return readdirSync(directory).filter((name) => !REGENERATED_PATHS.has(name)).flatMap(
+    (name) => lstatSync(path.join(directory, name)).isDirectory() ? walk_files(directory, name) : name
+  );
+}
+function is_dangling_pointer(directory) {
+  const file = path.join(directory, GIT_POINTER);
+  if (!lstatSync(file).isFile()) return false;
+  const pointer = readFileSync(file, "utf8").trim();
+  if (!pointer.startsWith(GITDIR_PREFIX)) return false;
+  return !existsSync(path.resolve(directory, pointer.slice(GITDIR_PREFIX.length)));
+}
+function is_reclaimable_file(directory, relative, recoverable) {
+  if (relative === GIT_POINTER) return is_dangling_pointer(directory);
+  return recoverable.has(blob_id(path.join(directory, relative)));
+}
+function foreign_paths(directory, recoverable) {
+  const pointer = lstatSync(path.join(directory, GIT_POINTER), { throwIfNoEntry: false });
+  if (pointer?.isDirectory() === true) return [GIT_POINTER];
+  return list_files(directory).filter(
+    (relative) => !is_reclaimable_file(directory, relative, recoverable)
+  );
+}
+function refusal(directory, foreign) {
+  const named = foreign.slice(0, NAMED_PATH_LIMIT).join(", ");
+  const rest = foreign.length - NAMED_PATH_LIMIT;
+  const more = rest > 0 ? ` and ${String(rest)} more` : "";
+  return new Error(
+    `${directory} already exists but git does not register it as a work tree, and it holds files the repository does not: ${named}${more}. It was left in place so nothing is lost \u2014 move those files out, delete the directory, and open the lane again.`
+  );
+}
+async function reclaim(directory) {
+  if (!existsSync(directory)) return;
+  const foreign = foreign_paths(directory, await recoverable_objects());
+  if (foreign.length > 0) throw refusal(directory, foreign);
+  rmSync(directory, { force: true, recursive: true });
+}
+var lane_leftover = {
+  blob_id,
+  foreign_paths,
+  parse_objects,
+  reclaim,
+  recoverable_objects
+};
+
+export {
+  git_remote_branch,
+  lane_leftover
+};

package/dist/commands/chunk-CTXJVMHW.js

@@ -0,0 +1,48 @@
+import {
+  repo_party
+} from "./chunk-DKDWOE3C.js";
+import {
+  gh_rate_limit
+} from "./chunk-LX2ENXHZ.js";
+import {
+  git_gh_etag_read
+} from "./chunk-IPS7EBE5.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  parse_json
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/gh/git-gh-repo.ts
+import { z } from "zod";
+var repository_schema = z.object({ full_name: z.string() });
+function local_name_with_owner() {
+  const identity = repo_party.current_repository();
+  return identity === void 0 ? void 0 : `${identity.owner}/${identity.repo}`;
+}
+async function repo_get_canonical_name_with_owner() {
+  try {
+    const body = await git_gh_etag_read.read(git_gh_api_path.repo_api_path());
+    const name = parse_json.parse_json_object_or_undefined(body, repository_schema)?.full_name.trim();
+    return name === "" ? void 0 : name;
+  } catch (error) {
+    if (gh_rate_limit.is_exhausted(error_text.message_of(error))) throw error;
+    error_text.trace_swallowed("git_gh_repo.repo_get_name_with_owner", error);
+    return void 0;
+  }
+}
+async function repo_get_name_with_owner() {
+  return local_name_with_owner() ?? await repo_get_canonical_name_with_owner();
+}
+var git_gh_repo = {
+  repo_get_canonical_name_with_owner,
+  repo_get_name_with_owner
+};
+
+export {
+  git_gh_repo
+};

package/dist/commands/chunk-CUWT6UQO.js

@@ -0,0 +1,13 @@
+import {
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+
+// scripts/hooks/hook-context.ts
+function from_process() {
+  return { cwd: process.cwd(), env: process.env, ancestry: lane_reap.own_ancestry };
+}
+var hook_context = { from_process };
+
+export {
+  hook_context
+};

package/dist/commands/chunk-CVRDJCOE.js

@@ -0,0 +1,125 @@
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  LANE_SEAT_KEY,
+  PORT_SEED_KEY,
+  ports
+} from "./chunk-IGD6QJPH.js";
+
+// scripts/lane/lane-environment.ts
+var LANE_OUTPUT_KEY = "JOSH_LANE_OUTPUT";
+var LANE_PROVIDER_KEY = "JOSH_LANE_AGENT_PROVIDER";
+var LANE_ROLE_KEY = "JOSH_LANE_AGENT_ROLE";
+var LANE_MODEL_KEY = "JOSH_LANE_AGENT_MODEL";
+var LANE_EFFORT_KEY = "JOSH_LANE_AGENT_EFFORT";
+var ASSIGNMENT_SEPARATOR = "=";
+var EXPORT_PREFIX = "export ";
+var QUOTE_CHARACTERS = /* @__PURE__ */ new Set(['"', "'"]);
+var MIN_QUOTED_LENGTH = 2;
+var FIRST_CHARACTER_END = 1;
+var LAST_CHARACTER_START = -1;
+function strip_export(line) {
+  const trimmed = line.trimStart();
+  return trimmed.startsWith(EXPORT_PREFIX) ? trimmed.slice(EXPORT_PREFIX.length).trimStart() : trimmed;
+}
+function is_key_line(line, key) {
+  const body = strip_export(line);
+  if (!body.startsWith(key)) return false;
+  return body.slice(key.length).trimStart().startsWith(ASSIGNMENT_SEPARATOR);
+}
+function is_seat_line(line) {
+  return is_key_line(line, LANE_SEAT_KEY);
+}
+function is_output_line(line) {
+  return is_key_line(line, LANE_OUTPUT_KEY);
+}
+function split_lines(content) {
+  const trimmed = content.trimEnd();
+  return trimmed.length === 0 ? [] : trimmed.split("\n");
+}
+function is_quoted(raw) {
+  const first = raw.slice(0, FIRST_CHARACTER_END);
+  if (!QUOTE_CHARACTERS.has(first)) return false;
+  return raw.length >= MIN_QUOTED_LENGTH && raw.endsWith(first);
+}
+function unquote(raw) {
+  return is_quoted(raw) ? raw.slice(FIRST_CHARACTER_END, LAST_CHARACTER_START) : raw;
+}
+function assignment_value(line) {
+  return unquote(line.slice(line.indexOf(ASSIGNMENT_SEPARATOR) + FIRST_CHARACTER_END).trim());
+}
+function read_assignment(content, key) {
+  const line = split_lines(content).findLast((entry) => is_key_line(entry, key));
+  return line === void 0 ? void 0 : assignment_value(line);
+}
+function read_root_seed(content) {
+  return ports.resolve_seed({ [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY) });
+}
+function read_lane_seat(content) {
+  const raw = read_assignment(content, LANE_SEAT_KEY);
+  return raw === void 0 ? void 0 : ports.resolve_lane({ [LANE_SEAT_KEY]: raw });
+}
+function read_lane_ports(content) {
+  const environment = {
+    [PORT_SEED_KEY]: read_assignment(content, PORT_SEED_KEY),
+    [LANE_SEAT_KEY]: read_assignment(content, LANE_SEAT_KEY)
+  };
+  return {
+    development: ports.resolve_development_port(environment),
+    preview: ports.resolve_preview_port(environment)
+  };
+}
+function read_lane_output(content) {
+  const line = split_lines(content).findLast((entry) => is_output_line(entry));
+  const raw = line === void 0 ? void 0 : assignment_value(line);
+  return raw === void 0 || raw.length === 0 ? void 0 : raw;
+}
+function read_lane_profile(content) {
+  return agent_profile_schema.parse({
+    provider: read_assignment(content, LANE_PROVIDER_KEY),
+    role: read_assignment(content, LANE_ROLE_KEY),
+    model: read_assignment(content, LANE_MODEL_KEY),
+    effort: read_assignment(content, LANE_EFFORT_KEY)
+  });
+}
+function replace_assignment(lines, keep, assignment, key) {
+  return lines.flatMap((entry, index) => {
+    if (index === keep) return [assignment];
+    if (is_key_line(entry, key)) return [];
+    return [entry];
+  });
+}
+function upsert_assignment(content, key, value) {
+  const assignment = `${key}${ASSIGNMENT_SEPARATOR}${value}`;
+  const lines = split_lines(content);
+  const last = lines.findLastIndex((entry) => is_key_line(entry, key));
+  const body = last === -1 ? [...lines, assignment] : replace_assignment(lines, last, assignment, key);
+  return `${body.join("\n")}
+`;
+}
+function lane_file_content(root_content, seat) {
+  return upsert_assignment(root_content, LANE_SEAT_KEY, String(seat));
+}
+function with_lane_output(content, output, profile) {
+  const recorded = upsert_assignment(content, LANE_OUTPUT_KEY, `"${output}"`);
+  if (profile === void 0) return recorded;
+  const with_provider = upsert_assignment(recorded, LANE_PROVIDER_KEY, profile.provider);
+  const with_role = upsert_assignment(with_provider, LANE_ROLE_KEY, profile.role);
+  const with_model = upsert_assignment(with_role, LANE_MODEL_KEY, profile.model);
+  return upsert_assignment(with_model, LANE_EFFORT_KEY, profile.effort);
+}
+var lane_environment = {
+  is_seat_line,
+  lane_file_content,
+  read_lane_output,
+  read_lane_profile,
+  read_lane_ports,
+  read_lane_seat,
+  read_root_seed,
+  with_lane_output
+};
+
+export {
+  lane_environment
+};