@joshuafolkken/kit 1.3000.0 → 1.3041.0

package/dist/hooks/pretool-guard.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env tsx
 import {
   pretool_guard
-} from "./chunk-UU4PTPEZ.js";
-import "./chunk-6RR6JZSB.js";
-import "./chunk-LKQBEKBI.js";
+} from "./chunk-HHIVWGHX.js";
+import "./chunk-OV22V63P.js";
+import "./chunk-6RLY27FT.js";
+import "./chunk-AO4TOV4V.js";
+import "./chunk-SXABK6UV.js";
+import "./chunk-5CUXGQT6.js";
 import {
   hook_decision
-} from "./chunk-CICKRHTB.js";
-import "./chunk-RQXECHAS.js";
-import "./chunk-LWD43Z3C.js";
-import "./chunk-NUPVO7RI.js";
+} from "./chunk-G5WSPYJ6.js";
 import "./chunk-YEURBB4L.js";
 import "./chunk-LRD2ERRI.js";
 import "./chunk-FOW4B7OQ.js";

package/dist/hooks/session-lang.js

@@ -1,27 +1,33 @@
 #!/usr/bin/env tsx
 import {
+  agent_phase_profile,
   agent_role_profile,
   consultation_handoff
-} from "./chunk-RQXECHAS.js";
+} from "./chunk-SXABK6UV.js";
 import {
+  RUN_STALLED_LABEL,
   detached_launch,
   distributed_paths,
   document_section,
+  git_gh_issue_write,
   lane_child_marker,
   require_semver,
+  run_cut,
   run_headless
-} from "./chunk-LWD43Z3C.js";
+} from "./chunk-5CUXGQT6.js";
 import {
   agent_profile_schema,
   agent_session_role,
   find_package_directory,
   issue_cite,
   josh_environment_file,
+  package_manifest,
   run_event_stream,
   run_event_stream_emit,
+  session_cite,
   session_language,
   transcript_tail
-} from "./chunk-NUPVO7RI.js";
+} from "./chunk-G5WSPYJ6.js";
 import {
   session_model_record
 } from "./chunk-SAAPRHTK.js";
