@krapht/ork 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/list-BUb5Uc3H.mjs

@@ -1,117 +0,0 @@
-import { Bt as lines, Rt as git, zt as gitOk } from "./src-BeR6f70A.mjs";
-import { existsSync } from "node:fs";
-// ../core/src/worktree/list.ts
-/**
-* @file What `ork worktrees` shows: every worktree and branch Ork's runs
-*   recorded creating, whatever the project's git rules named them, and any
-*   `ork/*` branch besides, with their state read from git itself. What clean
-*   and remove do with them is clean.ts.
-*/
-/**
-* The worktrees the project's runs recorded creating, oldest run first; one
-* entry per branch or folder, from the latest run that created it.
-*/
-const createdWorktrees = (store, project) => {
-	const byName = /* @__PURE__ */ new Map();
-	for (const run of store.runs({ project }).toReversed()) for (const { event } of store.events(run.id)) {
-		if (event.type !== "worktree" || event.action !== "created") continue;
-		byName.set(event.branch ?? event.path, {
-			runId: run.id,
-			nodeId: event.id,
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch }
-		});
-	}
-	return [...byName.values()];
-};
-const parsePorcelain = (text) => text.split("\n\n").map((block) => lines(block)).map((fields) => {
-	const value = (key) => fields.find((f) => f.startsWith(`${key} `))?.slice(key.length + 1);
-	return {
-		path: value("worktree") ?? "",
-		branch: (value("branch") ?? "").replace(/^refs\/heads\//u, ""),
-		prunable: fields.some((f) => f.startsWith("prunable"))
-	};
-}).filter((entry) => entry.path !== "");
-/**
-* The `ork/<run>/<node>` branches of runs that recorded nothing; with no path
-* recorded, the worktree is whichever has the branch checked out.
-*/
-const prefixed = (branch) => {
-	const [, runId = "", ...rest] = branch.split("/");
-	return {
-		runId,
-		nodeId: rest.join("/"),
-		path: "",
-		branch
-	};
-};
-/** How many commits a detached worktree holds that no branch, tag or remote has. */
-const onNoBranch = async (entry) => entry === void 0 ? "0" : (await git(entry.path, [
-	"rev-list",
-	"--count",
-	"HEAD",
-	"--not",
-	"--branches",
-	"--tags",
-	"--remotes"
-])).stdout;
-/** One created worktree or branch, with its state read from git. */
-const stateOf = async (root, entries, item, recorded) => {
-	const { branch } = item;
-	const entry = branch === void 0 || item.path !== "" ? entries.find((e) => e.path === item.path) : entries.find((e) => e.branch === branch);
-	const holder = branch === void 0 ? void 0 : entries.find((e) => e.branch === branch && e.path !== entry?.path);
-	const missing = entry !== void 0 && (entry.prunable || !existsSync(entry.path));
-	const status = entry === void 0 || missing ? "" : (await git(entry.path, ["status", "--porcelain"])).stdout;
-	const checkedOut = branch === void 0 && entry !== void 0 && entry.branch !== "" ? entry.branch : void 0;
-	const on = branch ?? checkedOut;
-	const counted = on === void 0 ? await onNoBranch(entry === void 0 || missing ? void 0 : entry) : (await git(root, [
-		"rev-list",
-		"--count",
-		`HEAD..${on}`
-	])).stdout;
-	const ahead = Number(counted);
-	const changes = lines(status).length;
-	return {
-		...branch === void 0 ? {} : { branch },
-		...checkedOut === void 0 ? {} : { checkedOut },
-		runId: item.runId,
-		nodeId: item.nodeId,
-		recorded,
-		path: entry?.path ?? null,
-		missing,
-		dirty: changes > 0,
-		changes,
-		ahead: Number.isNaN(ahead) ? 0 : ahead,
-		merged: on !== void 0 && ahead === 0,
-		inMainCheckout: entry?.path === root || holder?.path === root,
-		...holder === void 0 || holder.path === root ? {} : { heldBy: holder.path }
-	};
-};
-/**
-* Every worktree and branch Ork's runs created in the repository at `root`,
-* with its state: those the runs recorded (`created`, whatever the project's
-* git rules named them), and any `ork/` branch besides. A recorded one that git
-* no longer has is left out.
-*/
-const listOrkWorktrees = async (root, created = []) => {
-	const entries = parsePorcelain(await gitOk(root, [
-		"worktree",
-		"list",
-		"--porcelain"
-	]));
-	const branches = lines(await gitOk(root, [
-		"for-each-ref",
-		"--format=%(refname:short)",
-		"refs/heads/"
-	]));
-	const recordedBranches = new Set(created.flatMap((c) => c.branch ?? []));
-	const items = [...created.filter((c) => c.branch === void 0 ? entries.some((e) => e.path === c.path) : branches.includes(c.branch)).map((item) => ({
-		item,
-		recorded: true
-	})), ...branches.filter((b) => b.startsWith("ork/") && !recordedBranches.has(b)).map((b) => ({
-		item: prefixed(b),
-		recorded: false
-	}))];
-	return Promise.all(items.map(({ item, recorded }) => stateOf(root, entries, item, recorded)));
-};
-export { listOrkWorktrees as n, createdWorktrees as t };

package/dist/remove-BkFWGVYo.mjs

@@ -1,201 +0,0 @@
-import { Bt as lines, Rt as git, _t as liveStatus } from "./src-BeR6f70A.mjs";
-import { n as listOrkWorktrees, t as createdWorktrees } from "./list-BUb5Uc3H.mjs";
-import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-Bh4KZgzc.mjs";
-// ../core/src/worktree/words.ts
-/**
-* @file The plain words for what `ork worktrees` shows, in one place, so the
-*   CLI and the Worktrees panel say the same thing: an item's name, its merge
-*   state, its state as parts (each marked when it's work that removing would
-*   lose), a plan's line, and why an item can't be removed. The CLI colors
-*   them; the panel lays them out.
-*/
-/** An item's name: its branch, or its run and node when created detached. */
-const labelOf = (item) => item.branch ?? `${item.runId}/${item.nodeId}`;
-/** Merged into the current branch, not, or detached on no branch at all. */
-const mergeStateOf = (item) => {
-	if (item.branch === void 0 && item.checkedOut === void 0) return "detached";
-	return item.merged ? "merged" : "unmerged";
-};
-/** `3 commits`, `1 commit`. */
-const counted = (count, noun) => `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
-/**
-* An item's state, in order: where its worktree is when it isn't plain, the
-* workflow's own branch, uncommitted changes, unmerged or unreachable commits,
-* and the main checkout or another worktree holding the branch. `into` names
-* the branch "not merged" is measured against, when the words should say it.
-*/
-const stateParts = (item, into) => {
-	const parts = [];
-	const part = (text, risk = false) => {
-		parts.push({
-			text,
-			risk
-		});
-	};
-	if (item.path === null) part("no worktree");
-	else if (item.missing) part("missing (prunable)");
-	if (item.checkedOut !== void 0) part(`on the workflow's branch ${item.checkedOut}`);
-	if (item.dirty) part("uncommitted changes", true);
-	const state = mergeStateOf(item);
-	if (state === "unmerged") {
-		const where = into === void 0 ? "" : ` into ${into}`;
-		part(`${counted(item.ahead, "commit")} not merged${where}`);
-	}
-	if (state === "detached") {
-		if (item.ahead > 0) part(`${counted(item.ahead, "commit")} on no branch`, true);
-		else if (item.path !== null && !item.missing) part("nothing committed");
-	}
-	if (!item.recorded) part("not created by Ork");
-	if (item.inMainCheckout) part("checked out in the main checkout");
-	if (item.heldBy !== void 0) part(`checked out in ${item.heldBy}`);
-	return parts;
-};
-/** What a step does, as a plan says it. */
-const planWhat = (step) => {
-	const actions = [
-		...step.removeWorktree ? ["remove worktree"] : [],
-		...stepPrunes(step) && !step.removeWorktree ? ["prune worktree"] : [],
-		...step.deleteBranch ? ["delete branch"] : []
-	];
-	return actions.length > 0 ? actions.join(" + ") : "keep";
-};
-/** `ork/r1/lead: remove worktree`, `r1/check (detached): keep (…)`. */
-const planLine = (step) => {
-	const { item } = step;
-	return {
-		text: `${item.branch === void 0 && item.checkedOut === void 0 ? `${labelOf(item)} (detached)` : labelOf(item)}: ${planWhat(step)}`,
-		...step.skip === void 0 ? {} : { reason: step.skip }
-	};
-};
-/**
-* Why an item can't be removed at all, even forced, if it can't: no run
-* recorded creating it, the main checkout or a worktree Ork didn't create holds
-* it, or its run is still going.
-*/
-const removeRefusal = (item, live) => {
-	if (!item.recorded) return "not created by Ork (no run recorded it); delete it with git if it's yours to delete";
-	if (item.inMainCheckout) return "checked out in the main checkout; switch it to another branch first";
-	if (item.heldBy !== void 0) return `checked out in ${item.heldBy}, a worktree Ork didn't create; switch it to another branch first`;
-	return live ? `run ${item.runId} is still going; stop it first` : void 0;
-};
-// ../core/src/worktree/remove.ts
-/** The ids of the project's runs whose process is still going. */
-const liveRunIds = (store, root) => new Set(store.runs({ project: root }).filter((run) => liveStatus(run) === "running").map((run) => run.id));
-/**
-* Whether `root` is a repository with a commit, and the branch checked out
-* there, which "merged" means merged into (null when its HEAD is detached).
-*/
-const projectHead = async (root) => {
-	if ((await git(root, [
-		"rev-parse",
-		"--verify",
-		"--quiet",
-		"HEAD"
-	])).code !== 0) return { ok: false };
-	const answer = await git(root, [
-		"symbolic-ref",
-		"--short",
-		"-q",
-		"HEAD"
-	]);
-	return {
-		ok: true,
-		branch: answer.code === 0 ? answer.stdout.trim() : null
-	};
-};
-/** The top of the repository `cwd` is in, even one with no commit yet. */
-const repoRoot = async (cwd) => {
-	const top = await git(cwd, ["rev-parse", "--show-toplevel"]);
-	return top.code === 0 ? top.stdout.trim() : null;
-};
-/** What Ork created in the repo at `root`, from its runs' records and git. */
-const readWorktrees = async (store, root) => ({
-	items: await listOrkWorktrees(root, createdWorktrees(store, root)),
-	live: liveRunIds(store, root)
-});
-/**
-* The plan to remove one item, named by `keyOf`. A branch with no worktree is
-* removed by deleting it, so `deleteBranch` is implied there.
-*/
-const planRemove = ({ items, live }, key, deleteBranch) => {
-	const item = items.find((i) => keyOf(i) === key);
-	if (item === void 0) return {
-		ok: false,
-		error: `No Ork worktree or branch ${key}.`,
-		gone: true
-	};
-	const refusal = removeRefusal(item, live.has(item.runId));
-	if (refusal !== void 0) return {
-		ok: false,
-		error: `Can't remove ${labelOf(item)}: ${refusal}.`,
-		gone: false
-	};
-	const branches = item.branch !== void 0 && (deleteBranch || item.path === null);
-	const careful = cleanStep(item, {
-		branches,
-		force: false,
-		live
-	});
-	if (careful.skip === void 0) return {
-		ok: true,
-		plan: {
-			step: careful,
-			force: false
-		}
-	};
-	return {
-		ok: true,
-		plan: {
-			step: cleanStep(item, {
-				branches,
-				force: true,
-				live
-			}),
-			force: true
-		}
-	};
-};
-const out = async (cwd, args) => lines((await git(cwd, args)).stdout);
-/** What carrying out `plan` would lose, read from git. */
-const lostWork = async (root, { step }) => {
-	const { item } = step;
-	const inside = item.path !== null && !item.missing ? item.path : null;
-	const changes = inside !== null && item.dirty && step.removeWorktree ? await out(inside, ["status", "--porcelain"]) : [];
-	if (step.deleteBranch && item.branch !== void 0 && !item.merged) return {
-		changes,
-		commits: await out(root, [
-			"log",
-			"--oneline",
-			`HEAD..${item.branch}`
-		]),
-		commitsOn: "unmerged"
-	};
-	if (item.branch === void 0 && item.checkedOut === void 0 && inside !== null && item.ahead > 0 && step.removeWorktree) return {
-		changes,
-		commits: await out(inside, [
-			"log",
-			"--oneline",
-			"HEAD",
-			"--not",
-			"--branches",
-			"--tags",
-			"--remotes"
-		]),
-		commitsOn: "no branch"
-	};
-	return {
-		changes,
-		commits: [],
-		commitsOn: null
-	};
-};
-/**
-* Carries out a remove plan; what it did goes into `done` as it goes. The
-* caller has checked that a plan needing `force` was asked to force. It touches
-* only its own item, as each of clean's steps does.
-*/
-const applyRemove = async (root, { step, force }, done = []) => {
-	await applyStep(root, step, force, done);
-	return done;
-};
-export { readWorktrees as a, mergeStateOf as c, stateParts as d, projectHead as i, planLine as l, lostWork as n, repoRoot as o, planRemove as r, labelOf as s, applyRemove as t, removeRefusal as u };

