@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/dist/commands/chunk-NHIW7JE6.js

@@ -0,0 +1,335 @@
+import {
+  run_ship_review,
+  run_ship_stop_cause
+} from "./chunk-MRORPFSO.js";
+import {
+  lane_relaunch
+} from "./chunk-AC26ZUG5.js";
+import {
+  api_auth
+} from "./chunk-NUR4FQHM.js";
+import {
+  lane_parked
+} from "./chunk-FWU3H4TX.js";
+import {
+  review_round
+} from "./chunk-EKLU6QR7.js";
+import {
+  review_attest
+} from "./chunk-KIILCKQR.js";
+import {
+  agent_argv
+} from "./chunk-NU7W6QGT.js";
+import {
+  review_prompt_level
+} from "./chunk-E33LSO2W.js";
+import {
+  agent_role_profile
+} from "./chunk-6UCWAFQY.js";
+import {
+  core_priority
+} from "./chunk-TCBUX52E.js";
+import {
+  detached_launch
+} from "./chunk-C2SEDMZ3.js";
+import {
+  lane_child_marker
+} from "./chunk-QAHFPCFR.js";
+import {
+  distributed_paths
+} from "./chunk-66TGK5XL.js";
+import {
+  agent_profile_schema
+} from "./chunk-EZSO25UZ.js";
+import {
+  lane_child_invocation,
+  run_ship_stop_context
+} from "./chunk-EW4NPUMQ.js";
+import {
+  run_ship_stage
+} from "./chunk-OHNP3QL2.js";
+import {
+  parse_json
+} from "./chunk-XDF25GSU.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  stamp_file
+} from "./chunk-QWWTC3XR.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/review/review-pair.ts
+var PAIRED_ENV = "JOSH_REVIEWER_PAIRED";
+var ENABLED_VALUE = "1";
+var BRIEF_PREFIX = "josh-review-paired-brief-";
+var FINDINGS_PREFIX = "josh-review-paired-findings-";
+var LOG_PREFIX = "josh-review-paired-log-";
+var PAIRED_PROFILE = agent_role_profile.VERIFICATION_PROFILES.anthropic;
+function is_enabled(environment = process.env) {
+  return environment[PAIRED_ENV] === ENABLED_VALUE;
+}
+function paths(directory = PROJECT_ROOT) {
+  return {
+    brief: stamp_file.stamp_path(BRIEF_PREFIX, directory, ".md"),
+    findings: stamp_file.stamp_path(FINDINGS_PREFIX, directory, ".txt"),
+    log: stamp_file.stamp_path(LOG_PREFIX, directory, ".log")
+  };
+}
+function paired_brief(text, findings) {
+  const [level = "", ...rest] = text.split("\n");
+  return [
+    level,
+    "",
+    "## Paired comparison run \u2014 recorded only, never gating",
+    "",
+    `This overrides every attest and submit step below and your agent definition: never run \`review:attest\` or \`review:submit\`. Write your findings to ${findings}, one per line as \`<category>:<severity>:<file>[:<line>] \u2014 <sentence>\`, or the single line \`none\`.`,
+    "",
+    ...rest
+  ].join("\n");
+}
+function paired_opening(brief) {
+  return [
+    `${review_prompt_level.opening(brief)}Review this checkout as a paired /code-review, recorded only: read the review brief at ${brief}`,
+    "and follow its first section over everything else \u2014 never run review:attest or review:submit.",
+    "Review it yourself in this session and never launch a second reviewer."
+  ].join(" ");
+}
+function launch_note(brief) {
+  const opening = paired_opening(brief);
+  return [
+    `paired brief: ${brief}`,
+    `paired model: ${PAIRED_PROFILE.model} \xB7 effort ${PAIRED_PROFILE.effort}`,
+    `paired prompt: ${opening}`,
+    "Paired comparison on: launch a third `reviewer` beside round 1 with the paired model and prompt; when both return, run `pnpm josh review:pair --issue <N> --opus-agent <id> --sonnet-agent <id>` before `review:record`. Its result never gates."
+  ].join("\n");
+}
+function offer(text, environment = process.env, directory = PROJECT_ROOT) {
+  const { brief, findings } = paths(directory);
+  stamp_file.remove_stamp(findings);
+  if (!is_enabled(environment) || review_round.from_brief(text) === "2") {
+    stamp_file.remove_stamp(brief);
+    return void 0;
+  }
+  stamp_file.write_text_stamp(brief, `${paired_brief(text, findings)}
+`);
+  return launch_note(brief);
+}
+function is_offered(directory = PROJECT_ROOT) {
+  return stamp_file.read_stamp_text(paths(directory).brief) !== void 0;
+}
+var review_pair = {
+  PAIRED_ENV,
+  PAIRED_PROFILE,
+  is_enabled,
+  is_offered,
+  offer,
+  opening: paired_opening,
+  paths
+};
+
+// scripts/lane/lane-session-action.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+// scripts/review/review-pair-session.ts
+import { z } from "zod";
+var PAIR_COMMAND = "review:pair";
+var OBJECT_OPENING = "{";
+var record_schema = z.looseObject({});
+var init_schema = z.object({
+  type: z.literal("system"),
+  subtype: z.literal("init"),
+  session_id: z.string().min(1)
+});
+function note(text) {
+  process.stderr.write(`paired reviewer: ${text}
+`);
+}
+function session_in(line) {
+  if (!line.startsWith(OBJECT_OPENING)) return void 0;
+  const record = parse_json.parse_json_object_or_undefined(line, record_schema);
+  return init_schema.safeParse(record).data?.session_id;
+}
+function session_of(log_path) {
+  const lines = stamp_file.read_stamp_text(log_path)?.split("\n") ?? [];
+  return lines.map((line) => session_in(line.trim())).findLast((id) => id !== void 0);
+}
+async function run(directory, environment) {
+  const { brief, log } = review_pair.paths(directory);
+  const opening = review_pair.opening(brief);
+  const built = agent_argv.with_profile_in(opening, review_pair.PAIRED_PROFILE, directory);
+  if (built.kind === "rejected") {
+    note(`not started \u2014 ${built.note}`);
+    return;
+  }
+  stamp_file.remove_stamp(log);
+  const request = {
+    argv: built.argv,
+    cwd: directory,
+    log_path: log,
+    profile: built.profile,
+    env: environment
+  };
+  const result = await detached_launch.launch_attached(request, note);
+  if (result.kind === "failed") note(`not started \u2014 ${result.note}`);
+}
+async function launch(directory, environment) {
+  if (!review_pair.is_offered(directory)) return;
+  try {
+    await run(directory, environment);
+  } catch (error) {
+    note(`failed \u2014 ${error_text.message_of(error)}`);
+  }
+}
+function pair_argv(issue, code_log, directory) {
+  if (!review_pair.is_offered(directory)) return void 0;
+  const opus = session_of(code_log);
+  const sonnet = session_of(review_pair.paths(directory).log);
+  if (opus === void 0 || sonnet === void 0) return void 0;
+  return [PAIR_COMMAND, "--issue", issue, "--opus-agent", opus, "--sonnet-agent", sonnet];
+}
+var review_pair_session = { launch, pair_argv, session_of };
+
+// scripts/lane/lane-session-action.ts
+import { z as z2 } from "zod";
+var BRIEF_PREFIX2 = "josh-ship-review-brief-";
+var FINDINGS_PREFIX2 = "josh-ship-review-findings-";
+var LOG_PREFIX2 = "josh-ship-review-log-";
+var SUBMIT_SCRIPT = "scripts/review/review-submit-cli.ts";
+var ANTHROPIC_PROVIDER = "anthropic";
+var stop_schema = z2.object({
+  stage: z2.enum(run_ship_stage.STAGE),
+  title: z2.string(),
+  flags: z2.array(z2.string()).readonly(),
+  is_review: z2.boolean(),
+  unpinned_ok: z2.array(z2.string()).readonly().exactOptional(),
+  conflicts: z2.array(z2.string()).readonly().default([]),
+  cause: z2.enum(run_ship_stop_cause.CAUSE).exactOptional(),
+  is_review_stale: z2.boolean().exactOptional(),
+  context: run_ship_stop_context.stop_context_schema.exactOptional()
+}).strict();
+var slots_schema = z2.array(z2.enum(review_attest.REVIEW_SLOTS)).readonly();
+var action_schema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("review"),
+    round: z2.enum(["1", "2"]),
+    slots: slots_schema.exactOptional()
+  }).strict(),
+  z2.object({ kind: z2.literal("relaunch"), stop: stop_schema }).strict()
+]);
+var request_schema = z2.object({ session: z2.uuid(), nonce: z2.uuid(), action: action_schema }).strict();
+var SUCCESS = { is_success: true };
+function failure(reason) {
+  return { is_success: false, reason };
+}
+function review_paths(directory, slot = review_attest.REVIEW_SLOT.CODE) {
+  const prefix = slot === review_attest.REVIEW_SLOT.CODE ? "" : "interaction-";
+  return {
+    brief: stamp_file.stamp_path(`${BRIEF_PREFIX2}${prefix}`, directory, ".md"),
+    findings: stamp_file.stamp_path(`${FINDINGS_PREFIX2}${prefix}`, directory, ".txt"),
+    log: stamp_file.stamp_path(`${LOG_PREFIX2}${prefix}`, directory, ".log")
+  };
+}
+function provider_of(lane) {
+  return lane.profile?.provider ?? ANTHROPIC_PROVIDER;
+}
+function action_slots(action) {
+  return action.slots ?? [review_attest.REVIEW_SLOT.CODE];
+}
+function has_submit(directory) {
+  return [SUBMIT_SCRIPT, `${distributed_paths.KIT_PACKAGE_PATH_PREFIX}${SUBMIT_SCRIPT}`].some(
+    (script) => existsSync(path.join(directory, script))
+  );
+}
+function review_prompt(lane, action, slot) {
+  const { brief, findings } = review_paths(lane.directory, slot);
+  const round_prompt = action.round === "1" ? run_ship_review.reviewer_prompt : run_ship_review.verification_prompt;
+  const prompt_of = run_ship_review.slot_prompt(round_prompt, slot, action_slots(action));
+  const tail = lane_child_invocation.review_invocation(lane.issue);
+  const findings_path = has_submit(lane.directory) ? void 0 : findings;
+  return `${prompt_of(brief, slot, lane.issue, findings_path)} This is ${tail}`;
+}
+function exited_answer(exit_code, log_path) {
+  const exited = `the reviewer exited with code ${String(exit_code)}`;
+  if (!api_auth.is_auth_failed_transcript(stamp_file.read_stamp_text(log_path))) {
+    return failure(exited);
+  }
+  return failure(`${api_auth.AUTH_FAILURE_NOTE}: ${exited}`);
+}
+function reviewer_answer(result, log_path) {
+  if (result.kind === "failed") return failure(`the reviewer could not start: ${result.note}`);
+  return result.exit_code === 0 ? SUCCESS : exited_answer(result.exit_code, log_path);
+}
+function reviewer_environment(lane) {
+  return { ...lane_child_marker.env_for(lane.issue), ...core_priority.PRIORITY_ENVIRONMENT };
+}
+async function launch_review(lane, action, slot) {
+  const target = review_paths(lane.directory, slot);
+  const prompt = review_prompt(lane, action, slot);
+  const built = agent_argv.review_in(prompt, Number(action.round), lane.directory);
+  if (built.kind === "rejected") return failure(`the reviewer profile was rejected: ${built.note}`);
+  if (built.profile.provider !== provider_of(lane)) {
+    return failure(`the reviewer resolved to ${built.profile.provider}, not the lane's provider`);
+  }
+  console.error(agent_profile_schema.describe_review(Number(action.round), built.profile));
+  const result = await detached_launch.launch_attached(
+    {
+      argv: built.argv,
+      cwd: lane.directory,
+      log_path: target.log,
+      profile: built.profile,
+      env: reviewer_environment(lane)
+    },
+    console.error
+  );
+  return reviewer_answer(result, target.log);
+}
+async function launch_pair(lane, action) {
+  if (action.round !== "1" || !action_slots(action).includes(review_attest.REVIEW_SLOT.CODE)) return;
+  await review_pair_session.launch(lane.directory, reviewer_environment(lane));
+}
+async function launch_reviews(lane, action) {
+  const [answers] = await Promise.all([
+    Promise.all(action_slots(action).map(async (slot) => await launch_review(lane, action, slot))),
+    launch_pair(lane, action)
+  ]);
+  return answers.find((reply) => !reply.is_success) ?? SUCCESS;
+}
+async function relaunch(lane, stop) {
+  if (lane_relaunch.is_openai_lane(lane)) {
+    return failure("an OpenAI lane is relaunched by its own supervisor");
+  }
+  const invocation = lane_child_invocation.ship_stop_invocation(lane.issue, stop);
+  const phase = agent_profile_schema.IMPLEMENTATION_PHASE;
+  const result = await lane_relaunch.relaunch(lane, invocation, phase, console.error);
+  return result.kind === "launched" ? SUCCESS : failure(`the relaunch did not start: ${result.note}`);
+}
+async function perform(lane, action) {
+  if (await lane_parked.is_parked(lane.issue)) return failure("the issue is parked");
+  if (action.kind === "relaunch") return await relaunch(lane, action.stop);
+  return await launch_reviews(lane, action);
+}
+async function answer(lane, action) {
+  try {
+    return await perform(lane, action);
+  } catch (error) {
+    return failure(`the broker failed: ${error_text.message_of(error)}`);
+  }
+}
+var lane_session_action = {
+  SUCCESS,
+  action_schema,
+  answer,
+  failure,
+  request_schema,
+  review_paths
+};
+
+export {
+  review_pair,
+  review_pair_session,
+  lane_session_action
+};

