@joshuafolkken/kit 1.1379.0 → 1.1387.0

package/dist/hooks/session-lang.js

@@ -6,17 +6,23 @@ import {
   agent_role_profile,
   detached_launch,
   git_common_directory,
+  issue_cite,
+  run_event_stream,
+  run_event_stream_emit,
   run_headless
-} from "./chunk-YSDAH73S.js";
+} from "./chunk-U32VSRNG.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
 import {
   josh_environment_file
-} from "./chunk-NBEAGPS4.js";
+} from "./chunk-J3KSS7II.js";
 import {
   agent_session_environment,
   json_value,
   process_identity,
   run_carry
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 import {
   stamp_file
 } from "./chunk-NEC4AT4Z.js";
@@ -298,6 +304,32 @@ var agent_argv = {
   with_resume_in
 };
 
+// scripts/run/event/run-event-setup.ts
+var STAGE = {
+  // `josh backlogrun` started the parent session, which is reading its procedure.
+  STARTING: "starting session",
+  // `run:carry --begin` claimed the run, and the parent is planning it.
+  PLANNING: "planning",
+  // The supervisor took the run over from the parent and is asking for the first offer.
+  HANDING_OFF: "handing off"
+};
+var OPENING = "opening lane";
+function opening_lane(issue) {
+  return `${OPENING} ${issue_cite.plain(issue)}`;
+}
+async function emit(text) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SETUP, text);
+}
+function emit_in(repository, text, at) {
+  try {
+    const target = run_event_stream.target_of(repository);
+    run_event_stream.append(target, run_event_stream.EVENT_KIND.SETUP, text, at.toISOString());
+  } catch (error) {
+    error_text.trace_swallowed("run_event_setup.emit_in", error);
+  }
+}
+var run_event_setup = { STAGE, emit, emit_in, opening_lane };
+
 // scripts/backlog/backlogrun-launch.ts
 import { z } from "zod";
 var LAUNCH_PREFIX = "josh-backlogrun-launch-";
