@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-F4YMLVWN.js

@@ -0,0 +1,183 @@
+import {
+  run_retrospective
+} from "./chunk-IAB6LCJL.js";
+import {
+  latest_scope_cli
+} from "./chunk-BVUL57IX.js";
+import {
+  git_stash
+} from "./chunk-WROJTXWZ.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/run/run-step.ts
+var CLOSED = "CLOSED";
+var IMPLEMENT = "implement";
+var HUMAN_REVIEW = "human-review";
+var UPDATE_DEPS = "update-deps";
+var ALREADY_DONE = "already-done";
+var KEEP_WORK = "keep-work";
+var WAIT = "wait";
+var STOP = "stop";
+var UNKNOWN = "unknown";
+var VOCABULARY = [
+  IMPLEMENT,
+  HUMAN_REVIEW,
+  UPDATE_DEPS,
+  ALREADY_DONE,
+  KEEP_WORK,
+  WAIT,
+  STOP,
+  UNKNOWN
+];
+var RETROSPECTIVE_COMMAND = "pnpm josh retrospective";
+function closed_verdict(input) {
+  return input.has_changes ? KEEP_WORK : ALREADY_DONE;
+}
+function pre_verdict(input) {
+  if (input.state === void 0) return UNKNOWN;
+  if (input.state === CLOSED) return closed_verdict(input);
+  if (input.latest_scope === latest_scope_cli.REQUIRED_SCOPE) return UPDATE_DEPS;
+  if (input.is_human_review) return HUMAN_REVIEW;
+  return IMPLEMENT;
+}
+function verdict(token) {
+  return { kind: "verdict", line: token };
+}
+function command(line) {
+  return { kind: "command", line };
+}
+function merge_command(issue_number) {
+  return command(`pnpm josh run:merge ${issue_number}`);
+}
+var KIND = run_event_stream.EVENT_KIND;
+var OFFER_BACKLOG = "pnpm josh backlog:next";
+var EVENT_ACTIONS = {
+  [KIND.PR_OPENED]: () => command("pnpm josh followup"),
+  // `ship --review` asks `review:round2 --record` itself and reuses a recorded round 1, so a run past
+  // round 1 hands the rest of the region to it rather than to the hand-run round-2 steps.
+  [KIND.REVIEW_ROUND]: () => command("pnpm josh ship --review"),
+  [KIND.MERGE]: merge_command,
+  [KIND.OUTAGE]: merge_command,
+  [KIND.PARK]: () => command(OFFER_BACKLOG),
+  // The child was released; `backlog:drive` holds the next launch until the limit resets.
+  [KIND.USAGE_LIMIT]: () => command(OFFER_BACKLOG),
+  [KIND.CUT]: (issue_number) => command(`pnpm josh run:cut --resume ${issue_number}`),
+  // A stall is undispatched ready work with a free lane, so its next step is exactly a park's: offer
+  // the backlog. The detector only reports the stall; reading it here as a dispatch is what turns the
+  // report into the action that resolves it.
+  [KIND.STALL]: () => command(OFFER_BACKLOG),
+  // The post-implementation region is with a detached ship supervisor: nothing
+  // is the agent's until the supervisor stops or the issue closes, which the terminal read answers.
+  [KIND.SHIP_LAUNCH]: () => verdict(WAIT),
+  // The supervisor stopped at a failed stage and handed control back — the next step is reading the
+  // report it stopped on, which names the stage and why.
+  [KIND.SHIP_STOP]: (issue_number) => command(`pnpm josh ship --log ${issue_number}`)
+};
+var PARENT_ONLY_EVENTS = /* @__PURE__ */ new Set([KIND.MERGE, KIND.OUTAGE, KIND.USAGE_LIMIT]);
+function stop_action(input) {
+  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(STOP);
+}
+function drain_action(input) {
+  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(WAIT);
+}
+var HAND_OFF_COMMAND = "pnpm josh run:carry --cut";
+function can_hand_off(input) {
+  if (input.is_lane_child || input.is_at_cut_cap) return false;
+  return input.carry_kind === "carried" && !input.has_completion_callback;
+}
+function child_launch_action(input) {
+  return can_hand_off(input) ? command(HAND_OFF_COMMAND) : verdict(WAIT);
+}
+var FULL_INPUT_ACTIONS = {
+  [KIND.STOP]: stop_action,
+  [KIND.DRAIN]: drain_action,
+  [KIND.CHILD_LAUNCH]: child_launch_action,
+  // A person's restart re-dispatched the child, so the parent's position is a launch's.
+  [KIND.RESTART]: child_launch_action
+};
+function event_action(event, issue_number, is_lane_child) {
+  if (is_lane_child && PARENT_ONLY_EVENTS.has(event)) return verdict(STOP);
+  return EVENT_ACTIONS[event]?.(issue_number) ?? verdict(UNKNOWN);
+}
+var IMPLEMENTATION_POSITIONS = /* @__PURE__ */ new Set([KIND.PLAN, KIND.RESUME]);
+function is_pre_implementation(last_event) {
+  return last_event === void 0 || IMPLEMENTATION_POSITIONS.has(last_event);
+}
+function pre_implementation_action(input) {
+  return verdict(pre_verdict(input));
+}
+function owes_merge(input) {
+  return input.is_merge_owed && input.carry_kind === "carried" && !input.is_lane_child;
+}
+function closed_action(input) {
+  if (owes_merge(input)) return merge_command(input.issue_number);
+  if (closed_verdict(input) === ALREADY_DONE) return verdict(ALREADY_DONE);
+  const message = git_stash.work_message(input.issue_number, ALREADY_DONE);
+  return {
+    kind: "decide",
+    line: `decide: ${session_cite.issue(input.issue_number)} is closed but this tree holds uncommitted work \u2014 keep it with \`pnpm josh stash:push "${message}"\` | carry it into a new issue`
+  };
+}
+function is_handed_off_parent(input) {
+  return input.is_handed_off && input.carry_kind === "carried" && !input.is_lane_child;
+}
+function carry_terminal_action(input) {
+  if (input.carry_kind === "unreadable") return verdict(UNKNOWN);
+  if (is_handed_off_parent(input)) return verdict(STOP);
+  return void 0;
+}
+function terminal_action(input) {
+  const carry_action = carry_terminal_action(input);
+  if (carry_action !== void 0) return carry_action;
+  if (input.state === void 0) return verdict(UNKNOWN);
+  if (input.state === CLOSED) return closed_action(input);
+  return void 0;
+}
+var RETROSPECTIVE_POSITIONS = /* @__PURE__ */ new Set([KIND.DRAIN, KIND.STOP]);
+function is_retrospective_position(input) {
+  return RETROSPECTIVE_POSITIONS.has(input.last_event ?? "") && run_retrospective.is_owed(input);
+}
+function driving_action(input) {
+  if (is_retrospective_position(input)) return command(RETROSPECTIVE_COMMAND);
+  return input.is_at_cut_cap ? verdict(WAIT) : command(HAND_OFF_COMMAND);
+}
+function parent_action(input) {
+  if (input.is_lane_child) return verdict(UNKNOWN);
+  const terminal = carry_terminal_action(input);
+  if (terminal !== void 0) return terminal;
+  return input.is_driving ? driving_action(input) : verdict(UNKNOWN);
+}
+function next_action(input) {
+  const terminal = terminal_action(input);
+  if (terminal !== void 0) return terminal;
+  if (is_pre_implementation(input.last_event)) return pre_implementation_action(input);
+  const event = input.last_event ?? "";
+  const full_input_action = FULL_INPUT_ACTIONS[event];
+  if (full_input_action !== void 0) return full_input_action(input);
+  return event_action(event, input.issue_number, input.is_lane_child);
+}
+var run_step = {
+  ALREADY_DONE,
+  HAND_OFF_COMMAND,
+  HUMAN_REVIEW,
+  IMPLEMENT,
+  KEEP_WORK,
+  RETROSPECTIVE_COMMAND,
+  STOP,
+  UNKNOWN,
+  UPDATE_DEPS,
+  VOCABULARY,
+  WAIT,
+  next_action,
+  parent_action,
+  pre_verdict
+};
+
+export {
+  run_step
+};

