@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-NU7W6QGT.js

@@ -1,155 +0,0 @@
-import {
-  agent_diagnostics,
-  claude_agent_argv
-} 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-6UCWAFQY.js";
-import {
-  agent_session_role
-} from "./chunk-U3IVVR4W.js";
-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";
-var AGENT_FLAGS = ["exec"];
-var MODEL_FLAG = "--model";
-var CONFIG_FLAG = "-c";
-var JSON_FLAG = "--json";
-var SQLITE_CACHE_PATH = ["node_modules", ".cache", "josh", "openai"];
-var EPHEMERAL_FLAG = "--ephemeral";
-var PERMISSION_ARGUMENTS = [
-  CONFIG_FLAG,
-  'default_permissions=":danger-full-access"',
-  CONFIG_FLAG,
-  'approval_policy="never"'
-];
-function effort_config(profile) {
-  return `model_reasoning_effort="${profile.effort}"`;
-}
-function role_config(profile) {
-  return `shell_environment_policy.set.${agent_session_role.KEY}=${JSON.stringify(profile.role)}`;
-}
-function sqlite_config(cwd) {
-  return `sqlite_home=${JSON.stringify(path.resolve(cwd, ...SQLITE_CACHE_PATH))}`;
-}
-function persistence_arguments(profile) {
-  return profile.role === agent_profile_schema.WORKER ? [] : [EPHEMERAL_FLAG];
-}
-function lane_arguments(cwd, profile) {
-  if (cwd === void 0) return [];
-  return [CONFIG_FLAG, sqlite_config(cwd), ...persistence_arguments(profile)];
-}
-function build(invocation, profile, cwd) {
-  return {
-    command: AGENT_COMMAND,
-    args: [
-      ...AGENT_FLAGS,
-      MODEL_FLAG,
-      profile.model,
-      CONFIG_FLAG,
-      effort_config(profile),
-      CONFIG_FLAG,
-      role_config(profile),
-      ...PERMISSION_ARGUMENTS,
-      ...lane_arguments(cwd, profile),
-      JSON_FLAG,
-      invocation
-    ],
-    ends_with_prompt: true
-  };
-}
-var codex_agent_argv = { build };
-
-// scripts/agent/agent-argv.ts
-function build2(invocation, profile, cwd, session_id) {
-  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build(invocation, profile, session_id, cwd);
-}
-function build_resume(invocation, profile, session_id, cwd) {
-  return profile.provider === "openai" ? codex_agent_argv.build(invocation, profile, cwd) : claude_agent_argv.build_resume(invocation, profile, session_id, cwd);
-}
-function with_profile_in(invocation, profile, cwd, session_id) {
-  const diagnostic = agent_diagnostics.check(profile);
-  if (diagnostic.kind === "rejected") return diagnostic;
-  return { kind: "argv", argv: build2(invocation, profile, cwd, session_id), profile };
-}
-function with_resume_in(invocation, profile, session_id, cwd) {
-  const diagnostic = agent_diagnostics.check(profile);
-  if (diagnostic.kind === "rejected") return diagnostic;
-  return { kind: "argv", argv: build_resume(invocation, profile, session_id, cwd), profile };
-}
-function with_profile(invocation, profile) {
-  const diagnostic = agent_diagnostics.check(profile);
-  if (diagnostic.kind === "rejected") return diagnostic;
-  return { kind: "argv", argv: build2(invocation, profile), profile };
-}
-function resolve(invocation, role, environment = process.env) {
-  const resolved = agent_role_profile.resolve(role, environment);
-  return resolved.kind === "rejected" ? resolved : with_profile(invocation, resolved.profile);
-}
-function profiled_in(invocation, resolved, cwd) {
-  return resolved.kind === "rejected" ? resolved : with_profile_in(invocation, resolved.profile, 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);
-  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);
-}
-function review_in(invocation, round, cwd, environment = process.env) {
-  const is_reduced = review_prompt_level.level_of(invocation) === "low";
-  return profiled_in(
-    invocation,
-    agent_role_profile.resolve_review(round, environment, is_reduced),
-    cwd
-  );
-}
-var agent_argv = {
-  resolve,
-  resolve_in,
-  review_in,
-  resume_argv,
-  with_profile,
-  with_profile_in,
-  with_resume_in
-};
-
-export {
-  agent_argv
-};

