@joshuafolkken/kit 1.1784.0 → 1.2116.0

package/scripts/issue/trusted-measure.ts

@@ -0,0 +1,84 @@
+import { execSync } from 'node:child_process'
+import { gh_author_association } from '#scripts/gh/gh-author-association'
+import { git_gh_issue_read } from '#scripts/gh/git-gh-issue-read'
+import { parse_json_object_or_undefined } from '#scripts/git/parse-json-array'
+import { error_text } from '#scripts/lib/error-message'
+import { z } from 'zod'
+import { session_cite } from './session-cite'
+
+// Running a command an Issue body names — `josh measure:rerun`'s baselines and the drive's measurement
+// declaration (`measure-declaration.ts`) alike.
+//
+// **The command is shell, and the body is written by whoever filed the Issue**.
+// A baseline needs pipes and loops (`git log … | wc -l`, `for d in $(ls …)`), so an allow-list of
+// commands cannot make it safe; what can is who wrote it. The input is therefore the Issue number, not
+// a file, so the author's `author_association` arrives with the body from the same REST read, and only
+// a body written by someone with write access to the repository is run.
+
+const ISSUE_FIELDS = `body,${gh_author_association.AUTHOR_FIELDS}`
+const UNKNOWN_ASSOCIATION = 'unknown'
+// One command's budget — the same minute `josh-harness.ts` gives one command it spawns. A measurement
+// is a count or a digest that answers in seconds, so a command still running after a minute is stuck,
+// and without a bound it would hold the whole re-measurement open with nothing printed.
+const MEASURE_TIMEOUT_MS = 60_000
+const issue_schema = z.object({
+	body: z.string().nullish(),
+	...gh_author_association.author_fields_schema,
+})
+
+type IssueFields = z.infer<typeof issue_schema>
+type BodyRead = { kind: 'trusted'; body: string } | { kind: 'refused'; reason: string }
+type CommandRun = { kind: 'ok'; output: string } | { kind: 'failed'; message: string }
+
+// The command's stdout, trimmed, or the message a failing or timed-out command threw.
+function run_command(command: string): CommandRun {
+	try {
+		return {
+			kind: 'ok',
+			output: execSync(command, { encoding: 'utf8', timeout: MEASURE_TIMEOUT_MS }).trim(),
+		}
+	} catch (error) {
+		return { kind: 'failed', message: error_text.message_of(error) }
+	}
+}
+
+// The run as one printable value: a failure is spelled in place of the output.
+function text_of(run: CommandRun): string {
+	return run.kind === 'ok' ? run.output : `(command failed: ${run.message})`
+}
+
+async function read_issue(issue_number: string): Promise<IssueFields | undefined> {
+	const json = await git_gh_issue_read.issue_view_json(issue_number, ISSUE_FIELDS)
+
+	return json === undefined ? undefined : parse_json_object_or_undefined(json, issue_schema)
+}
+
+function untrusted(issue_number: string, issue: IssueFields): BodyRead {
+	const association = issue.author_association ?? UNKNOWN_ASSOCIATION
+
+	return {
+		kind: 'refused',
+		reason: `refusing to run the baseline of ${session_cite.issue(issue_number)}: its author (${association}) is not ${gh_author_association.TRUSTED_LIST}`,
+	}
+}
+
+// The body, only when its author can write to the repository. A read that fails is refused as well:
+// an unknown author is not a trusted one.
+async function read_trusted_body(issue_number: string): Promise<BodyRead> {
+	const issue = await read_issue(issue_number)
+
+	if (issue === undefined) {
+		return { kind: 'refused', reason: `could not read issue ${session_cite.issue(issue_number)}` }
+	}
+
+	if (!(await gh_author_association.is_trusted(gh_author_association.author_of(issue)))) {
+		return untrusted(issue_number, issue)
+	}
+
+	return { kind: 'trusted', body: issue.body ?? '' }
+}
+
+const trusted_measure = { read_trusted_body, run_command, text_of }
+
+export type { BodyRead, CommandRun }
+export { trusted_measure }

package/scripts/josh/command-usage.ts

@@ -1,8 +1,9 @@
-import { canonical_command, COMMAND_MAP } from './josh-command-map'
+import { canonical_command } from './josh-aliases'
+import { COMMAND_MAP } from './josh-command-map'
 import type { CommandUsage } from './josh-command-types'
 
 // The single renderer of a command's usage. `josh help <command>` prints it and