package/dist/commands/{chunk-CJSFC5YI.js → chunk-NILSN7A4.js}

@@ -1,21 +1,21 @@
 import {
   review_reviewed_tree
-} from "./chunk-Q3463XNL.js";
+} from "./chunk-GITT5A5A.js";
 import {
   review_record
-} from "./chunk-BCK5LW4F.js";
+} from "./chunk-JVKXJ763.js";
 import {
   issue_watch_gate
-} from "./chunk-D3SHCUBC.js";
+} from "./chunk-OVWPZDWP.js";
 import {
   run_preflight
-} from "./chunk-VD72V5VX.js";
-import {
-  run_hold
-} from "./chunk-P4CWLRT2.js";
+} from "./chunk-AJ65WNJB.js";
 import {
   git_worktree
 } from "./chunk-W3FX7FYN.js";
+import {
+  run_hold
+} from "./chunk-X3TNPALI.js";
 import {
   run_ship_stage
 } from "./chunk-OHNP3QL2.js";

package/dist/commands/{chunk-W4J6YTFE.js → chunk-NOLFSPOB.js}

@@ -1,9 +1,9 @@
 import {
   scoped_green
-} from "./chunk-BK6Q4VCA.js";
+} from "./chunk-WTH6NTXU.js";
 import {
   verification_inputs
-} from "./chunk-REMKUFAC.js";
+} from "./chunk-34KZDKQJ.js";
 import {
   input_fingerprint
 } from "./chunk-MGF64OHV.js";