package/dist/commands/chunk-NYWGJLBU.js

@@ -1,19 +0,0 @@
-import {
-  start_exec
-} from "./chunk-RH6ZWJOA.js";
-
-// scripts/init/initial-commit.ts
-var DEFAULT_BRANCH = "main";
-function create_repository(root) {
-  start_exec.git_run(["init", `--initial-branch=${DEFAULT_BRANCH}`], root);
-}
-function commit_all(root) {
-  start_exec.git_run(["add", "--all"], root);
-  start_exec.git_run(["commit", "--no-verify", "--message", "Initial commit"], root);
-  start_exec.git_run(["branch", "--move", "--force", DEFAULT_BRANCH], root);
-}
-var initial_commit = { create_repository, commit_all };
-
-export {
-  initial_commit
-};

package/dist/commands/chunk-OAAVY2JK.js

@@ -1,49 +0,0 @@
-import {
-  delivered_rules
-} from "./chunk-CP2J4RV2.js";
-
-// scripts/rules/stop-rule-rows.ts
-var STOP_GUARD = "pnpm josh stop:guard";
-var ROWS = [
-  {
-    id: "stop-notify",
-    about: {
-      title: "Stop notification",
-      topic: '`rule-delivery.md` \u2192 "stop-notify"',
-      entry: STOP_GUARD,
-      fires: "a stop with the work tree held and no `confirmation` notify that turn. Sends the notify itself; blocks only when the send fails",
-      quiet: "no hold, a `confirmation` notify on the tail, or a pre-gate cut taken"
-    }
-  },
-  {
-    id: "hold-release",
-    about: {
-      title: "Hold release",
-      topic: "`.claude/skills/workflow-commands/working-tree-hold.md`",
-      entry: STOP_GUARD,
-      fires: "a stop on a clean tree with the `run:hold` record still in place. Releases the hold itself; blocks only when that fails",
-      quiet: "a dirty tree (a `halfrun` stop before the commit, a `needs-human-review` stop) or already released"
-    }
-  },
-  {
-    id: "filing-offer",
-    about: {
-      title: "Offer to file",
-      topic: "`.claude/skills/workflow-commands/observation-filing.md`",
-      entry: STOP_GUARD,
-      fires: "an unattended run (a kit-launched headless session, a lane child, a `backlogrun` parent) whose last reply offers to file without filing. Blocks the stop",
-      quiet: "an interactive session, already filed, inside a fence or quote, a named third-party `owner/repo`, or an unknown owner"
-    }
-  }
-];
-var stop_rule_rows = { ROWS };
-
-// scripts/rules/guard-rule-rows.ts
-function rows() {
-  return [...delivered_rules.MEASURED_RULES, ...stop_rule_rows.ROWS];
-}
-var guard_rule_rows = { rows };
-
-export {
-  guard_rule_rows
-};

package/dist/commands/chunk-OGS2DK7I.js

