@krapht/ork 0.3.0 → 0.4.0

package/dist/{mcp-BWsdQyri.mjs → mcp-CHVKKg3B.mjs}

@@ -1,8 +1,8 @@
-import "./src-Cz1yOUTg.mjs";
-import { n as ORK_VERSION } from "./__build_info__-CXXMLvjt.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-D5ruZFgD.mjs";
-import { n as explainNode, p as isNewer } from "./context-BFGC_C02.mjs";
-import { p as runMarkerIn } from "./src-DtN1k-B3.mjs";
+import { m as isNewer } from "./src-CGqMati3.mjs";
+import { n as ORK_VERSION } from "./__build_info__-CtSVVuZE.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-CpDKIulI.mjs";
+import { n as explainNode } from "./context-C_bksb0C.mjs";
+import { p as runMarkerIn } from "./src-UWkk1sl9.mjs";
 import { defineCommand } from "citty";
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -43,7 +43,7 @@ const orkMcpServer = (options = {}) => {
 		...options.script === void 0 ? {} : { script: options.script }
 	});
 	const all = [...opened.tools, explainTool(opened, options.home)];
-	const tools = options.expects !== void 0 && isNewer(options.expects, "0.3.0") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "0.4.0") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION

package/dist/{output-Q2EdeVUt.mjs → output-CXSJO00X.mjs}

@@ -1,4 +1,4 @@
-import { Ct as FEEDBACK_SEVERITIES, G as usageQueries, J as text, K as eventOf, Ot as maskReplacer, St as FEEDBACK_KINDS, W as backfillUsage, kt as maskSecrets, q as inTransaction, qt as PROJECT_MODES, wt as FEEDBACK_TARGETS } from "./src-Cz1yOUTg.mjs";
+import { At as FEEDBACK_KINDS, Ht as maskReplacer, J as eventOf, K as backfillUsage, Mt as FEEDBACK_TARGETS, Ut as maskSecrets, X as text, Y as inTransaction, jt as FEEDBACK_SEVERITIES, pt as ownProcessStart, q as usageQueries, sn as PROJECT_MODES } from "./src-CGqMati3.mjs";
 import { createInterface } from "node:readline/promises";
 import path from "node:path";
 import { mkdirSync } from "node:fs";