package/dist/commands/chunk-NT67QTZO.js

@@ -0,0 +1,65 @@
+import {
+  observation_ledger_home
+} from "./chunk-WWVYEHQT.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-ledger-read.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var LEDGER_EXTENSION = ".jsonl";
+var HOURS_PER_DAY = 24;
+var MS_PER_HOUR = 36e5;
+var MS_PER_DAY = HOURS_PER_DAY * MS_PER_HOUR;
+var KEY_SEPARATOR = "	";
+var line_schema = z.object({
+  at: z.string(),
+  hook: z.string(),
+  rule: z.string(),
+  tool: z.string(),
+  session: z.string(),
+  command: z.string()
+});
+function period_start(period_days, now) {
+  return now.getTime() - period_days * MS_PER_DAY;
+}
+function day_files(directory, period_days, now) {
+  const count = Math.ceil(period_days) + 1;
+  const days = Array.from(
+    { length: count },
+    (_, index) => observation_ledger_home.ledger_date(new Date(now.getTime() - (count - 1 - index) * MS_PER_DAY))
+  );
+  return days.map((day) => path.join(directory, `${day}${LEDGER_EXTENSION}`));
+}
+async function read_text(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+function lines_of(text) {
+  return text.split("\n").map((line) => json_value.parse_with(line, line_schema)).filter((line) => line !== void 0);
+}
+async function read_lines(directory, period_days, now) {
+  const files = day_files(directory, period_days, now);
+  const texts = await Promise.all(files.map(async (file) => await read_text(file)));
+  const start = period_start(period_days, now);
+  return texts.flatMap((text) => lines_of(text)).filter((line) => Date.parse(line.at) >= start);
+}
+function group(lines) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const key = `${line.hook}${KEY_SEPARATOR}${line.rule}`;
+    const found = groups.get(key) ?? { hook: line.hook, rule: line.rule, lines: [] };
+    groups.set(key, { ...found, lines: [...found.lines, line] });
+  }
+  return [...groups.values()].toSorted((left, right) => right.lines.length - left.lines.length);
+}
+var hook_ledger_read = { group, period_start, read_lines };
+
+export {
+  hook_ledger_read
+};