package/dist/report-CEN8VoUb.mjs

@@ -1,140 +0,0 @@
-// ../core/src/usage/report.ts
-const USAGE_DIMENSIONS = [
-	"day",
-	"week",
-	"month",
-	"workflow",
-	"node",
-	"model",
-	"driver",
-	"project"
-];
-const pad = (value) => String(value).padStart(2, "0");
-/** `2026-11-03`, in the machine's own time zone. */
-const dayOf = (date) => `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
-/** The Monday of a time's week. */
-const weekOf = (date) => {
-	const monday = new Date(date);
-	monday.setDate(date.getDate() - (date.getDay() + 6) % 7);
-	return dayOf(monday);
-};
-const KEYS = {
-	day: (row) => dayOf(new Date(row.at)),
-	week: (row) => weekOf(new Date(row.at)),
-	month: (row) => dayOf(new Date(row.at)).slice(0, 7),
-	workflow: (row) => row.workflow,
-	node: (row) => `${row.workflow}/${row.template ?? row.node}`,
-	model: (row) => row.model ?? "unknown",
-	driver: (row) => row.driver ?? "unknown",
-	project: (row) => row.project
-};
-const TIMES = /* @__PURE__ */ new Set([
-	"day",
-	"week",
-	"month"
-]);
-/** Dimensions a tool command has no value in. */
-const SESSION_ONLY = /* @__PURE__ */ new Set(["model", "driver"]);
-const totalsOf = (rows, cpu) => {
-	const totals = {
-		costUsd: 0,
-		inputTokens: 0,
-		outputTokens: 0,
-		cacheReadTokens: 0,
-		cacheWriteTokens: 0,
-		turns: 0,
-		durationMs: 0,
-		sessions: rows.length,
-		runs: new Set(rows.map((row) => row.runId)).size,
-		failedUsd: 0,
-		reworkUsd: 0,
-		chatUsd: 0,
-		cacheHitRate: 0,
-		cpuMs: cpu.reduce((sum, row) => sum + row.userMs + row.systemMs, 0)
-	};
-	for (const row of rows) {
-		totals.costUsd += row.costUsd;
-		totals.inputTokens += row.inputTokens;
-		totals.outputTokens += row.outputTokens;
-		totals.cacheReadTokens += row.cacheReadTokens;
-		totals.cacheWriteTokens += row.cacheWriteTokens;
-		totals.turns += row.turns;
-		totals.durationMs += row.durationMs;
-		if (row.failed) totals.failedUsd += row.costUsd;
-		if (row.kind === "chat") totals.chatUsd += row.costUsd;
-		else if (row.round > 1) totals.reworkUsd += row.costUsd;
-	}
-	const read = totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens;
-	totals.cacheHitRate = read === 0 ? 0 : totals.cacheReadTokens / read;
-	return totals;
-};
-const groupBy = (rows, cpu, dimension) => {
-	const buckets = /* @__PURE__ */ new Map();
-	const bucketOf = (row) => {
-		const key = KEYS[dimension](row);
-		const found = buckets.get(key);
-		if (found !== void 0) return found;
-		const fresh = {
-			rows: [],
-			cpu: []
-		};
-		buckets.set(key, fresh);
-		return fresh;
-	};
-	for (const row of rows) bucketOf(row).rows.push(row);
-	if (!SESSION_ONLY.has(dimension)) for (const row of cpu) bucketOf(row).cpu.push(row);
-	const groups = [...buckets].map(([key, bucket]) => Object.assign(totalsOf(bucket.rows, bucket.cpu), { key }));
-	return TIMES.has(dimension) ? groups.toSorted((a, b) => a.key.localeCompare(b.key)) : groups.toSorted((a, b) => b.costUsd - a.costUsd);
-};
-/** Below this, a percentage says nothing worth acting on. */
-const MIN_SPEND_USD = .5;
-const REWORK_SHARE = .2;
-const FAILED_SHARE = .1;
-const CONCENTRATED_SHARE = .5;
-const LOW_CACHE_RATE = .5;
-const MIN_CACHE_TOKENS = 1e5;
-const percent = (share) => `${String(Math.round(share * 100))}%`;
-const hintsOf = (totals, nodes) => {
-	const spend = totals.costUsd;
-	if (spend < MIN_SPEND_USD) return [];
-	const hints = [];
-	if (totals.reworkUsd / spend >= REWORK_SHARE) hints.push({
-		code: "rework",
-		message: `${percent(totals.reworkUsd / spend)} of the spend went to loop rounds after the first. Sharper briefs or an earlier check can stop work coming back.`
-	});
-	if (totals.failedUsd / spend >= FAILED_SHARE) hints.push({
-		code: "failed",
-		message: `${percent(totals.failedUsd / spend)} of the spend went to sessions that failed. A cheap check before them, or a lower budget per session, can stop them sooner.`
-	});
-	const top = nodes[0];
-	if (top !== void 0 && nodes.length > 1 && top.costUsd / spend >= CONCENTRATED_SHARE) hints.push({
-		code: "concentrated",
-		message: `${top.key} took ${percent(top.costUsd / spend)} of the spend. It is the first place to try a smaller model, a lower effort or a tighter brief.`
-	});
-	if (totals.inputTokens + totals.cacheReadTokens + totals.cacheWriteTokens >= MIN_CACHE_TOKENS && totals.cacheHitRate < LOW_CACHE_RATE) hints.push({
-		code: "cache",
-		message: `Only ${percent(totals.cacheHitRate)} of input tokens came from the prompt cache. Long runs of fresh sessions cost more than resumed ones.`
-	});
-	return hints;
-};
-/** Everything a report shows, from the ledger's rows and tool commands' CPU. */
-const usageReport = (rows, cpu = []) => {
-	const totals = totalsOf(rows, cpu);
-	const by = (dimension) => groupBy(rows, cpu, dimension);
-	const groups = {
-		day: by("day"),
-		week: by("week"),
-		month: by("month"),
-		workflow: by("workflow"),
-		node: by("node"),
-		model: by("model"),
-		driver: by("driver"),
-		project: by("project")
-	};
-	return {
-		totals,
-		groups,
-		hints: hintsOf(totals, groups.node)
-	};
-};
-export { usageReport as n, USAGE_DIMENSIONS as t };

package/dist/send-CaZlGG5a.mjs

@@ -1,163 +0,0 @@
-import { Cn as socketPath, Dt as scriptContactsOf, Tn as wakeRun, _t as liveStatus, w as openStore } from "./src-BeR6f70A.mjs";
-import { s as writeErr } from "./output-CnRzrbUM.mjs";
-import { u as inheritedScrubber } from "./src-D93tHZ5B.mjs";
-import { defineCommand } from "citty";
-// ../core/src/remote/send.ts
-/**
-* @file `ork send` (RFC-005): a program in a tool node writes to a session on
-*   its run's bus. The check is on the sender's side, as a refusal must be an
-*   exit code a script can act on; then a row in the store and a wake, as for a
-*   message between linked runs. `ORK_RUN` and `ORK_NODE` say who it is, and
-*   they are attribution, not proof: the check stops mistakes, not a program
-*   running as the same user.
-*/
-/** A first value, as for links; real use will show whether it is the right one. */
-const DEFAULT_SCRIPT_MESSAGES = 100;
-/**
-* Why this sender may not write to this node; `null` when it may. The body is
-* not needed, so a program is told before it pipes a whole message in.
-*/
-const scriptRefusal = (store, send) => {
-	const { run: runId, node, to } = send;
-	if (runId === void 0 || node === void 0) return "`ork send` runs inside a tool node of a run: `ORK_RUN` and `ORK_NODE` are not set.";
-	if (runId.startsWith("node-")) return `Run ${runId} runs one node, which has no message bus; run the whole workflow.`;
-	const run = store.lookup(runId).find((found) => found.id === runId);
-	if (run === void 0) return `There is no run ${runId}.`;
-	const status = liveStatus(run);
-	if (status !== "running") return `Run ${runId} is not running (${status}).`;
-	const started = store.events(runId).map((stored) => stored.event).findLast((event) => event.type === "run.started");
-	if (started === void 0) return `Run ${runId} has not started yet.`;
-	const own = started.nodes.find((found) => found.id === node);
-	if (own === void 0 || !own.type.startsWith("tool.")) return `${node} is not a tool node of run ${runId}.`;
-	const contacts = scriptContactsOf(node, started.nodes, started.channels ?? []);
-	if (contacts.includes(to)) return null;
-	return contacts.length === 0 ? `\`${node}\` has no one to write to: give it an owner, or a channel under \`messages:\`.` : `\`${to}\` is not a contact of \`${node}\`, which can write to \`${contacts.join("`, `")}\` (its owner and its channels).`;
-};
-/** Reading all of it would cost as much as sending it. */
-const TOO_LONG = "The message is over 64 KiB. Write it to a file and send the file's path.";
-/** Checks the message, writes it for the run, and wakes it. */
-const sendFromScript = async (store, send, home) => {
-	const refused = scriptRefusal(store, send);
-	if (refused !== null) return {
-		ok: false,
-		error: refused
-	};
-	if (Buffer.byteLength(send.body) > 65536) return {
-		ok: false,
-		error: TOO_LONG
-	};
-	const run = String(send.run);
-	const node = String(send.node);
-	if (!store.scriptCommand(run, {
-		kind: "script",
-		node: send.to,
-		from: node,
-		body: send.body
-	}, DEFAULT_SCRIPT_MESSAGES)) return {
-		ok: false,
-		error: `\`${node}\` has sent ${String(DEFAULT_SCRIPT_MESSAGES)} messages in this run, which is the most it may.`
-	};
-	await wakeRun(socketPath(run, home));
-	return { ok: true };
-};
-// src/commands/send.ts
-/**
-* @file `ork send` (RFC-005): a program in a tool node writes to a session on
-*   its run's bus. It prints nothing when it works, as what a program prints is
-*   its node's output, and says why on stderr, with exit 1, when it is refused:
-*   before reading a message it could not send, and for anything wrong with the
-*   command itself, which would otherwise go to stdout as usage.
-*/
-const refuse = (message) => {
-	writeErr(message);
-	process.exitCode = 1;
-};
-/** Stdin, up to the limit: past it, the rest is not worth holding. */
-const readBounded = async () => {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of process.stdin) {
-		const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
-		size += part.length;
-		if (size > 65536) return null;
-		chunks.push(part);
-	}
-	return Buffer.concat(chunks);
-};
-/** The message, or why it can't go. */
-const bodyOf = async (given) => {
-	if (given !== void 0) return { body: given };
-	const read = await readBounded();
-	if (read === null) return { refused: TOO_LONG };
-	try {
-		return { body: new TextDecoder("utf-8", { fatal: true }).decode(read) };
-	} catch {
-		return { refused: "The message is not UTF-8 text." };
-	}
-};
-const deliver = async (store, to, given) => {
-	const sender = {
-		run: process.env["ORK_RUN"],
-		node: process.env["ORK_NODE"],
-		to
-	};
-	const refused = scriptRefusal(store, sender);
-	if (refused !== null) {
-		refuse(refused);
-		return;
-	}
-	const message = await bodyOf(given);
-	if ("refused" in message) {
-		refuse(message.refused);
-		return;
-	}
-	if (message.body.replaceAll(/[\p{Cc}\s]/gu, "") === "") {
-		refuse("The message is empty.");
-		return;
-	}
-	const sent = await sendFromScript(store, {
-		...sender,
-		body: inheritedScrubber(process.env)(message.body)
-	});
-	if (!sent.ok) refuse(sent.error);
-};
-const send = defineCommand({
-	meta: {
-		name: "send",
-		description: "From a tool node's program: write to a session in its run"
-	},
-	args: {
-		to: {
-			type: "positional",
-			description: "The node to write to: the owner, or a channel",
-			required: false
-		},
-		message: {
-			type: "string",
-			alias: "m",
-			description: "The message"
-		},
-		stdin: {
-			type: "boolean",
-			description: "Read the message from stdin",
-			default: false
-		}
-	},
-	run: async ({ args }) => {
-		if (args.to === void 0 || args._.length !== 1) {
-			refuse("Give one node to write to: ork send <to> -m <body>.");
-			return;
-		}
-		if (args.message === void 0 === !args.stdin) {
-			refuse("Give the message with -m or --stdin, one of them.");
-			return;
-		}
-		const store = openStore();
-		try {
-			await deliver(store, args.to, args.message);
-		} finally {
-			store.close();
-		}
-	}
-});
-export { send };