@@ -32,6 +38,7 @@ import {
 import {
   agent_provider,
   agent_session_environment,
+  cli_flags,
   durable_state,
   file_reader,
   issue_number_shape,
@@ -131,6 +138,100 @@ function check(profile, ports = default_ports) {
 }
 var agent_diagnostics = { check };
 
+// scripts/agent/agent-ship-cap.ts
+function has_phase_model(profile, phase) {
+  return agent_phase_profile.phase_model(profile.role, profile.provider, phase, {}) !== void 0;
+}
+function weaker(profile, resolved) {
+  const { worker, settings } = resolved;
+  const rank = settings.profiles.findIndex((entry) => entry.agent.model === profile.model);
+  const limit = settings.profiles.findIndex((entry) => entry.name === worker.name);
+  return rank <= limit ? profile : { ...profile, model: worker.agent.model };
+}
+function capped_by(profile, result) {
+  if (result.kind === "unset") return { kind: "profile", profile };
+  return result.kind === "rejected" ? result : { kind: "profile", profile: weaker(profile, result) };
+}
+async function capped(resolved, phase, worker) {
+  if (resolved.kind === "rejected" || !has_phase_model(resolved.profile, phase)) return resolved;
+  return capped_by(resolved.profile, await worker());
+}
+var agent_ship_cap = { capped };
+
+// scripts/agent/agent-worker-profile.ts
+var { EFFORT_SCHEMA, PROFILE_SCHEMA, WORKER } = agent_profile_schema;
+var CONFIG_KEY = "josh.worker";
+var LABEL_PREFIX = "worker:";
+var UNSET = { kind: "unset" };
+function rejected2(note) {
+  return { kind: "rejected", note: `${CONFIG_KEY} ${note}` };
+}
+function schema_rejection(error) {
+  const [issue] = error.issues;
+  if (issue === void 0) return rejected2("is invalid");
+  return { kind: "rejected", note: `${issue.path.join(".")}: ${issue.message}` };
+}
+function checked_profile(definition) {
+  const { name, model, effort, when } = definition;
+  const parsed = PROFILE_SCHEMA.safeParse({ role: WORKER, model, effort });
+  if (!parsed.success) {
+    return rejected2(
+      `profile ${name}: effort ${effort} is not one of ${EFFORT_SCHEMA.options.join(", ")}`
+    );
+  }
+  const checked = agent_role_profile.validate(parsed.data, `${CONFIG_KEY} profile ${name} model`);
+  return checked.kind === "rejected" ? checked : { kind: "profile", worker: { name, when, agent: checked.profile } };
+}
+function checked_settings(config) {
+  const profiles = [];
+  for (const definition of config.profiles) {
+    const checked = checked_profile(definition);
+    if (checked.kind === "rejected") return checked;
+    profiles.push(checked.worker);
+  }
+  return {
+    kind: "settings",
+    settings: { default: config.default, escalate: config.escalate, profiles }
+  };
+}
+function manifest_value(directory) {
+  const text = file_reader.read_if_readable(package_manifest.manifest_path(directory));
+  if (text === void 0) return {};
+  return json_value.parse_or_undefined(text) ?? {};
+}
+function read(directory) {
+  const parsed = package_manifest.josh_schemas.worker.safeParse(manifest_value(directory));
+  if (!parsed.success) return schema_rejection(parsed.error);
+  const config = parsed.data.josh?.worker;
+  return config === void 0 ? UNSET : checked_settings(config);
+}
+function profile_named(settings, name) {
+  return settings.profiles.find((profile) => profile.name === name);
+}
+function for_labels(settings, labels) {
+  const names = labels.filter((label) => label.startsWith(LABEL_PREFIX)).map((label) => label.slice(LABEL_PREFIX.length));
+  if (names.length > 1) {
+    return rejected2(`allows one ${LABEL_PREFIX}<name> label, got ${names.join(", ")}`);
+  }
+  const [name = settings.default] = names;
+  const worker = profile_named(settings, name);
+  if (worker === void 0) return rejected2(`has no profile for the label ${LABEL_PREFIX}${name}`);
+  return { kind: "worker", worker, settings };
+}
+async function resolve(directory, fetch_labels) {
+  const result = read(directory);
+  if (result.kind !== "settings") return result;
+  const labels = await fetch_labels();
+  if (labels === void 0) return rejected2("could not read the Issue labels");
+  return for_labels(result.settings, labels);
+}
+function next(settings, worker) {
+  const index = settings.profiles.findIndex((profile) => profile.name === worker.name);
+  if (index === -1) return void 0;
+  return settings.profiles[index + 1];
+}
+var agent_worker_profile = { LABEL_PREFIX, for_labels, next, read, resolve };
+
 // scripts/agent/claude-agent-argv.ts
 import { existsSync } from "node:fs";
 import path2 from "node:path";
@@ -166,6 +267,164 @@ var cost_tokens = {
   ascii_bytes_to_tokens
 };
 
+// scripts/run/park/run-stalled.ts
+var SESSION_UNFINISHED = {
+  short: "session unfinished",
+  why: "the child\u2019s session ended with its issue still open and unfinished."
+};
+var CUT_NOT_RELAUNCHED = {
+  short: "cut not relaunched",
+  why: "its lane held a declared cut, but no successor could be relaunched from it (or it already was once)."
+};
+var STALE_HANDOFF = {
+  short: "stale hand-off",
+  why: "the child stopped at `resume: handed-off` because an old hand-off cut record was already adopted."
+};
+var RESUME_COMMAND = "fullrun";
+var CAUSE_LEAD = `${RUN_STALLED_LABEL}: `;
+function resume_of(child, is_backlog_live = false) {
+  return is_backlog_live ? `pnpm josh run:add ${String(child)} --retry` : `${RESUME_COMMAND} ${issue_cite.plain_for("program", child)}`;
+}
+function recovery_of(cause) {
+  if (cause === STALE_HANDOFF.why) {
+    return `repair the stale hand-off cut record with \`${run_cut.END_COMMAND}\` (retry alone does not clear it)`;
+  }
+  return /cut.*(?:handed-off|already handed off)/iu.test(cause) ? `clear the handed-off cut with \`${run_cut.END_COMMAND}\`` : "fix the cause";
+}
+function next_step(child, cause = "") {
+  const recovery = recovery_of(cause);
+  return `${recovery}, then use \`${resume_of(child, true)}\` in the live backlogrun or resume it with \`${resume_of(child, false)}\``;
+}
+var ESCALATION_REQUESTED = {
+  short: "escalation requested",
+  why: "the worker declared that its Issue needs a stronger josh.worker profile."
+};
+var CARRYING_CLASSES = [SESSION_UNFINISHED, ESCALATION_REQUESTED];
+function lead_of(cause) {
+  return `${cause.short}: `;
+}
+function carrying(cause, message) {
+  const first = message.split(/\r?\n/u, 1)[0]?.trim() ?? "";
+  return first === "" ? cause : { short: `${lead_of(cause)}${first}`, why: first };
+}
+function session_unfinished(message) {
+  return carrying(SESSION_UNFINISHED, message);
+}
+function escalation_requested(reason) {
+  return carrying(ESCALATION_REQUESTED, reason);
+}
+function class_of(cause) {
+  const carried = CARRYING_CLASSES.find((known) => cause.startsWith(lead_of(known)));
+  return carried?.short ?? cause;
+}
+function park_event(child, cause) {
+  return `${issue_cite.plain_for("program", child)} parked (${CAUSE_LEAD}${cause})`;
+}
+function cause_of(reason) {
+  if (reason === RUN_STALLED_LABEL) return "";
+  return reason.startsWith(CAUSE_LEAD) ? reason.slice(CAUSE_LEAD.length) : void 0;
+}
+function cause_in(text) {
+  const lead = ` parked (${CAUSE_LEAD}`;
+  const start2 = text.indexOf(lead);
+  return start2 === -1 || !text.endsWith(")") ? void 0 : text.slice(start2 + lead.length, -1);
+}
+function stop_of(event) {
+  return event.stop;
+}
+function row_text(child, cause = "", is_backlog_live = false) {
+  const resume = `\u2192 resume: ${resume_of(child, is_backlog_live)}`;
+  return cause === "" ? resume : `${resume} (${cause})`;
+}
+function waiting_text(waits) {
+  return `waiting on ${waits.map((wait) => wait.includes("#") ? wait : issue_cite.plain_for("program", wait)).join(", ")}`;
+}
+var run_stalled = {
+  CUT_NOT_RELAUNCHED,
+  ESCALATION_REQUESTED,
+  SESSION_UNFINISHED,
+  STALE_HANDOFF,
+  cause_in,
+  cause_of,
+  class_of,
+  escalation_requested,
+  next_step,
+  park_event,
+  resume_of,
+  row_text,
+  session_unfinished,
+  stop_of,
+  waiting_text
+};
+
+// scripts/issue/issue-park.ts
+async function apply(issue, label, body) {
+  const is_labelled = await git_gh_issue_write.issue_add_label(issue, label);
+  if (!is_labelled) return { is_labelled, is_commented: false };
+  const is_commented = await git_gh_issue_write.issue_try_comment(issue, body);
+  return { is_labelled, is_commented };
+}
+var issue_park = { apply };
+
+// scripts/run/park/run-stalled-park.ts
+var { PARK } = run_event_stream.EVENT_KIND;
+async function apply2(issue, comment, cause, fields = {}) {
+  const park_write = await issue_park.apply(issue, RUN_STALLED_LABEL, comment);
+  if (!park_write.is_labelled) return false;
+  await run_event_stream_emit.emit(PARK, run_stalled.park_event(issue, cause), /* @__PURE__ */ new Date(), fields);
+  return true;
+}
+var run_stalled_park = { apply: apply2 };
+
+// scripts/run/park/run-park-escalate.ts
+var ESCALATE_FLAG = "--escalate";
+var OPTIONS = { escalate: { type: "string" } };
+var DISABLED_NOTE = `run:park ${ESCALATE_FLAG}: refused \u2014 this repository's package.json does not set josh.worker.escalate to true.`;
+function is_requested(argv) {
+  return argv.some((token) => token === ESCALATE_FLAG || token.startsWith(`${ESCALATE_FLAG}=`));
+}
+function is_enabled(directory) {
+  const result = agent_worker_profile.read(directory);
+  return result.kind === "settings" && result.settings.escalate;
+}
+function reason_of(value) {
+  return value?.trim() ?? "";
+}
+function escalation_of(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue = issue_number_shape.single_of(parsed.positionals);
+  const reason = reason_of(parsed.values.escalate);
+  return issue === void 0 || reason === "" ? void 0 : { issue, reason };
+}
+function refusal_of(escalation, directory, usage) {
+  if (escalation === void 0) return usage;
+  return is_enabled(directory) ? void 0 : DISABLED_NOTE;
+}
+function accepted(argv, directory, usage) {
+  const escalation = escalation_of(argv);
+  const refusal = refusal_of(escalation, directory, usage);
+  if (refusal !== void 0) console.error(refusal);
+  return refusal === void 0 ? escalation : void 0;
+}
+function comment_of(escalation) {
+  const { issue, reason } = escalation;
+  return [
+    `Parked with \`${RUN_STALLED_LABEL}\`: ${run_stalled.ESCALATION_REQUESTED.why}`,
+    `- Reason: ${reason}`,
+    `- Next: the backlogrun drive resumes it one \`worker:<name>\` profile up, or hands it to a person at the top profile; without a drive, give it a stronger profile, ${run_stalled.next_step(issue)}.`
+  ].join("\n");
+}
+async function park(argv, directory, usage) {
+  const escalation = accepted(argv, directory, usage);
+  if (escalation === void 0) return void 0;
+  const { short } = run_stalled.escalation_requested(escalation.reason);
+  const is_parked = await run_stalled_park.apply(escalation.issue, comment_of(escalation), short);
+  console.info(`escalate ${session_cite.issue(escalation.issue)} \u2014 parked: ${String(is_parked)}`);
+  return is_parked ? escalation.issue : void 0;
+}
+var run_park_escalate = { ESCALATE_FLAG, is_enabled, is_requested, park };
+
 // scripts/agent/lane-instructions.ts
 var LANE_DOCUMENT = "prompts/collaboration-workflow/lane-instructions.md";
 var WORKFLOW_ENTRY = "fullrun-lane.md";
@@ -178,6 +437,12 @@ 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)));
+var ESCALATION_GUIDE = [
+  "",
+  "## Escalation",
+  "",
+  '- This Issue needs a stronger model than the one you run on \u2192 `pnpm josh run:park <N> --escalate "<reason>"`, then stop. The reason is required and recorded; the lane resumes one profile up, or goes to a person at the top profile.'
+].join("\n");
 function expand_line(line, rules) {
   const wanted = INCLUDE_PATTERN.exec(line)?.groups?.["wanted"];
   if (wanted === void 0) return line;
@@ -196,7 +461,7 @@ 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) {
+function rules_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)) {
@@ -205,6 +470,11 @@ function composed_set(cwd, package_directory) {
   }
   return void 0;
 }