package/dist/commands/{chunk-NJT5L6IC.js → chunk-NU7W6QGT.js}

@@ -1,13 +1,17 @@
 import {
   agent_diagnostics,
   claude_agent_argv
-} from "./chunk-OHVAEJSM.js";
+} from "./chunk-DEZF7QZZ.js";
 import {
   review_prompt_level
 } from "./chunk-E33LSO2W.js";
 import {
+  agent_worker_profile
+} from "./chunk-FVDQNMP6.js";
+import {
+  agent_phase_profile,
   agent_role_profile
-} from "./chunk-RIQ75QWR.js";
+} from "./chunk-6UCWAFQY.js";
 import {
   agent_session_role
 } from "./chunk-U3IVVR4W.js";
@@ -15,6 +19,26 @@ import {
   agent_profile_schema
 } from "./chunk-EZSO25UZ.js";
 
+// 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/codex-agent-argv.ts
 import path from "node:path";
 var AGENT_COMMAND = "codex";
@@ -96,9 +120,14 @@ function resolve(invocation, role, environment = process.env) {
 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);

package/dist/commands/chunk-NUR4FQHM.js

@@ -0,0 +1,21 @@
+import {
+  agent_exit_record
+} from "./chunk-GPTO6IZG.js";
+
+// scripts/agent/api-auth.ts
+var AUTH_MARKERS = ["failed to authenticate"];
+var AUTH_FAILURE_NOTE = "the session could not authenticate \u2014 a person has to run /login";
+function is_auth_failure(record) {
+  if (record === void 0 || !record.is_error || record.reason === void 0) return false;
+  const lower = record.reason.toLowerCase();
+  return AUTH_MARKERS.some((marker) => lower.includes(marker));
+}
+function is_auth_failed_transcript(transcript) {
+  if (transcript === void 0 || !agent_exit_record.ends_on_exit_record(transcript)) return false;
+  return is_auth_failure(agent_exit_record.read_exit_record(transcript));
+}
+var api_auth = { AUTH_FAILURE_NOTE, is_auth_failed_transcript, is_auth_failure };
+
+export {
+  api_auth
+};