package/dist/commands/chunk-F57LACNC.js

@@ -0,0 +1,84 @@
+import {
+  review_brief
+} from "./chunk-EVVQJJFV.js";
+import {
+  review_stamps
+} from "./chunk-S5GX3H4P.js";
+import {
+  file_map_stamp
+} from "./chunk-M32UPB2D.js";
+
+// scripts/gate/gate-skip.ts
+var FORCE_FLAG = "--force";
+var NO_BASE = "the merge base could not be read";
+var NO_CHANGE = "no file differs from the merge base";
+var INPUTS_MOVED = "a checked tool or environment variable changed since the green gate";
+var BASE_MOVED = "the merge base moved since the green gate";
+function base_moved(recorded, base) {
+  return `${BASE_MOVED} (${recorded ?? "none"} \u2192 ${base})`;
+}
+function stamp_miss(stamp, base) {
+  if (stamp.base !== base) return base_moved(stamp.base, base);
+  return review_stamps.gate_stamp.describes_inputs(stamp) ? void 0 : INPUTS_MOVED;
+}
+var NO_MATCHING_RECORD = "no green gate record matches the changed files";
+function record_miss(recorded, tree) {
+  if (recorded === void 0) return NO_MATCHING_RECORD;
+  const changed = String(Object.keys(tree).length);
+  const covered = String(Object.keys(recorded.files).length);
+  const differing = String(file_map_stamp.changed_since(recorded, tree).length);
+  return `${NO_MATCHING_RECORD} (${changed} changed, record covers ${covered}, ${differing} differ)`;
+}
+function gate_reuse(tree, base, source) {
+  if (base === void 0) return { miss: NO_BASE };
+  if (Object.keys(tree).length === 0) return { miss: NO_CHANGE };
+  const recorded = review_stamps.gate_stamp.read(source);
+  const stamp = review_brief.matching_stamp(recorded, tree);
+  if (stamp === void 0) return { miss: record_miss(recorded, tree) };
+  const miss = stamp_miss(stamp, base);
+  return miss === void 0 ? { stamp } : { miss };
+}
+var MISS_KINDS = [
+  [NO_BASE, "no-base"],
+  [NO_CHANGE, "no-change"],
+  [`${NO_MATCHING_RECORD} (`, "record-differs"],
+  [NO_MATCHING_RECORD, "no-record"],
+  [BASE_MOVED, "base-moved"],
+  [INPUTS_MOVED, "inputs-moved"]
+];
+var OTHER_MISS = "other";
+function miss_kind(miss) {
+  return MISS_KINDS.find(([prefix]) => miss.startsWith(prefix))?.[1] ?? OTHER_MISS;
+}
+function stamp_of(reuse) {
+  return "stamp" in reuse ? reuse.stamp : void 0;
+}
+function reusable_green_gate(tree, base, source) {
+  return stamp_of(gate_reuse(tree, base, source));
+}
+function format_reuse_notice(notice) {
+  return `\u2714 this tree is already green \u2014 ${notice.subject} passed on it at ${notice.taken_at} (\`pnpm josh gate\`)${notice.carried_clause}.
+  Reusing that result; nothing was re-run. \`${notice.force_hint}\` runs ${notice.rerun_object} anyway.`;
+}
+function format_skip(taken_at) {
+  return format_reuse_notice({
+    subject: "lint, the type check, the spell check and the unit tests all",
+    carried_clause: "",
+    taken_at,
+    force_hint: `pnpm josh gate ${FORCE_FLAG}`,
+    rerun_object: "the four checks"
+  });
+}
+var gate_skip = {
+  FORCE_FLAG,
+  format_reuse_notice,
+  format_skip,
+  gate_reuse,
+  miss_kind,
+  reusable_green_gate,
+  stamp_of
+};
+
+export {
+  gate_skip
+};