-// `tools/document/generate-command-usage.ts` writes it between a reference page's usage markers,
+// `josh command:derive` writes it between a reference page's usage markers,
 // so the terminal and the page are one text (#3932). The usage itself sits on each command's entry
 // (#4185); which page renders it is the page's own `<!-- usage: <command> -->` span.
 

package/scripts/josh/durable-state-migrate.ts

@@ -0,0 +1,105 @@
+import { constants, copyFileSync, lstatSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import { stamp_file } from '#scripts/josh/stamp-file'
+
+// The two upkeep jobs of the durable run-state directory (`durable-state.ts`), each run at most once
+// per process per directory rather than on every record lookup.
+//
+// **A legacy record is copied once per directory.** A run that is going when
+// this lands wrote its records to `/tmp`, and reading only the new place would end it as a reboot
+// did. Copying on every lookup instead brought back a record a run removed on purpose — an ended
+// carry, a stopped launch, a failed ship's result — from the `/tmp` original. The original is left
+// in place: a lane or parent still on the code before this change reads `/tmp` until it merges main.
+// A copy rather than a rename because `/tmp` is often another filesystem. A record an old-code
+// process writes to `/tmp` after the copy is not picked up.
+//
+// **A log not written for two weeks is removed.** `/tmp` used to clear them on every boot; the common
+// git directory never does, and a log is the only record here that grows without an owner ending it.
+
+const COPIED_MARKER = '.legacy-copied'
+const MARKER_MODE = 0o600
+const LOG_RETENTION_DAYS = 14
+const DAY_MS = 86_400_000
+const LOG_SUFFIX = '.log'
+// What a record is. A lock or a staged write beside a record carries its prefix but means nothing
+// past the process that made it.
+const RECORD_SUFFIXES = ['.json', '.jsonl', LOG_SUFFIX] as const
+
+function is_record_name(name: string, prefixes: ReadonlyArray<string>): boolean {
+	const has_prefix = prefixes.some((prefix) => name.startsWith(prefix))
+
+	return has_prefix && RECORD_SUFFIXES.some((suffix) => name.endsWith(suffix))
+}
+
+function list_names(directory: string): Array<string> {
+	try {
+		return readdirSync(directory)
+	} catch {
+		return []
+	}
+}
+
+function copy_record(from: string, to: string): void {
+	try {
+		if (!stamp_file.is_own_regular_file(from)) return
+
+		copyFileSync(from, to, constants.COPYFILE_EXCL)
+	} catch {
+		// Another process wrote it first, or the copy failed; either way nothing is overwritten.
+	}
+}
+
+function copy_legacy(from: string, to: string, prefixes: ReadonlyArray<string>): void {
+	if (from === to) return
+
+	for (const name of list_names(from)) {
+		if (is_record_name(name, prefixes)) copy_record(path.join(from, name), path.join(to, name))
+	}
+}
+
+// The marker is created exclusively, so one process wins the copy. A marker rather than whether
+// `mkdirSync` made the directory: a lane on this code can create the shared directory before the run
+// that owns the `/tmp` records switches over, and that run still needs its copy.
+function claim_copy(directory: string): boolean {
+	try {
+		writeFileSync(path.join(directory, COPIED_MARKER), '', { flag: 'wx', mode: MARKER_MODE })
+
+		return true
+	} catch {
+		return false
+	}
+}
+
+function copy_once(from: string, to: string, prefixes: ReadonlyArray<string>): void {
+	if (claim_copy(to)) copy_legacy(from, to, prefixes)
+}
+
+function is_stale(target: string, now_ms: number): boolean {
+	const age_ms = now_ms - lstatSync(target).mtimeMs
+
+	return age_ms > LOG_RETENTION_DAYS * DAY_MS && stamp_file.is_own_regular_file(target)
+}
+
+function prune_log(target: string, now_ms: number): void {
+	try {
+		if (is_stale(target, now_ms)) rmSync(target, { force: true })
+	} catch {
+		// Gone already, or not ours to remove.
+	}
+}
+
+function prune_stale_logs(
+	directory: string,
+	prefixes: ReadonlyArray<string>,
+	now_ms: number,
+): void {
+	for (const name of list_names(directory)) {
+		if (name.endsWith(LOG_SUFFIX) && is_record_name(name, prefixes)) {
+			prune_log(path.join(directory, name), now_ms)
+		}
+	}
+}
+
+const durable_state_migrate = { LOG_RETENTION_DAYS, copy_once, is_record_name, prune_stale_logs }
+
+export { durable_state_migrate }

package/scripts/josh/durable-state.ts

@@ -0,0 +1,112 @@
+import { mkdirSync } from 'node:fs'
+import path from 'node:path'
+import { git_common_directory } from '#scripts/git/git-common-directory'
+import { durable_state_migrate } from '#scripts/josh/durable-state-migrate'
+import { PLATFORM_TEMP_ROOT, platform_temporary } from '#scripts/josh/platform-temporary'
+import { stamp_file } from '#scripts/josh/stamp-file'
+
+// **Which record goes where — the one place this is decided.** A record a run has to read again after
+// the machine restarts lives here, in the common git directory: the carry and ended records, the event
+// stream, the lane state and ledger, the wake log, the backlogrun launch record and log, the detached
+// ship's log and result, and a lane child's dispatch log. macOS empties `/tmp` on every boot, and losing them
+// there left the open lanes stateless, the merge statistics empty and a parked ship's failure
+// unreadable. Everything that means nothing past the process that wrote it — a lock, a pid, a socket,
+// a per-process cache — stays in `PLATFORM_TEMP_ROOT`, where a reboot clearing it is the right answer.
+//
+// **The common git directory rather than the home directory**, because a Codex lane's sandbox reads
+// `$HOME` but may write the common git directory (`codex-agent-argv.ts`), and every lane of one
+// repository shares it. A repository's own clone is also where `review-stops.jsonl` already lives.
+// Outside a repository there is no such directory, and the record falls back to the temp root.
+//
+// **Records a run left in `/tmp` are copied in once per directory, and a log not written for two
+// weeks is removed** (`durable-state-migrate.ts`).
+//
+// **`JOSH_TEMP_ROOT` moves this root too**, into a directory of its own beneath the override, so the unit
+// suite's network guard keeps every record of a test run out of the live one exactly as before.
+const RUN_STATE_DIRECTORY = 'run-state'
+const OVERRIDE_STATE_DIRECTORY = 'josh-state'
+const STATE_DIRECTORY_MODE = 0o700
+
+function state_root(override: string | undefined, common: string | undefined): string {
+	if (override !== undefined && override !== '') {
+		return path.join(override, OVERRIDE_STATE_DIRECTORY)
+	}
+
+	if (common === undefined) return PLATFORM_TEMP_ROOT
+
+	return path.join(common, git_common_directory.STATE_DIRECTORY, RUN_STATE_DIRECTORY)
+}
+
+// Read once at import, as `PLATFORM_TEMP_ROOT` is, so both roots answer for the same override.
+const STATE_ROOT_OVERRIDE = process.env[platform_temporary.TEMP_ROOT_KEY]
+
+// The root for a named common git directory — what a launcher grants a sandboxed child before it runs.
+function root_for(common: string | undefined): string {
+	return state_root(STATE_ROOT_OVERRIDE, common)
+}
+
+function root(): string {
+	return root_for(git_common_directory.repository())
+}
+
+// Every record kept here, by the prefix of its file name — the list the one-time copy from `/tmp`
+// walks, so a record added here is carried over with the rest.
+const PREFIX = {
+	CARRY: 'josh-run-carry-',
+	ENDED: 'josh-run-ended-',
+	EVENTS: 'josh-run-events-',
+	LANE_STATE: 'josh-lane-state-',
+	LANE_LEDGER: 'josh-lane-ledger-',
+	WAKE_LOG: 'josh-run-wake-log-',
+	BACKLOGRUN_LAUNCH: 'josh-backlogrun-launch-',
+	BACKLOGRUN_LOG: 'josh-backlogrun-log-',
+	SHIP_LOG: 'josh-ship-log-',
+	SHIP_RESULT: 'josh-ship-result-',
+	LANE_DISPATCH: 'josh-lane-dispatch-',
+	LANE_PLAN: 'josh-lane-plan-',
+} as const
+
+const PREFIXES: ReadonlyArray<string> = Object.values(PREFIX)
+
+// Directories this process has already made ready, so the upkeep runs once rather than per lookup.
+const ensured = new Set<string>()
+
+function prepare(directory: string): void {
+	mkdirSync(directory, { recursive: true, mode: STATE_DIRECTORY_MODE })
+	durable_state_migrate.copy_once(PLATFORM_TEMP_ROOT, directory, PREFIXES)
+	durable_state_migrate.prune_stale_logs(directory, PREFIXES, Date.now())
+}
+
+// **A directory that cannot be created answers the temp root rather than throwing** — a sandbox that
+// may not write the common git directory still runs, with the records `/tmp` always held.
+function ensure(directory: string): string {
+	if (ensured.has(directory)) return directory
+
+	try {
+		prepare(directory)
+	} catch {
+		return PLATFORM_TEMP_ROOT
+	}
+
+	ensured.add(directory)
+
+	return directory
+}
+
+// The durable counterpart of `stamp_file.stamp_path`: the same per-account, per-key file name, in the
+// directory above. The directory is created on the way, private to the account.
+function durable_path(prefix: string, key_root: string, suffix?: string): string {
+	return path.join(ensure(root()), stamp_file.stamp_name(prefix, key_root, suffix))
+}
+
+const durable_state = {
+	PREFIX,
+	STATE_DIRECTORY_MODE,
+	ensure,
+	path: durable_path,
+	root,
+	root_for,
+	state_root,
+}
+
+export { durable_state }

package/scripts/josh/josh-aliases.ts

@@ -0,0 +1,95 @@
+// The `josh` subcommand aliases, in a leaf of their own (joshuafolkken/kit#5128).
+//
+// **A reader that only expands an alias imports no command table.** The table (`josh-command-map.ts`)
+// imports every command module, so a module that imported it for `canonical_command` alone — the shell
+// and bundle readers of `josh time` — carried every command module into each test that reached it, and
+// a one-line change to any command table re-ran hundreds of unrelated tests under `josh test:related`.
+
+const ALIASES: Record<string, string> = {
+	ga: 'gate',
+	l: 'lint',
+	lr: 'lint:related',
+	cr: 'check:related',
+	ln: 'lines',
+	by: 'bytes',
+	mt: 'metrics',
+	f: 'format',
+	sd: 'cspell:dot',
+	bh: 'behavior',
+	eu: 'exports:unused',
+	t: 'test',
+	tu: 'test:unit',
+	tr: 'test:related',
+	td: 'test:declared',
+	trd: 'test:red',
+	tpn: 'test:pinned',
+	te: 'test:e2e',
+	c: 'check',
+	pt: 'port',
+	i: 'init',
+	pf: 'profile',
+	st: 'start',
+	sy: 'sync',
+	un: 'uninstall',
+	g: 'git',
+	gp: 'pr',
+	ms: 'main:sync',
+	mm: 'main:merge',
+	bp: 'bump',
+	re: 'release',
+	v: 'version',
+	r: 'ranges',
+	dr: 'doctor',
+	rc: 'ruleset:check',
+	pg: 'propagate',
+	ad: 'adopt',
+	ov: 'overrides',
+	a: 'audit',
+	rt: 'reconcile-templates',
+	cdv: 'command:derive',
+	u: 'latest',
+	lc: 'latest:corepack',
+	lu: 'latest:update',
+	tm: 'time',
+	tmd: 'time:density',
+	rtr: 'retrospective',
+	ca: 'cost:audit',
+	rvf: 'review:findings',
+	rvs: 'review:stops',
+	ruv: 'rule:value',
+	ev: 'eval',
+	fr: 'fresh:run',
+	as: 'auth:setup',
+	lsm: 'lane:sample',
+	lst: 'lane:stats',
+	lva: 'lane:value',
+	lnt: 'lane:net',
+	lbd: 'lane:breakdown',
+	lli: 'lane:limit',
+	lrs: 'lane:restart',
+	lwd: 'lane:withdraw',
+	lps: 'lane:pause',
+	lru: 'lane:resume',
+	lad: 'lane:adopt',
+	blr: 'backlogrun',
+}
+
+// The canonical name of a `josh` subcommand: an alias expands, and anything else passes through
+// unchanged.
+//
+// **The expansion is one rule, so it lives beside the table it reads.** Two readers had each written
+// their own `ALIASES[name] ?? name` — the layer report and the gate-run count — and a third, the run
+// measurement's command key, had not, so `pnpm josh ga` and `pnpm josh gate` were measured as two
+// different commands. A lookup is small enough to copy and exactly the kind of copy that drifts: the
+// two that had it disagreed with the one that did not about whether a call was the gate.
+//
+// **`Object.hasOwn` rather than a bare lookup**, because a subcommand spelled like a member of
+// `Object.prototype` — `constructor`, `toString` — would otherwise come back as that member instead
+// of as itself, and the caller would key a call by something that is not a command name at all.
+function canonical_command(name: string): string {
+	if (!Object.hasOwn(ALIASES, name)) return name
+
+	return ALIASES[name] ?? name
+}
+
+export { ALIASES, canonical_command }

package/scripts/josh/josh-command-map.ts

@@ -31,86 +31,5 @@ const COMMAND_MAP: Record<string, CommandEntry> = {
 	...CLONE_COMMANDS,
 }
 
-const ALIASES: Record<string, string> = {
-	ga: 'gate',
-	l: 'lint',
-	lr: 'lint:related',
-	ln: 'lines',
-	by: 'bytes',
-	mt: 'metrics',
-	f: 'format',
-	sd: 'cspell:dot',
-	bh: 'behavior',
-	eu: 'exports:unused',
-	t: 'test',
-	tu: 'test:unit',
-	tr: 'test:related',
-	td: 'test:declared',
-	trd: 'test:red',
-	tpn: 'test:pinned',
-	te: 'test:e2e',
-	c: 'check',
-	pt: 'port',
-	i: 'init',
-	pf: 'profile',
-	st: 'start',
-	sy: 'sync',
-	un: 'uninstall',
-	g: 'git',
-	gp: 'pr',
-	ms: 'main:sync',
-	mm: 'main:merge',
-	bp: 'bump',
-	re: 'release',
-	v: 'version',
-	r: 'ranges',
-	dr: 'doctor',
-	rc: 'ruleset:check',
-	pg: 'propagate',
-	ad: 'adopt',
-	ov: 'overrides',
-	a: 'audit',
-	rt: 'reconcile-templates',
-	u: 'latest',
-	lc: 'latest:corepack',
-	lu: 'latest:update',
-	tm: 'time',
-	tmd: 'time:density',
-	rtr: 'retrospective',
-	ca: 'cost:audit',
-	rvf: 'review:findings',
-	rvs: 'review:stops',
-	ruv: 'rule:value',
-	ev: 'eval',
-	fr: 'fresh:run',
-	as: 'auth:setup',
-	lsm: 'lane:sample',
-	lst: 'lane:stats',
-	lli: 'lane:limit',
-	lrs: 'lane:restart',
-	lwd: 'lane:withdraw',
-	lps: 'lane:pause',
-	lru: 'lane:resume',
-	blr: 'backlogrun',
-}
-
-// The canonical name of a `josh` subcommand: an alias expands, and anything else passes through
-// unchanged.
-//
-// **The expansion is one rule, so it lives beside the table it reads.** Two readers had each written
-// their own `ALIASES[name] ?? name` — the layer report and the gate-run count — and a third, the run
-// measurement's command key, had not, so `pnpm josh ga` and `pnpm josh gate` were measured as two
-// different commands. A lookup is small enough to copy and exactly the kind of copy that drifts: the
-// two that had it disagreed with the one that did not about whether a call was the gate.
-//
-// **`Object.hasOwn` rather than a bare lookup**, because a subcommand spelled like a member of
-// `Object.prototype` — `constructor`, `toString` — would otherwise come back as that member instead
-// of as itself, and the caller would key a call by something that is not a command name at all.
-function canonical_command(name: string): string {
-	if (!Object.hasOwn(ALIASES, name)) return name
-
-	return ALIASES[name] ?? name
-}
-
 export type { CommandCategory, CommandEntry } from './josh-command-types'
-export { ALIASES, CATEGORY_ORDER, COMMAND_MAP, canonical_command }
+export { CATEGORY_ORDER, COMMAND_MAP }

package/scripts/josh/josh-commands-agent-hooks.ts

@@ -26,17 +26,17 @@ const AGENT_HOOK_COMMANDS: Record<string, CommandEntry> = {
 		category: 'Development',
 		reference: ['', 'automation', ['none']],
 		usage: { examples: [{ arguments: '', note: PRE_TOOL_USE }] },
-		// **No `tsx_arguments`, deliberately.** `JOSH_BATCH_GUARD` and the other guard switches are
-		// per-machine preferences kept in `.env`, which every other command reads through
-		// `OPTIONAL_ENV_FILE_FLAGS` — but declaring any `tsx_arguments` disqualifies a command from
-		// in-process dispatch (`josh-in-process.ts`), and this is the one PreToolUse hook consumers run
+		// **No `tsx_arguments`, deliberately.** The guards read `.env` for their other values, as other
+		// commands do through `OPTIONAL_ENV_FILE_FLAGS`; the guard switches themselves come from the
+		// launch environment alone (`josh-environment-file.ts`). But declaring any `tsx_arguments`
+		// disqualifies a command from in-process dispatch (`josh-in-process.ts`), and this is the one PreToolUse hook consumers run
 		// before every guarded call, where a second ~0.16 s tsx start is not affordable. Each guard it
 		// composes loads `.env` through the shared loader instead.
 	},
 	'stop:guard': {
 		script: 'scripts/hooks/stop-guard.ts',
 		description:
-			'Claude Code Stop hook: send the hold notify, release the hold and print the issue citations itself; block on the rules that need the model (reads the Stop payload on stdin)',
+			'Claude Code Stop hook: send the hold notify and release the hold itself; block on the rules that need the model (reads the Stop payload on stdin)',
 		category: 'Development',
 		reference: ['', 'automation', ['none']],
 		usage: {
@@ -59,7 +59,7 @@ const AGENT_HOOK_COMMANDS: Record<string, CommandEntry> = {
 		},
 		// **No `tsx_arguments`, deliberately**, the same as `pretool:guard` above: this runs on every
 		// `UserPromptSubmit`, so it must stay eligible for in-process dispatch rather than pay a second
-		// tsx start each turn. It calls `process.loadEnvFile` itself through the shared loader.
+		// tsx start each turn. It loads `.env` itself through the shared loader.
 	},
 	'codex:hook-adapter': {
 		script: 'scripts/hooks/codex-hook-adapter.ts',

package/scripts/josh/josh-commands-ai.ts

@@ -1,4 +1,4 @@
-import { core_budget } from '#scripts/gate/core-budget'
+import { core_weights } from '#scripts/gate/core-weights'
 import type { CommandEntry } from './josh-command-types'
 import { BACKLOG_COMMANDS } from './josh-commands-backlog'
 import { DOCUMENT_COMMANDS } from './josh-commands-document'
@@ -82,7 +82,7 @@ const AI_COMMANDS: Record<string, CommandEntry> = {
 			examples: [
 				{
 					arguments: '--cut',
-					note: 'compare billed input per request with the shared 135,000 context-cut threshold',
+					note: 'compare billed input per request with the context-cut threshold priced at the session model',
 				},
 				{ arguments: '--over <tokens>', note: 'compare with an explicit limit' },
 				{ arguments: `--cut ${PATH_DIR}`, note: 'Anthropic project or current OpenAI worktree' },
@@ -179,7 +179,7 @@ const AI_COMMANDS: Record<string, CommandEntry> = {
 				{
 					names: [PATH_DIR],
 					description:
-						"read another project's lane transcripts, as `josh time` does. Run it from the main checkout — a lane reads only its own transcript.",
+						"read another project's lane transcripts, as `josh time` does. Run from a lane, it reads its main checkout's lanes.",
 				},
 			],
 		},
@@ -190,8 +190,8 @@ const AI_COMMANDS: Record<string, CommandEntry> = {
 			"Aggregate a finished run's cost, review findings, observation ledger and events into one digest",
 		category: 'AI tools',
 		reference: ['', 'maintainer', ['none']],
-		core_weight: core_budget.CORE_WEIGHTS.retrospective,
-		memory_mb: core_budget.MEMORY_MB.retrospective,
+		core_weight: core_weights.CORE_WEIGHTS.retrospective,
+		memory_mb: core_weights.MEMORY_MB.retrospective,
 		// Kit-only: it reads kit's own development run — the transcript store, the review ledger and the
 		// run event stream — so it means nothing in a consumer project and is dropped from a consumer's
 		// help, through the same declaration `josh time` uses for the same reason.