package/dist/commands/{chunk-OKKQI4ZG.js → chunk-OAAVY2JK.js}

@@ -1,6 +1,6 @@
 import {
   delivered_rules
-} from "./chunk-S7XWXG4M.js";
+} from "./chunk-CP2J4RV2.js";
 
 // scripts/rules/stop-rule-rows.ts
 var STOP_GUARD = "pnpm josh stop:guard";

package/dist/commands/chunk-OF4BY4N7.js

@@ -0,0 +1,32 @@
+// scripts/init/hook-launch.ts
+var HOOK_DIST_DIR = "dist/hooks";
+var RUN_HOOK_SCRIPT = "scripts/hooks/run-hook.sh";
+var ROOT_LOOKUP = "git rev-parse --show-toplevel";
+var CLAUDE_ROOT = "$CLAUDE_PROJECT_DIR";
+var CODEX_ROOT = `$( (unset GIT_DIR GIT_WORK_TREE; ${ROOT_LOOKUP} 2>/dev/null) || ${ROOT_LOOKUP})`;
+function rooted_path(root, relative_path) {
+  return `"${root}/${relative_path}"`;
+}
+function hook_launch_command(name, root = CLAUDE_ROOT) {
+  return `sh ${rooted_path(root, RUN_HOOK_SCRIPT)} ${name}`;
+}
+function codex_command(command) {
+  return command.split(`"${CLAUDE_ROOT}/`).join(`"${CODEX_ROOT}/`);
+}
+function fallback_command(name) {
+  return name.replace("-", ":");
+}
+var hook_launch = {
+  CLAUDE_ROOT,
+  codex_command,
+  CODEX_ROOT,
+  fallback_command,
+  HOOK_DIST_DIR,
+  hook_launch_command,
+  rooted_path,
+  RUN_HOOK_SCRIPT
+};
+
+export {
+  hook_launch
+};