@@ -1,47 +0,0 @@
-import {
-  run_hold_cli
-} from "./chunk-4ZQM4I7R.js";
-import {
-  run_hold
-} from "./chunk-X3TNPALI.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-
-// scripts/run/park/run-park-release.ts
-var SUCCESS_EXIT_CODE = 0;
-var RELEASE_FLAG = "--release";
-async function read_worktree_directory() {
-  try {
-    return await run_hold.worktree_directory();
-  } catch {
-    return void 0;
-  }
-}
-async function is_held_by_other_run(issue_number) {
-  const directory = await read_worktree_directory();
-  if (directory === void 0) return false;
-  const read = run_hold.read_hold(run_hold.hold_path(directory));
-  return "hold" in read && !run_hold.is_own_hold(read.hold, issue_number);
-}
-async function release_own(issue_number) {
-  const code = await run_hold_cli.run([RELEASE_FLAG, issue_number]);
-  if (code !== SUCCESS_EXIT_CODE) {
-    console.error(
-      `park ${session_cite.issue(issue_number)} \u2014 parked, but the release failed; re-run: pnpm josh run:release ${issue_number}`
-    );
-  }
-  return code;
-}
-async function release(issue_number) {
-  if (!await is_held_by_other_run(issue_number)) return await release_own(issue_number);
-  console.info(
-    `park ${session_cite.issue(issue_number)} \u2014 release skipped: this tree's hold is another run's`
-  );
-  return SUCCESS_EXIT_CODE;
-}
-var run_park_release = { release };
-
-export {
-  run_park_release
-};

package/dist/commands/chunk-OHNP3QL2.js