+function composed_set(cwd, package_directory, is_worker = false) {
+  const set = rules_set(cwd, package_directory);
+  if (set === void 0 || !is_worker || !run_park_escalate.is_enabled(cwd)) return set;
+  return { ...set, text: `${set.text}${ESCALATION_GUIDE}` };
+}
 function composed_in(cwd, package_directory = PACKAGE_DIRECTORY) {
   return composed_set(cwd, package_directory)?.text;
 }
@@ -220,12 +490,14 @@ function written(text) {
 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);
+function flags_of(set, cwd) {
   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 flags(cwd = process.cwd(), is_worker = false) {
+  return flags_of(composed_set(cwd, PACKAGE_DIRECTORY, is_worker), cwd);
+}
 function tokens_of(text) {
   return cost_tokens.estimate(text).toLocaleString("en-US");
 }
@@ -298,7 +570,7 @@ function tool_flags(role, cwd = process.cwd()) {
 }
 function instruction_flags(profile, cwd) {
   if (profile.role === agent_role_profile.SCHEDULER) return [];
-  return lane_instructions.flags(cwd);
+  return lane_instructions.flags(cwd, profile.role === agent_role_profile.WORKER);
 }
 function build(invocation, profile, session_id, cwd) {
   return {
@@ -338,7 +610,7 @@ function build_resume(invocation, profile, session_id, cwd) {
 function with_profile(invocation, profile) {
   return { kind: "argv", argv: build(invocation, profile), profile };
 }
-function resolve(invocation, role, environment = process.env) {
+function resolve2(invocation, role, environment = process.env) {
   const result = agent_role_profile.resolve(role, environment);
   if (result.kind === "rejected") return result;
   return with_profile(invocation, result.profile);
@@ -349,7 +621,7 @@ var claude_agent_argv = {
   LAUNCHED_TOOLS,
   build,
   build_resume,
-  resolve
+  resolve: resolve2
 };
 
 // scripts/agent/codex-agent-argv.ts
@@ -426,16 +698,21 @@ function with_profile2(invocation, profile) {
   if (diagnostic.kind === "rejected") return diagnostic;
   return { kind: "argv", argv: build3(invocation, profile), profile };
 }
-function resolve2(invocation, role, environment = process.env) {
+function resolve3(invocation, role, environment = process.env) {
   const resolved = agent_role_profile.resolve(role, environment);
   return resolved.kind === "rejected" ? resolved : with_profile2(invocation, resolved.profile);
 }
 function profiled_in(invocation, resolved, cwd) {
   return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, cwd);
 }
-function resume_argv(invocation, profile, phase, cwd) {
+async function resume_argv(invocation, profile, phase, site) {
   const resolved = profile === void 0 ? agent_role_profile.resolve(agent_role_profile.WORKER, process.env, phase) : agent_role_profile.with_phase(profile, phase);
-  return profiled_in(invocation, resolved, cwd);
+  const capped2 = await agent_ship_cap.capped(
+    resolved,
+    phase,
+    async () => await agent_worker_profile.resolve(site.cwd, site.labels)
+  );
+  return profiled_in(invocation, capped2, site.cwd);
 }
 function resolve_in(invocation, role, cwd, environment = process.env) {
   return profiled_in(invocation, agent_role_profile.resolve(role, environment), cwd);
@@ -449,7 +726,7 @@ function review_in(invocation, round, cwd, environment = process.env) {
   );
 }
 var agent_argv = {
-  resolve: resolve2,
+  resolve: resolve3,
   resolve_in,
   review_in,
   resume_argv,
@@ -576,8 +853,8 @@ function is_launch_live(record) {
   if (record === void 0) return false;
   return process_identity.is_same_process(record.pid, record.start) !== false;
 }
-function is_carry_live(read) {
-  return read.kind === "carried" && run_carry.is_owner_live(read.carry);
+function is_carry_live(read2) {
+  return read2.kind === "carried" && run_carry.is_owner_live(read2.carry);
 }
 function is_running(git_directory) {
   if (is_carry_live(run_carry.read_carry(run_carry.carry_path(git_directory)))) return true;