@@ -213,8 +213,10 @@ const recordOf$3 = (row) => {
 };
 const itemOf = (row) => {
 	const severities = strings(row, "severities");
+	const id = text(row, "fingerprint");
 	return {
-		id: text(row, "fingerprint"),
+		id,
+		merged: strings(row, "fingerprints").filter((f) => f !== id),
 		status: oneOf(STATUSES$1, text(row, "status"), "new"),
 		title: text(row, "title"),
 		target: oneOf(FEEDBACK_TARGETS, text(row, "target"), "workflow"),
@@ -229,16 +231,20 @@ const itemOf = (row) => {
 		models: strings(row, "models")
 	};
 };
-const ITEMS = `SELECT f.fingerprint, i.status,
-     (SELECT title FROM feedback WHERE fingerprint = f.fingerprint ORDER BY id LIMIT 1) AS title,
+/** Each record with the item it lists under: its own, or the one it merged into. */
+const ITEMS = `SELECT r.fingerprint, r.status,
+     (SELECT title FROM feedback WHERE fingerprint = r.fingerprint ORDER BY id LIMIT 1) AS title,
      MIN(f.target) AS target, MIN(f.kind) AS kind,
      json_group_array(DISTINCT f.severity) AS severities,
      json_group_array(DISTINCT f.source) AS sources,
      COUNT(*) AS count, MIN(f.at) AS first_seen, MAX(f.at) AS last_seen,
      json_group_array(DISTINCT f.run_id) AS runs,
      json_group_array(DISTINCT f.workflow) AS workflows,
-     json_group_array(DISTINCT f.model) AS models
-   FROM feedback f JOIN feedback_items i ON i.fingerprint = f.fingerprint`;
+     json_group_array(DISTINCT f.model) AS models,
+     json_group_array(DISTINCT f.fingerprint) AS fingerprints
+   FROM feedback f
+   JOIN feedback_items i ON i.fingerprint = f.fingerprint
+   JOIN feedback_items r ON r.fingerprint = COALESCE(i.merged_into, i.fingerprint)`;
 const feedbackQueries = (db) => {
 	const insert = db.prepare(`INSERT INTO feedback (run_id, seq, at, node, source, kind, target, severity,
        title, body, evidence, code, fingerprint, workflow, workflow_hash,
@@ -246,21 +252,51 @@ const feedbackQueries = (db) => {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
 	const insertItem = db.prepare(`INSERT INTO feedback_items (fingerprint, status, updated_at)
      VALUES (?, 'new', ?) ON CONFLICT (fingerprint) DO NOTHING`);
-	const shown = db.prepare(`${ITEMS} WHERE i.status != 'dismissed' GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const every = db.prepare(`${ITEMS} GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const byPrefix = db.prepare(`${ITEMS} WHERE substr(f.fingerprint, 1, ?) = ? GROUP BY f.fingerprint ORDER BY last_seen DESC`);
-	const records = db.prepare("SELECT * FROM feedback WHERE fingerprint = ? ORDER BY id");
+	const shown = db.prepare(`${ITEMS} WHERE r.status != 'dismissed' GROUP BY r.fingerprint ORDER BY last_seen DESC`);
+	const every = db.prepare(`${ITEMS} GROUP BY r.fingerprint ORDER BY last_seen DESC`);
+	const byPrefix = db.prepare(`${ITEMS} WHERE r.fingerprint IN (
+       SELECT COALESCE(merged_into, fingerprint) FROM feedback_items
+       WHERE substr(fingerprint, 1, ?) = ?
+     ) GROUP BY r.fingerprint ORDER BY last_seen DESC`);
+	const records = db.prepare(`SELECT * FROM feedback
+     WHERE fingerprint = ? OR fingerprint IN (
+       SELECT fingerprint FROM feedback_items WHERE merged_into = ?
+     ) ORDER BY id`);
+	const rootOf = db.prepare("SELECT COALESCE(merged_into, fingerprint) AS root FROM feedback_items WHERE fingerprint = ?");
+	const mergeInto = db.prepare(`UPDATE feedback_items SET merged_into = ?, updated_at = ?
+     WHERE (fingerprint = ? OR merged_into = ?) AND fingerprint != ?`);
+	const exported = db.prepare(`SELECT f.* FROM feedback f
+     LEFT JOIN feedback_items i ON i.fingerprint = f.fingerprint
+     LEFT JOIN feedback_items r ON r.fingerprint = COALESCE(i.merged_into, f.fingerprint)
+     WHERE ? = 1 OR COALESCE(r.status, 'new') != 'dismissed' ORDER BY f.id`);
+	const known = db.prepare("SELECT 1 FROM feedback WHERE run_id = ? AND seq = ?");
+	const split = db.prepare("UPDATE feedback_items SET merged_into = NULL, updated_at = ? WHERE merged_into = ?");
 	const setStatus = db.prepare("UPDATE feedback_items SET status = ?, updated_at = ? WHERE fingerprint = ?");
+	/** Writes a record, its secrets masked, and its item when it's new. */
+	const insertRecord = (runId, seq, at, node, feedback) => {
+		const { origin } = feedback;
+		insert.run(runId, seq, at, node ?? null, feedback.source, feedback.kind, feedback.target, feedback.severity, maskSecrets(feedback.title), maskSecrets(feedback.body), JSON.stringify(feedback.evidence.map((e) => maskSecrets(e))), feedback.code ?? null, feedback.fingerprint, origin.workflow ?? null, origin.workflowHash ?? null, origin.nodeType ?? null, origin.model ?? null, origin.driver ?? null, origin.version ?? null, 1);
+		insertItem.run(feedback.fingerprint, at);
+	};
 	return {
-		insertFeedback: (runId, seq, at, node, feedback) => {
-			const { origin } = feedback;
-			insert.run(runId, seq, at, node ?? null, feedback.source, feedback.kind, feedback.target, feedback.severity, maskSecrets(feedback.title), maskSecrets(feedback.body), JSON.stringify(feedback.evidence.map((e) => maskSecrets(e))), feedback.code ?? null, feedback.fingerprint, origin.workflow ?? null, origin.workflowHash ?? null, origin.nodeType ?? null, origin.model ?? null, origin.driver ?? null, origin.version ?? null, 1);
-			insertItem.run(feedback.fingerprint, at);
-		},
+		insertFeedback: insertRecord,
 		feedbackItems: (filter = {}) => (filter.all === true ? every : shown).all().map((r) => itemOf(r)),
 		findFeedback: (prefix) => byPrefix.all(prefix.length, prefix).map((r) => itemOf(r)),
-		feedbackRecords: (fingerprint) => records.all(fingerprint).map((r) => recordOf$3(r)),
-		setFeedbackStatus: (fingerprint, status) => Number(setStatus.run(status, (/* @__PURE__ */ new Date()).toISOString(), fingerprint).changes) > 0
+		feedbackRecords: (fingerprint) => records.all(fingerprint, fingerprint).map((r) => recordOf$3(r)),
+		setFeedbackStatus: (fingerprint, status) => Number(setStatus.run(status, (/* @__PURE__ */ new Date()).toISOString(), fingerprint).changes) > 0,
+		mergeFeedback: (into, from) => {
+			const root = text(rootOf.get(into), "root");
+			if (root === "") return 0;
+			const at = (/* @__PURE__ */ new Date()).toISOString();
+			return inTransaction(db, () => from.filter((fingerprint) => fingerprint !== root).reduce((moved, fingerprint) => moved + Number(mergeInto.run(root, at, fingerprint, fingerprint, root).changes), 0));
+		},
+		splitFeedback: (fingerprint) => Number(split.run((/* @__PURE__ */ new Date()).toISOString(), fingerprint).changes),
+		exportFeedback: (filter = {}) => exported.all(filter.all === true ? 1 : 0).map((r) => recordOf$3(r)),
+		importFeedback: (record) => {
+			if (known.get(record.runId, record.seq) !== void 0) return false;
+			insertRecord(record.runId, record.seq, record.at, record.node, record.feedback);
+			return true;
+		}
 	};
 };
 // ../core/src/store/links.ts
@@ -681,7 +717,10 @@ const MIGRATIONS = [
      id INTEGER PRIMARY KEY CHECK (id = 1),
      pid INTEGER NOT NULL,
      at TEXT NOT NULL
-   );`
+   );`,
+	`ALTER TABLE feedback_items ADD COLUMN merged_into TEXT;
+   CREATE INDEX feedback_items_merged ON feedback_items (merged_into);`,
+	`ALTER TABLE runs ADD COLUMN process_start TEXT;`
 ];
 const versionOf = (db) => Number(db.prepare("PRAGMA user_version").get()?.["user_version"] ?? 0);
 /** Applies the migrations the database has not had yet. */
@@ -728,6 +767,8 @@ const recordOf = (row) => {
 		costUsd: Number(row?.["cost_usd"]),
 		depth: Number(row?.["depth"] ?? 0)
 	};
+	const processStart = text(row, "process_start");
+	if (processStart !== "") record.processStart = processStart;
 	const parent = text(row, "parent");
 	if (parent !== "") record.parent = parent;
 	const finished = text(row, "finished_at");
@@ -741,7 +782,8 @@ const nodeOf = (event) => {
 	return null;
 };
 /** Opens (and creates) the store at `file`; `:memory:` for tests. */
-const openStore = (file = storePath()) => {
+const openStore = (file = storePath(), options = {}) => {
+	const ownStart = options.processStart ?? ownProcessStart;
 	if (file !== ":memory:") mkdirSync(path.dirname(file), { recursive: true });
 	const db = new DatabaseSync(file);
 	db.exec("PRAGMA busy_timeout = 5000");
@@ -749,12 +791,12 @@ const openStore = (file = storePath()) => {
 	db.exec("PRAGMA synchronous = NORMAL");
 	db.exec("PRAGMA foreign_keys = ON");
 	migrate(db);
-	const insertRun = db.prepare(`INSERT INTO runs (id, workflow, file, project, status, pid, started_at, parent, depth)
-     VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?)`);
+	const insertRun = db.prepare(`INSERT INTO runs (id, workflow, file, project, status, pid, process_start, started_at, parent, depth)
+     VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?, ?)`);
 	const lastSeq = db.prepare("SELECT COALESCE(MAX(seq), 0) AS seq FROM events WHERE run_id = ?");
 	const insertEvent = db.prepare("INSERT INTO events (run_id, seq, at, type, node, data) VALUES (?, ?, ?, ?, ?, ?)");
 	const finishRun = db.prepare("UPDATE runs SET status = ?, finished_at = ?, cost_usd = ? WHERE id = ?");
-	const reopenRun = db.prepare("UPDATE runs SET status = 'running', pid = ?, finished_at = NULL WHERE id = ?");
+	const reopenRun = db.prepare("UPDATE runs SET status = 'running', pid = ?, process_start = ?, finished_at = NULL WHERE id = ?");
 	const addCost = db.prepare("UPDATE runs SET cost_usd = cost_usd + ? WHERE id = ?");
 	const byId = db.prepare("SELECT * FROM runs WHERE id = ?");
 	const byPrefix = db.prepare("SELECT * FROM runs WHERE substr(id, 1, ?) = ? ORDER BY started_at DESC, rowid DESC");
@@ -767,18 +809,20 @@ const openStore = (file = storePath()) => {
 		begin: (run) => {
 			const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 			const depth = run.parent === void 0 ? 0 : Number(byId.get(run.parent)?.["depth"] ?? 0) + 1;
-			insertRun.run(run.id, run.workflow, run.file, run.project, process.pid, startedAt, run.parent ?? null, depth);
+			const processStart = ownStart();
+			insertRun.run(run.id, run.workflow, run.file, run.project, process.pid, processStart ?? null, startedAt, run.parent ?? null, depth);
 			return {
 				...run,
 				depth,
 				status: "running",
 				pid: process.pid,
+				...processStart === void 0 ? {} : { processStart },
 				startedAt,
 				costUsd: 0
 			};
 		},
 		reopen: (runId) => {
-			reopenRun.run(process.pid, runId);
+			reopenRun.run(process.pid, ownStart() ?? null, runId);
 		},
 		append: (runId, event) => inTransaction(db, () => {
 			const at = (/* @__PURE__ */ new Date()).toISOString();

package/dist/{pause-DKACDfV1.mjs → pause-BPSmg4yz.mjs}

@@ -1,7 +1,7 @@
-import { B as requestContinue, V as requestPause } from "./src-Cz1yOUTg.mjs";
-import { t as findRun } from "./find-BcvhT6UN.mjs";
-import { a as write, c as openStore, i as style, o as writeErr } from "./output-Q2EdeVUt.mjs";
-import { r as continueRefusal } from "./in-a-run-BbLhZOFW.mjs";
+import { H as requestContinue, U as requestPause } from "./src-CGqMati3.mjs";
+import { t as findRun } from "./find-DptmbhGd.mjs";
+import { a as write, c as openStore, i as style, o as writeErr } from "./output-CXSJO00X.mjs";
+import { r as continueRefusal } from "./in-a-run-D1Qc5Mit.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**

package/dist/{relay-CbK-Wme9.mjs → relay-Do-aNbSD.mjs}

@@ -1,5 +1,5 @@
-import { F as linkNodes, M as addressOf, R as unlinkNodes } from "./src-Cz1yOUTg.mjs";
-import { a as write, c as openStore, i as style, o as writeErr } from "./output-Q2EdeVUt.mjs";
+import { B as unlinkNodes, L as linkNodes, P as addressOf } from "./src-CGqMati3.mjs";
+import { a as write, c as openStore, i as style, o as writeErr } from "./output-CXSJO00X.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts
 /**

package/dist/remove-AwaMMaHf.mjs

@@ -0,0 +1,194 @@
+import { D as git, k as lines, lt as liveStatus } from "./src-CGqMati3.mjs";
+import { n as listOrkWorktrees, t as createdWorktrees } from "./list-ZvY2OcLq.mjs";
+import { i as keyOf, n as applyStep, r as cleanStep, s as stepPrunes } from "./clean-Dcr807be.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.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: the main
+* checkout or a worktree Ork didn't create holds it, or its run is still
+* going.
+*/
+const removeRefusal = (item, live) => {
+	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
+	};
+};
+/** 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, planLine as c, projectHead as i, removeRefusal as l, lostWork as n, labelOf as o, planRemove as r, mergeStateOf as s, applyRemove as t, stateParts as u };

package/dist/{send-C6yr04Fe.mjs → send-DhGBkowy.mjs}

@@ -1,6 +1,6 @@
-import { Ft as socketPath, It as wakeRun, gt as scriptContactsOf, rt as liveStatus } from "./src-Cz1yOUTg.mjs";
-import { c as openStore, o as writeErr } from "./output-Q2EdeVUt.mjs";
-import { u as inheritedScrubber } from "./src-DtN1k-B3.mjs";
+import { Xt as wakeRun, Yt as socketPath, lt as liveStatus, wt as scriptContactsOf } from "./src-CGqMati3.mjs";
+import { c as openStore, o as writeErr } from "./output-CXSJO00X.mjs";
+import { u as inheritedScrubber } from "./src-UWkk1sl9.mjs";
 import { defineCommand } from "citty";
 // ../core/src/remote/send.ts
 /**

package/dist/{src-CZOVF2yU.mjs → src-BHnxpJyH.mjs}

@@ -1,4 +1,4 @@
-import { Ct as FEEDBACK_SEVERITIES, D as parseReport, St as FEEDBACK_KINDS, wt as FEEDBACK_TARGETS } from "./src-Cz1yOUTg.mjs";
+import { At as FEEDBACK_KINDS, Mt as FEEDBACK_TARGETS, ct as parseReport, jt as FEEDBACK_SEVERITIES } from "./src-CGqMati3.mjs";
 import { z } from "zod";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createInterface } from "node:readline";