@@ -306,7 +338,11 @@ var LOG_SUFFIX = ".log";
 var launch_schema = z.object({
   pid: z.number(),
   start: z.string().optional(),
-  session: z.string().optional()
+  session: z.string().optional(),
+  // What the parent was started to run and when, so `run:board` has a run to draw and a clock to count
+  // before the parent claims the carry record. Absent on a record an earlier version wrote.
+  invocation: z.string().optional(),
+  started_at: z.string().optional()
 });
 function launch_path(git_directory) {
   return stamp_file.stamp_path(LAUNCH_PREFIX, git_directory);
@@ -348,9 +384,27 @@ function argv_of(invocation, provider, worktree, session) {
 function note_to_stderr(note) {
   console.error(`backlogrun: ${note}`);
 }
-function record_launch(git_directory, pid, session) {
-  const started = process_identity.read_start(pid);
-  stamp_file.replace_stamp(launch_path(git_directory), { pid, start: started, session });
+function record_launch(git_directory, launch) {
+  const now = /* @__PURE__ */ new Date();
+  const identity = process_identity.read_start(launch.pid);
+  const record = { ...launch, start: identity, started_at: now.toISOString() };
+  stamp_file.replace_stamp(launch_path(git_directory), record);
+  run_event_setup.emit_in(git_directory, run_event_setup.STAGE.STARTING, now);
+}
+function live_launch(git_directory) {
+  const record = read_launch(launch_path(git_directory));
+  return is_launch_live(record) ? record : void 0;
+}
+function pending_launch(git_directory) {
+  const { invocation, started_at } = live_launch(git_directory) ?? {};
+  if (invocation === void 0 || started_at === void 0) return void 0;
+  return { invocation, started_at };
+}
+function started_for(git_directory, owner_pid) {
+  const record = live_launch(git_directory);
+  if (record?.started_at === void 0 || record.pid !== owner_pid) return void 0;
+  const started_ms = Date.parse(record.started_at);
+  return Number.isNaN(started_ms) ? void 0 : new Date(started_ms);
 }
 function spawn_parent(argv, provider, target) {
   const environment = {
@@ -376,7 +430,7 @@ function start(invocation, provider, target) {
   if (built.kind === "rejected") return { kind: "failed", note: built.note };
   const result = spawn_parent(built, provider, target);
   if (result.kind === "failed") return result;
-  record_launch(target.git_directory, result.pid, session);
+  record_launch(target.git_directory, { pid: result.pid, session, invocation });
   const launched = { pid: result.pid, session, log_path: log_path(target.git_directory) };
   return { kind: "launched", launched };
 }
@@ -384,7 +438,9 @@ var backlogrun_launch = {
   argv_of,
   chosen_environment,
   is_running,
-  start
+  pending_launch,
+  start,
+  started_for
 };
 
 // scripts/josh/session-language-cli.ts

package/dist/hooks/stop-guard.js

@@ -13,10 +13,8 @@ import {
   lane_park,
   repo_party,
   run_cut,
-  run_event_stream,
-  run_event_stream_emit,
   run_hold
-} from "./chunk-TG2AB3W6.js";
+} from "./chunk-GNDJ7NJ7.js";
 import {
   session_language
 } from "./chunk-6V5OPIUU.js";
@@ -25,23 +23,25 @@ import {
   agent_role_profile,
   issue_cite,
   lane_registry,
+  run_event_stream,
+  run_event_stream_emit,
   run_headless
-} from "./chunk-YSDAH73S.js";
+} from "./chunk-U32VSRNG.js";
 import {
   timed_fetch
 } from "./chunk-FZ6FUSBM.js";
 import "./chunk-CDY4NFQG.js";
 import {
   hook_decision
-} from "./chunk-E7LZL5AN.js";
+} from "./chunk-EBSHN25W.js";
 import {
   time_density_hook,
   time_hook_transcript,
   time_reported_failure
-} from "./chunk-TORRSNDJ.js";
+} from "./chunk-SL4GQ2XP.js";
 import {
   lane_child_marker
-} from "./chunk-NBEAGPS4.js";
+} from "./chunk-J3KSS7II.js";
 import {
   backlog_budget,
   issue_number_shape,
@@ -50,7 +50,7 @@ import {
   process_owner_schema,
   run_carry,
   run_invocation
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 import {
   PROJECT_ROOT,
   stamp_file
@@ -964,8 +964,53 @@ var run_halfrun_resume = {
   take_over
 };
 
-// scripts/run/wake/run-wake.ts
+// scripts/run/carry/run-carry-ended.ts
+import path from "node:path";
 import { z as z4 } from "zod";
+var ENDED_PREFIX = "josh-run-ended-";
+var TRANSCRIPT_SUFFIX = ".jsonl";
+var ended_run_schema = z4.object({
+  invocation: z4.string(),
+  started_at: z4.string(),
+  ended_at: z4.string(),
+  stopped: z4.string().optional(),
+  session: z4.string().optional()
+});
+function ended_path(git_directory) {
+  return stamp_file.stamp_path(ENDED_PREFIX, git_directory);
+}
+function session_of(transcript) {
+  return transcript === void 0 ? void 0 : path.basename(transcript, TRANSCRIPT_SUFFIX);
+}
+function stop_of(transcript, stopped) {
+  return stopped === void 0 ? {} : { stopped, session: session_of(transcript) };
+}
+function record_ended(target, read, now = /* @__PURE__ */ new Date(), stopped) {
+  if (read.kind !== "carried") return;
+  const { invocation, started_at, owner_transcript } = read.carry;
+  const ended_at = now.toISOString();
+  stamp_file.replace_stamp(target, {
+    invocation,
+    started_at,
+    ended_at,
+    ...stop_of(owner_transcript, stopped)
+  });
+}
+function parse_ended(raw) {
+  return json_value.parse_with(raw, ended_run_schema);
+}
+function read_ended(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : parse_ended(raw);
+}
+function has_ended(target, started_at) {
+  const ended = read_ended(target);
+  return ended !== void 0 && ended.started_at === started_at;
+}
+var run_carry_ended = { ended_path, has_ended, read_ended, record_ended };
+
+// scripts/run/wake/run-wake.ts
+import { z as z5 } from "zod";
 var WAKE_PREFIX = "josh-run-wake-";
 var WAKE_LOG_PREFIX = "josh-run-wake-log-";
 var WAKE_LOG_SUFFIX = ".log";
@@ -981,19 +1026,18 @@ var PENDING_DECISION = { kind: "pending" };
 var FAILED_DECISION = { kind: "failed" };
 var STOP_REASONS = {
   none: "ended",
-  expired: "expired",
   unreadable: "unreadable"
 };
 var run_wake_schema = process_owner_schema.extend({
-  invocation: z4.string(),
-  started_at: z4.string(),
-  woke: z4.number(),
-  woke_at: z4.string().optional(),
+  invocation: z5.string(),
+  started_at: z5.string(),
+  woke: z5.number(),
+  woke_at: z5.string().optional(),
   // Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
-  attempts: z4.number().optional(),
-  woke_pid: z4.number().optional(),
-  spawned: z4.array(z4.string()).optional(),
-  idle_since: z4.string().optional(),
+  attempts: z5.number().optional(),
+  woke_pid: z5.number().optional(),
+  spawned: z5.array(z5.string()).optional(),
+  idle_since: z5.string().optional(),
   profile: agent_role_profile.PROFILE_SCHEMA.optional()
 });
 function is_overdue(marked_at, now, limit_ms = WAKE_GRACE_MS) {
@@ -1157,14 +1201,17 @@ function supervisor_liveness(wake, same_process = process_identity.is_same_proce
   if (is_same === void 0) return UNKNOWN;
   return is_same ? LIVE : GONE;
 }
+function had_driver(carry) {
+  return carry.is_handed_off === true || carry.owner_pid !== void 0;
+}
 function is_stranded(input) {
-  if (input.read.kind !== "carried" || input.read.carry.is_handed_off !== true || input.is_owner_live) {
+  if (input.read.kind !== "carried" || input.is_owner_live || !had_driver(input.read.carry)) {
     return false;
   }
   return input.supervisor === GONE;
 }
 function describe2(carry) {
-  return `Run stranded \u2014 ${run_carry.describe_carry(carry)}. The owner is gone, no cut successor claimed the budget, and no supervisor is watching.`;
+  return `Run stranded \u2014 ${run_carry.describe_carry(carry)}. The owner is gone, no successor holds the budget, and no supervisor is watching.`;
 }
 function verdict_of(is_run_stranded) {
   return is_run_stranded ? STRANDED : OK2;
@@ -1184,10 +1231,12 @@ var run_stranded = {
 
 // scripts/run/run-stranded-detect.ts
 var STRAND_RECOVERY = `Restart supervision with \`${run_stranded.RECOVERY_COMMAND}\` \u2014 it wakes a fresh successor to claim the budget; the cutting session must not resume it itself.`;
+function targets_of(directory) {
+  return { carry: run_carry.carry_path(directory), wake: run_wake.wake_path(directory) };
+}
 async function real_resolve_targets() {
   const directory = await run_carry.repository_directory();
-  if (directory === void 0) return void 0;
-  return { carry: run_carry.carry_path(directory), wake: run_wake.wake_path(directory) };
+  return directory === void 0 ? void 0 : targets_of(directory);
 }
 async function real_emit_stranded(text2) {
   return await run_event_stream_emit.emit_once(run_event_stream.EVENT_KIND.STRANDED, text2);
@@ -1199,14 +1248,13 @@ var DEFAULT_PORTS3 = {
   resolve_targets: real_resolve_targets,
   read_carry: (target) => run_carry.read_carry(target),
   is_owner_live: run_carry.is_owner_live,
+  has_ended: run_carry_ended.has_ended,
   read_wake: (target) => run_wake.read_wake(target),
   supervisor_liveness: (wake) => run_stranded.supervisor_liveness(wake),
   emit_stranded: real_emit_stranded,
   notify_stranded: real_notify_stranded
 };
-async function gather2(ports) {
-  const targets = await ports.resolve_targets();
-  if (targets === void 0) return void 0;
+function input_at(ports, targets) {
   const read = ports.read_carry(targets.carry);
   if (read.kind !== "carried") return void 0;
   return {
@@ -1215,6 +1263,10 @@ async function gather2(ports) {
     supervisor: ports.supervisor_liveness(ports.read_wake(targets.wake))
   };
 }
+async function gather2(ports) {
+  const targets = await ports.resolve_targets();
+  return targets === void 0 ? void 0 : input_at(ports, targets);
+}
 async function report2(ports, input) {
   if (input.read.kind !== "carried") return;
   const text2 = run_stranded.describe(input.read.carry);
@@ -1233,7 +1285,25 @@ async function run_stranded_check() {
   } catch {
   }
 }
-var run_stranded_detect = { detect_and_report: detect_and_report2, run_stranded_check };
+function is_stranded_at(directory, ports = DEFAULT_PORTS3) {
+  const input = input_at(ports, targets_of(directory));
+  return input !== void 0 && run_stranded.is_stranded(input);
+}
+function is_left_stranded(run, ports = DEFAULT_PORTS3) {
+  const read = ports.read_carry(run.carry_target);
+  if (read.kind !== "carried") return !ports.has_ended(run.ended_target, run.started_at);
+  return run_stranded.is_stranded({
+    read,
+    is_owner_live: run_carry.is_held_by_another(read.carry, ports.is_owner_live),
+    supervisor: run_stranded.GONE
+  });
+}
+var run_stranded_detect = {
+  detect_and_report: detect_and_report2,
+  is_left_stranded,
+  is_stranded_at,
+  run_stranded_check
+};
 
 // scripts/hooks/stop-guard.ts
 async function hold_facts() {
@@ -1295,18 +1365,20 @@ async function outcome_of(raw_payload) {
     return stop_rules.NO_OUTCOME;
   }
 }
-async function has_run_record() {
+async function carried_owner_live() {
   try {
     const directory = await run_carry.repository_directory();
-    if (directory === void 0) return false;
-    return run_carry.read_carry(run_carry.carry_path(directory)).kind === "carried";
+    if (directory === void 0) return void 0;
+    const read = run_carry.read_carry(run_carry.carry_path(directory));
+    return read.kind === "carried" ? run_carry.is_owner_live(read.carry) : void 0;
   } catch {
-    return false;
+    return void 0;
   }
 }
 async function run_report_checks() {
-  if (!await has_run_record()) return;
-  await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS);
+  const is_owner_live = await carried_owner_live();
+  if (is_owner_live === void 0) return;
+  if (is_owner_live) await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS);
   await run_stranded_detect.run_stranded_check();
 }
 async function write_stop_decision(raw_payload) {

package/dist/josh.js

@@ -1867,7 +1867,7 @@ var AI_COMMANDS = {
     // `.env` rather than the ambient environment: the strand notification needs the Telegram
     // credentials, the same reason `run:wake` carries these flags.
     tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Report whether the run is stranded \u2014 budget handed off, owner gone, and no supervisor watching",
+    description: "Report whether the run is stranded \u2014 owner gone, no successor holding the budget, and no supervisor watching",
     category: "AI tools",
     reference: ["", "automation", ["processes", "notifications"]]
   },
@@ -2501,7 +2501,7 @@ var PROJECT_COMMANDS = {
     description: "Set a project up for the GitHub Issue workflow, from git init to the setup PR",
     category: "Project",
     reference: [
-      `${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--init-command <command>]`,
+      `${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--init-command <command>] [--push-preflight-command <command>]`,
       "developer",
       ["files", "git", "network", "processes"]
     ]

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1379.0",
+  "version": "1.1387.0",
   "name": "@joshuafolkken/kit",
   "description": "Development toolkit for AI-assisted projects: formatting, AI assistant rules and a Git/GitHub Issue workflow for any repository, plus lint, type check, tests and hooks for Node projects",
   "keywords": [

package/prompts/collaboration-workflow/upstream-interrupt.md

@@ -18,7 +18,7 @@
 1. **起票する** — `pnpm josh issue:file "<title>" --body-file <path> --depth <n> --route interrupt --label priority:high`。上限は効かない（`wip-cap.md` →「割り込み起票 — 上限が効かない側」の条件 2）
 2. **止まらずに直す** — 壊れた機構を迂回しない（回避策の禁止と、検証ゲートを緩めない規則はここでも変わらない）。`backlogrun` の中では、その割り込みを次の子にし、修正が着地してから塞がれていた子へ戻る。プールから選ぶランでは `priority:high` が先頭に並べ、epic の下では `wip-cap.md` の手順 3 で挿入する。名前を指定したランのドライバーは指定された Issue しか出さないので、`pnpm josh lane:launch <N>` で自分で dispatch する。バッチの外では `wip-cap.md` の手順 4 が変わらず効く — 起票まで済ませ、打つべき `fullrun #<N>` を報告して止まる
 3. **再開できるなら自分で再開し、動くことを確かめる** — 修正のマージ後、再開の手段がある答えには人の打ち直しを求めない。手渡し済みの記録、所有者が死んだ記録、監督プロセスの停止（`warning` Telegram）には `pnpm josh run:wake --start`、`run:carry` の `standing` には `pnpm josh run:carry --resume "<invocation>" --owner "$PPID"` を自分で打つ。そのあと `pnpm josh run:wake --list` が監督プロセスを示し、そのログに次の子の dispatch が現れることを確かめて報告する
-4. **人に打ち直しを求めるのは再開の手段が無いときだけ** — `expired`（8 時間の上限を使い切った）、`mismatch`（別の起動の記録）、別の生きた所有者の `busy`。新しい承認を宣言するのは人だけ、という規則も変わらない
+4. **人に打ち直しを求めるのは再開の手段が無いときだけ** — `mismatch`（別の起動の記録）、別の生きた所有者の `busy`。新しい承認を宣言するのは人だけ、という規則も変わらない
 5. **`needs-decision` を付けない** — ランが自分で直せる不具合は人の判断を要さない（`.claude/skills/workflow-commands/backlogrun-park.md` → "Only a person's judgement carries `needs-decision`"）
 
 手順:

package/scripts/backlog/backlog-budget-cli.ts

@@ -8,7 +8,6 @@ import {
 	type BudgetDecision,
 	type BudgetInput,
 } from './backlog-budget'
-import { backlog_idle } from './backlog-idle'
 
 // The thin half of `josh backlog:budget` (joshuafolkken/kit#1632): read the loop's state off the
 // command line, hand it to the pure decision, print the verdict on stdout and the reason on stderr
@@ -18,7 +17,6 @@ const ARGV_OFFSET = 2
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const JSON_KEY = 'budget'
-const EXHAUSTED_ANSWER: BacklogAnswer = 'exhausted'
 
 const USAGE = `Usage: josh backlog:budget --answer <${backlog_budget.ANSWERS.join('|')}> --started <ISO-8601> [--active <ISO-8601>, required unless the watch is off] [--merged <count>] [--running <count>] [--max <count>] [--idle <minutes>, 0 to turn the watch off] [--json]`
 
@@ -71,7 +69,7 @@ function to_count(raw: string | undefined): number | undefined {
 
 // A flag that was given but could not be read makes the whole invocation unreadable. Falling back to
 // the default instead would answer a question nobody asked — a mistyped `--idle 0` would read as the
-// default 30-minute watch and hold a run open that was asked to finish at its first empty backlog.
+// default watch and hold a run open that was asked to finish at its first empty backlog.
 function is_readable(raw: string | undefined, parsed: number | undefined): boolean {
 	return raw === undefined || parsed !== undefined
 }
@@ -165,27 +163,11 @@ function build_input(values: ParsedValues, now_ms: number): BudgetInput | undefi
 	return input_of(values, { answer, now_ms, started_at_ms })
 }
 
-// The idle window, carried only on the watch an empty backlog opens — the one `idle_decision` reaches,
-// not the draining watch a reached bound returns while children still run — so `backlog:offer` can
-// record when that wait ends (joshuafolkken/kit#3430).
-function idle_of(input: BudgetInput, verdict: string): string | undefined {
-	const is_idle_watch =
-		verdict === backlog_budget.WATCH_VERDICT &&
-		input.answer === EXHAUSTED_ANSWER &&
-		backlog_budget.is_finish(input)
-	const window = is_idle_watch ? backlog_idle.window_of(input) : undefined
-
-	return window === undefined ? undefined : backlog_idle.text_of(window)
-}
-
 function print_json(input: BudgetInput, decision: BudgetDecision): void {
 	const { verdict, reason } = decision
-	const idle = idle_of(input, verdict)
 	const is_finish = backlog_budget.is_finish(input)
 
-	console.info(
-		JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish, ...(idle !== undefined && { idle }) }),
-	)
+	console.info(JSON.stringify({ [JSON_KEY]: verdict, reason, is_finish }))
 }
 
 function refuse(): number {