package/dist/commands/chunk-F5N2QIFD.js

@@ -0,0 +1,213 @@
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/josh/stamp-record.ts
+var NONE_READ = { kind: "none" };
+var UNREADABLE_READ = { kind: "unreadable" };
+function is_older_than(iso, max_age_ms, now) {
+  const at = Date.parse(iso);
+  if (Number.isNaN(at)) return true;
+  return now.getTime() - at > max_age_ms;
+}
+function classify(raw, spec, now) {
+  if (raw === void 0) return NONE_READ;
+  const record = spec.parse(raw);
+  if (record === void 0) return UNREADABLE_READ;
+  const is_expired2 = is_older_than(spec.timestamp_of(record), spec.max_age_ms, now);
+  return { kind: is_expired2 ? "expired" : "carried", record };
+}
+var stamp_record = { classify, is_older_than };
+
+// scripts/run/hold/run-hold.ts
+import { z } from "zod";
+var HOLD_PREFIX = "josh-run-hold-";
+var UNNUMBERED_ISSUE = "new";
+var HOLD_MAX_AGE_HOURS = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var HOLD_MAX_AGE_MS = HOLD_MAX_AGE_HOURS * MILLISECONDS_PER_HOUR;
+var RELEASE_COMMAND = "pnpm josh run:release";
+var FORCE_RELEASE_COMMAND = `${RELEASE_COMMAND} --force`;
+var NOT_IDLE = 'that is not "nothing is running here"';
+var FREE_READ = { kind: "free" };
+var UNREADABLE_READ2 = { kind: "unreadable" };
+function hold_path(git_directory) {
+  return stamp_file.stamp_path(HOLD_PREFIX, git_directory);
+}
+async function worktree_directory() {
+  const directories = await git_command.git_directories();
+  return directories[0];
+}
+async function is_linked_worktree() {
+  const directories = await git_command.git_directories();
+  return directories[0] !== void 0 && directories[0] !== directories[1];
+}
+var run_hold_schema = z.object({
+  issue: z.string(),
+  taken_at: z.string(),
+  pid: z.number(),
+  is_fullrun: z.boolean().optional(),
+  is_halfrun_stop: z.boolean().optional(),
+  prrun_stop_head: z.string().optional(),
+  owner_pid: z.number().optional(),
+  owner_start: z.string().optional(),
+  notified_at: z.string().optional()
+});
+function parse_hold(raw) {
+  return json_value.parse_with(raw, run_hold_schema);
+}
+function is_expired(hold, now) {
+  return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
+}
+function is_stop_marked(hold) {
+  return hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
+}
+function is_owner_gone(hold) {
+  if (is_stop_marked(hold) || hold.owner_pid === void 0) return false;
+  return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
+}
+function is_stale(hold, now) {
+  return is_expired(hold, now) || is_owner_gone(hold);
+}
+function classify2(raw, now) {
+  if (raw === void 0) return FREE_READ;
+  const hold = parse_hold(raw);
+  if (hold === void 0) return UNREADABLE_READ2;
+  return { kind: is_stale(hold, now) ? "stale" : "held", hold };
+}
+function read_hold(target, now = /* @__PURE__ */ new Date()) {
+  return classify2(stamp_file.read_stamp_text(target), now);
+}
+function session_owner(environment = process.env) {
+  const pid = agent_session_environment.session_pid(environment);
+  if (pid === void 0) return {};
+  return { owner_pid: pid, owner_start: process_identity.read_start(pid) };
+}
+function build_hold(issue, now, is_fullrun) {
+  return { issue, taken_at: now.toISOString(), pid: process.pid, is_fullrun, ...session_owner() };
+}
+function write_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  const hold = build_hold(issue, now);
+  stamp_file.write_stamp(target, hold);
+  return hold;
+}
+function create_hold(target, issue, now = /* @__PURE__ */ new Date(), is_fullrun) {
+  return stamp_file.create_stamp(target, build_hold(issue, now, is_fullrun));
+}
+var HALFRUN_STOP_FIELDS = { is_halfrun_stop: true };
+function create_stop_hold(target, issue, mark, now = /* @__PURE__ */ new Date()) {
+  return stamp_file.create_stamp(target, { ...build_hold(issue, now), ...mark });
+}
+function create_halfrun_stop_hold(target, issue, now = /* @__PURE__ */ new Date()) {
+  return create_stop_hold(target, issue, HALFRUN_STOP_FIELDS, now);
+}
+async function is_tree_dirty(directory) {
+  try {
+    const status = await git_command.status(directory);
+    return status.trim() !== "";
+  } catch (error) {
+    error_text.trace_swallowed("run_hold.is_tree_dirty", error);
+    return true;
+  }
+}
+function release_hold(target) {
+  stamp_file.remove_stamp(target);
+}
+function describe_holder(hold) {
+  const holder = hold.issue === UNNUMBERED_ISSUE ? "an unnumbered run" : session_cite.issue(hold.issue);
+  return `${holder}, recorded ${hold.taken_at} (pid ${String(hold.owner_pid ?? hold.pid)})`;
+}
+function own_release_command(issue) {
+  return issue === UNNUMBERED_ISSUE ? RELEASE_COMMAND : `${RELEASE_COMMAND} ${issue}`;
+}
+function is_own_hold(hold, claimant) {
+  return hold.issue === claimant;
+}
+function is_reentry(hold, claimant) {
+  return claimant !== UNNUMBERED_ISSUE && is_own_hold(hold, claimant);
+}
+function held_message(hold) {
+  return `This working tree is already held by ${describe_holder(hold)}. One run at a time per working tree: a second run here commits its files onto the other run's branch. If that record is stale, run \`${FORCE_RELEASE_COMMAND}\` in this working tree \u2014 it removes a record this run did not write, so be sure the run that did has ended \u2014 and ask again.`;
+}
+function foreign_release_message(hold) {
+  return `This working tree is held by ${describe_holder(hold)}, and this release did not claim it \u2014 nothing was removed. Release it as that run with \`${own_release_command(hold.issue)}\`, or, once you are sure it has ended, remove the record with \`${FORCE_RELEASE_COMMAND}\`.`;
+}
+function forced_release_message(hold) {
+  return `Forced: removed the run record held by ${describe_holder(hold)}.`;
+}
+function unreadable_message() {
+  return `This working tree's run record could not be read \u2014 ${NOT_IDLE}. Run \`${FORCE_RELEASE_COMMAND}\` in this working tree to clear it, then ask again.`;
+}
+function stale_reason(hold) {
+  return is_owner_gone(hold) ? "the session that wrote it has ended" : `older than ${String(HOLD_MAX_AGE_HOURS)} hours`;
+}
+function stale_message(hold) {
+  return `Replaced a stale run record held by ${describe_holder(hold)}: ${stale_reason(hold)}, so the run that wrote it has ended without releasing it.`;
+}
+function uncommitted_message(hold) {
+  return `This working tree still has uncommitted changes, and its run record \u2014 held by ${describe_holder(hold)} \u2014 has expired or outlived its session. That is a run which stopped for a person rather than one that finished, so the tree is not free: commit or stash the work, or run \`${own_release_command(hold.issue)}\` once you are done with it, then ask again.`;
+}
+function race_message(read, target) {
+  if (read.kind === "held") return held_message(read.hold);
+  return `A record already exists at ${target} and this run did not write it \u2014 ${NOT_IDLE}. Either another run claimed the tree at the same moment, or the record belongs to another account. Run \`${FORCE_RELEASE_COMMAND}\`, and remove that file by hand if it is still there.`;
+}
+function unknown_message() {
+  return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
+}
+var run_hold = {
+  is_stop_marked,
+  FORCE_RELEASE_COMMAND,
+  HOLD_MAX_AGE_HOURS,
+  HOLD_MAX_AGE_MS,
+  RELEASE_COMMAND,
+  UNNUMBERED_ISSUE,
+  classify: classify2,
+  create_halfrun_stop_hold,
+  create_stop_hold,
+  HALFRUN_STOP_FIELDS,
+  create_hold,
+  describe_holder,
+  foreign_release_message,
+  forced_release_message,
+  held_message,
+  hold_path,
+  is_linked_worktree,
+  is_own_hold,
+  is_reentry,
+  is_tree_dirty,
+  own_release_command,
+  race_message,
+  read_hold,
+  release_hold,
+  session_owner,
+  stale_message,
+  stale_reason,
+  uncommitted_message,
+  unknown_message,
+  unreadable_message,
+  worktree_directory,
+  write_hold
+};
+
+export {
+  stamp_record,
+  run_hold
+};