@@ -1,186 +0,0 @@
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/ship/run-ship-stage.ts
-import { z } from "zod";
-var STAGE = {
-  PREFLIGHT: "preflight",
-  REVIEW: "review",
-  GATE: "gate",
-  SYNC: "sync",
-  COMMIT: "commit",
-  ROUND_TWO: "round-2",
-  FOLLOWUP: "followup",
-  REPORT: "report"
-};
-var PHASE = {
-  START: "start",
-  DONE: "done",
-  FAILED: "failed",
-  SKIPPED: "skipped"
-};
-var RECORD_PREFIX = "josh-ship-stages-";
-var RECORD_SEPARATOR = "-";
-var SKIP_COMMIT_FLAG = "--skip-commit";
-var SKIP_PUSH_FLAG = "--skip-push";
-var WORD_SEPARATOR = " ";
-var STARTED_SEPARATOR = ",";
-var STARTED_INDEX = 3;
-var WORD_COUNT = STARTED_INDEX + 1;
-var REASON_SEPARATOR = " | ";
-var record_schema = z.object({
-  done: z.array(z.string()),
-  started: z.array(z.string()).default([]),
-  is_merge_waiting: z.boolean().default(false),
-  is_place_waiting: z.boolean().default(false)
-});
-var EMPTY_RECORD = {
-  done: [],
-  started: [],
-  is_merge_waiting: false,
-  is_place_waiting: false
-};
-function record_path(repository, issue) {
-  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue}${RECORD_SEPARATOR}`, repository);
-}
-function parse_record(raw) {
-  return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
-}
-function read_record(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
-}
-function read_done(target) {
-  return new Set(read_record(target).done);
-}
-function mark_done(target, stage) {
-  const record = read_record(target);
-  stamp_file.replace_stamp(target, { ...record, done: [.../* @__PURE__ */ new Set([...record.done, stage])] });
-}
-function read_started(target) {
-  return read_record(target).started;
-}
-function mark_started(target, stage) {
-  const record = read_record(target);
-  stamp_file.replace_stamp(target, { ...record, started: [.../* @__PURE__ */ new Set([...record.started, stage])] });
-}
-function end_attempt(target) {
-  stamp_file.replace_stamp(target, { ...read_record(target), started: [], is_merge_waiting: false });
-}
-function read_merge_waiting(target) {
-  return read_record(target).is_merge_waiting;
-}
-function mark_merge_waiting(target, is_merge_waiting) {
-  stamp_file.replace_stamp(target, { ...read_record(target), is_merge_waiting });
-}
-function read_place_waiting(target) {
-  return read_record(target).is_place_waiting;
-}
-function mark_place_waiting(target, is_place_waiting) {
-  stamp_file.replace_stamp(target, { ...read_record(target), is_place_waiting });
-}
-function clear_waits(target) {
-  stamp_file.replace_stamp(target, {
-    ...read_record(target),
-    is_merge_waiting: false,
-    is_place_waiting: false
-  });
-}
-function clear(target) {
-  stamp_file.remove_stamp(target);
-}
-function is_shipped(state) {
-  return state.is_committed && state.is_pushed;
-}
-var DONE_BY = {
-  // The preflight asks what the commit stage would refuse on, so a commit is
-  // its output; a resumed commit stage still asks `git -y`'s own preflight.
-  [STAGE.PREFLIGHT]: (done, state) => state.is_merged || done.has(STAGE.PREFLIGHT) && state.is_committed,
-  // The sync stage commits locally before the review round and the gate, without pushing
-  // (`run-ship-sync.ts`), so a commit is neither's output: a pushed one on a clean tree is, as only the
-  // commit stage after the gate pushes — unless the issue changed since.
-  [STAGE.REVIEW]: (done, state) => state.is_merged || done.has(STAGE.REVIEW) && is_shipped(state) && state.is_review_stale !== true,
-  [STAGE.GATE]: (done, state) => state.is_merged || done.has(STAGE.GATE) && is_shipped(state),
-  // The merge of the default branch before the gate: once pushed, a default branch that
-  // moved is the followup's to merge again.
-  [STAGE.SYNC]: (done, state) => state.is_merged || done.has(STAGE.SYNC) && is_shipped(state),
-  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
-  // The final review precedes the push. Its own tree stamp decides reuse after a stop.
-  [STAGE.ROUND_TWO]: (_done, state) => state.is_merged,
-  // A recorded followup still needs the shipped state: a record left by a merged ship whose report
-  // failed must not pass over the followup of new, not-yet-pushed work on the same issue.
-  [STAGE.FOLLOWUP]: (done, state) => state.is_merged || done.has(STAGE.FOLLOWUP) && is_shipped(state),
-  [STAGE.REPORT]: (done) => done.has(STAGE.REPORT)
-};
-function is_done(stage, done, state, has_body = false) {
-  if (has_body && stage === STAGE.COMMIT && !state.is_merged) return false;
-  return DONE_BY[stage](done, state);
-}
-function commit_flags(state) {
-  if (!state.is_committed) return [];
-  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
-}
-function event_text(issue, stage, phase, started = []) {
-  const words = [issue_cite.plain_for("program", issue), stage, phase];
-  const listed = [...new Set(started)].join(STARTED_SEPARATOR);
-  const full = started.length > 0 ? [...words, listed] : words;
-  return full.join(WORD_SEPARATOR);
-}
-function with_reason(text, reason) {
-  return reason === void 0 ? text : `${text}${REASON_SEPARATOR}${reason}`;
-}
-function words_part(text) {
-  return text.split(REASON_SEPARATOR, 1)[0] ?? "";
-}
-function started_of(text) {
-  return words_part(text).split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
-}
-function words_of(text) {
-  const [, stage = "", phase = ""] = words_part(text).split(WORD_SEPARATOR, WORD_COUNT);
-  return { stage, phase };
-}
-function reason_of(text) {
-  const at = text.indexOf(REASON_SEPARATOR);
-  return at === -1 ? void 0 : text.slice(at + REASON_SEPARATOR.length);
-}
-var CONFLICT = "conflict";
-function stop_reason(stage, conflicts = []) {
-  return conflicts.length > 0 ? CONFLICT : stage;
-}
-var run_ship_stage = {
-  CONFLICT,
-  PHASE,
-  STAGE,
-  clear,
-  clear_waits,
-  commit_flags,
-  end_attempt,
-  event_text,
-  is_done,
-  is_shipped,
-  mark_done,
-  mark_merge_waiting,
-  mark_place_waiting,
-  mark_started,
-  read_done,
-  read_merge_waiting,
-  read_place_waiting,
-  read_started,
-  reason_of,
-  record_path,
-  started_of,
-  with_reason,
-  words_of,
-  stop_reason
-};
-
-export {
-  run_ship_stage
-};