package/dist/commands/{chunk-W47I2KDY.js → chunk-OGS2DK7I.js}

@@ -1,12 +1,12 @@
 import {
   run_hold_cli
-} from "./chunk-WTRDWEUQ.js";
+} from "./chunk-4ZQM4I7R.js";
 import {
   run_hold
-} from "./chunk-P4CWLRT2.js";
+} from "./chunk-X3TNPALI.js";
 import {
   session_cite
-} from "./chunk-X7PN54LZ.js";
+} from "./chunk-22DVQCP6.js";
 
 // scripts/run/park/run-park-release.ts
 var SUCCESS_EXIT_CODE = 0;

package/dist/commands/{chunk-MS6Q3Z7V.js → chunk-OIPV3PWW.js}

@@ -1,19 +1,19 @@
 import {
   repository_labels
-} from "./chunk-DSBK66US.js";
+} from "./chunk-FOKCRIAN.js";
 import {
   auto_merge_setting,
   security_updates
 } from "./chunk-A6T2N7VC.js";
 import {
   self_sync_guard
-} from "./chunk-OGNTJ5JB.js";
+} from "./chunk-LYO6TX5L.js";
 import {
   package_manager_version
 } from "./chunk-AWLYN2SP.js";
 import {
   project_checks
-} from "./chunk-RK4HE5NW.js";
+} from "./chunk-JM6EVOFN.js";
 import {
   DEFAULT_RELEASE_AGE_MINUTES,
   copy_directory_failure,
@@ -30,7 +30,7 @@ import {
   sonar_file,
   transform_copied_content,
   vscode_tasks
-} from "./chunk-XH6BGVVP.js";
+} from "./chunk-LX7TIEMI.js";
 import {
   gh_spawn
 } from "./chunk-3PEXBHRN.js";
@@ -38,7 +38,7 @@ import {
   PLUGIN_SKILL_DIRECTORIES,
   init_logic,
   json_format
-} from "./chunk-RZ4OKKPM.js";
+} from "./chunk-5ZNUH4LV.js";
 import {
   KIT_PACKAGE_NAME
 } from "./chunk-PBOS7MTW.js";
@@ -54,7 +54,7 @@ import {
 import {
   PACKAGE_JSON,
   package_manifest
-} from "./chunk-NKKH3PBE.js";
+} from "./chunk-WB4T3VY2.js";
 import {
   file_reader
 } from "./chunk-ZNX2LJCQ.js";

package/dist/commands/{chunk-T33QDAWD.js → chunk-OIX2363L.js}

@@ -1,6 +1,6 @@
 import {
   git_gh_issue_write
-} from "./chunk-U2UH4VM4.js";
+} from "./chunk-RN2YDNLF.js";
 
 // scripts/issue/issue-park.ts
 async function apply(issue, label, body) {