package/dist/commands/chunk-F7B4ESZE.js

@@ -0,0 +1,80 @@
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+
+// scripts/agent/agent-profile-schema.ts
+import { z } from "zod";
+
+// scripts/agent/agent-model-alias.ts
+var CLAUDE_MODEL_PATTERN = /^claude-(?<family>opus|sonnet|haiku|fable)-/u;
+function alias_of(model) {
+  return CLAUDE_MODEL_PATTERN.exec(model)?.groups?.["family"];
+}
+function suffix_of(model) {
+  const alias = alias_of(model);
+  return alias === void 0 ? "" : ` (${alias})`;
+}
+var agent_model_alias = { alias_of, suffix_of };
+
+// scripts/agent/agent-profile-schema.ts
+var ROLE_SCHEMA = z.enum(["scheduler", "worker", "reviewer"]);
+var EFFORT_SCHEMA = z.enum(["low", "medium", "high", "xhigh", "max"]);
+var PHASE_SCHEMA = z.enum(["implementation", "pre-gate"]);
+var PROFILE_SCHEMA = z.object({
+  provider: agent_provider.PROVIDER_SCHEMA.default("anthropic"),
+  role: ROLE_SCHEMA,
+  model: z.string(),
+  effort: EFFORT_SCHEMA
+});
+var SCHEDULER = "scheduler";
+var WORKER = "worker";
+var REVIEWER = "reviewer";
+var IMPLEMENTATION_PHASE = "implementation";
+var PRE_GATE_PHASE = "pre-gate";
+var OPENAI_MODEL = "gpt-6.1-sol";
+var ANTHROPIC_MODEL = "claude-opus-5-5";
+var REVIEW_EFFORT = "medium";
+var { ANTHROPIC_PROVIDER, OPENAI_PROVIDER } = agent_provider;
+var { is_safe_value } = agent_safe_text;
+function role_profiles(provider, model) {
+  return {
+    scheduler: { provider, role: SCHEDULER, model, effort: "medium" },
+    worker: { provider, role: WORKER, model, effort: "medium" },
+    reviewer: { provider, role: REVIEWER, model, effort: REVIEW_EFFORT }
+  };
+}
+var DEFAULT_PROFILES = role_profiles(ANTHROPIC_PROVIDER, ANTHROPIC_MODEL);
+var OPENAI_PROFILES = role_profiles(OPENAI_PROVIDER, OPENAI_MODEL);
+function describe(profile) {
+  return `provider=${profile.provider} role=${profile.role} model=${profile.model}${agent_model_alias.suffix_of(profile.model)} effort=${profile.effort}`;
+}
+function describe_review(round, profile) {
+  return `review round ${String(round)} \xB7 ${describe(profile)}`;
+}
+function parse(value) {
+  const parsed = PROFILE_SCHEMA.safeParse(value);
+  return parsed.success && is_safe_value(parsed.data.model) ? parsed.data : void 0;
+}
+var agent_profile_schema = {
+  DEFAULT_PROFILES,
+  EFFORT_SCHEMA,
+  IMPLEMENTATION_PHASE,
+  OPENAI_MODEL,
+  OPENAI_PROFILES,
+  PHASE_SCHEMA,
+  PRE_GATE_PHASE,
+  PROFILE_SCHEMA,
+  REVIEWER,
+  SCHEDULER,
+  WORKER,
+  describe,
+  describe_review,
+  parse
+};
+
+export {
+  agent_profile_schema
+};