@agimon-ai/doompi-task 0.0.1-alpha.75 → 0.0.1-alpha.76

package/dist/src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.d.cts

@@ -0,0 +1,59 @@
+import { Task } from "../../../../../../models/task.cjs";
+//#region src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.d.ts
+export interface TaskCounts {
+  total: number;
+  completed: number;
+  inProgress: number;
+  pending: number;
+  failed: number;
+  blocked: number;
+}
+export interface TaskGroups {
+  inProgress: Task[];
+  blocked: Task[];
+  pending: Task[];
+  completed: Task[];
+  failed: Task[];
+}
+export interface TaskProjection {
+  visible: Task[];
+  counts: TaskCounts;
+  groups: TaskGroups;
+  showIds: boolean;
+  hasActiveWork: boolean;
+}
+export declare function visibleTasks(tasks: readonly Task[]): Task[];
+/**
+ * Derive all overlay-facing state in O(tasks + dependency edges).
+ *
+ * The id index replaces one full task-list scan per dependency, while the
+ * ordered pass keeps group ordering identical to the source document.
+ */
+export declare function deriveTaskProjection(tasks: readonly Task[]): TaskProjection;
+export declare function countTasks(tasks: readonly Task[]): TaskCounts;
+/**
+ * Group tasks for display.
+ *
+ * Blocked tasks split out of `pending` because a reader scanning the overlay
+ * needs to know at a glance what is actually actionable right now.
+ */
+export declare function groupTasks(tasks: readonly Task[]): TaskGroups;
+/** Ids are only worth the visual noise once dependencies are in play. */
+export declare function shouldShowIds(tasks: readonly Task[]): boolean;
+export declare function hasActiveWork(tasks: readonly Task[]): boolean;
+export interface OverlayLayout {
+  visible: Task[];
+  hiddenCompleted: number;
+  truncatedTail: number;
+}
+/**
+ * Choose which rows fit the overlay budget.
+ *
+ * Active work wins limited space: in-progress first, then failed, blocked, and
+ * pending. Selected rows are always returned in source order, however, so a
+ * status update does not reshuffle an otherwise unchanged overlay.
+ */
+export declare function selectOverlayLayoutFromProjection(projection: TaskProjection, budget: number): OverlayLayout;
+export declare function selectOverlayLayout(tasks: readonly Task[], budget: number): OverlayLayout;
+//#endregion
+//# sourceMappingURL=selectors.d.cts.map

package/dist/src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.cts","names":[],"sources":["../../../../../../../../src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.ts"],"mappings":";;iBAGiB;EACf;EACA;EACA;EACA;EACA;EACA;;iBAGe;EACf,YAAY;EACZ,SAAS;EACT,SAAS;EACT,WAAW;EACX,QAAQ;;iBAGO;EACf,SAAS;EACT,QAAQ;EACR,QAAQ;EACR;EACA;;wBAGc,aAAa,gBAAgB,SAAS;;;;;;;wBAuBtC,qBAAqB,gBAAgB,SAAS;wBA4C9C,WAAW,gBAAgB,SAAS;;;;;;;wBAUpC,WAAW,gBAAgB,SAAS;;wBAKpC,cAAc,gBAAgB;wBAI9B,cAAc,gBAAgB;iBAI7B;EACf,SAAS;EACT;EACA;;;;;;;;;wBAUc,kCAAkC,YAAY,gBAAgB,iBAAiB;wBAiC/E,oBAAoB,gBAAgB,QAAQ,iBAAiB"}

package/dist/src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.d.mts

@@ -0,0 +1,59 @@
+import { Task } from "../../../../../../models/task.mjs";
+//#region src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.d.ts
+export interface TaskCounts {
+  total: number;
+  completed: number;
+  inProgress: number;
+  pending: number;
+  failed: number;
+  blocked: number;
+}
+export interface TaskGroups {
+  inProgress: Task[];
+  blocked: Task[];
+  pending: Task[];
+  completed: Task[];
+  failed: Task[];
+}
+export interface TaskProjection {
+  visible: Task[];
+  counts: TaskCounts;
+  groups: TaskGroups;
+  showIds: boolean;
+  hasActiveWork: boolean;
+}
+export declare function visibleTasks(tasks: readonly Task[]): Task[];
+/**
+ * Derive all overlay-facing state in O(tasks + dependency edges).
+ *
+ * The id index replaces one full task-list scan per dependency, while the
+ * ordered pass keeps group ordering identical to the source document.
+ */
+export declare function deriveTaskProjection(tasks: readonly Task[]): TaskProjection;
+export declare function countTasks(tasks: readonly Task[]): TaskCounts;
+/**
+ * Group tasks for display.
+ *
+ * Blocked tasks split out of `pending` because a reader scanning the overlay
+ * needs to know at a glance what is actually actionable right now.
+ */
+export declare function groupTasks(tasks: readonly Task[]): TaskGroups;
+/** Ids are only worth the visual noise once dependencies are in play. */
+export declare function shouldShowIds(tasks: readonly Task[]): boolean;
+export declare function hasActiveWork(tasks: readonly Task[]): boolean;
+export interface OverlayLayout {
+  visible: Task[];
+  hiddenCompleted: number;
+  truncatedTail: number;
+}
+/**
+ * Choose which rows fit the overlay budget.
+ *
+ * Active work wins limited space: in-progress first, then failed, blocked, and
+ * pending. Selected rows are always returned in source order, however, so a
+ * status update does not reshuffle an otherwise unchanged overlay.
+ */
+export declare function selectOverlayLayoutFromProjection(projection: TaskProjection, budget: number): OverlayLayout;
+export declare function selectOverlayLayout(tasks: readonly Task[], budget: number): OverlayLayout;
+//#endregion
+//# sourceMappingURL=selectors.d.mts.map

package/dist/src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.mts","names":[],"sources":["../../../../../../../../src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.ts"],"mappings":";;iBAGiB;EACf;EACA;EACA;EACA;EACA;EACA;;iBAGe;EACf,YAAY;EACZ,SAAS;EACT,SAAS;EACT,WAAW;EACX,QAAQ;;iBAGO;EACf,SAAS;EACT,QAAQ;EACR,QAAQ;EACR;EACA;;wBAGc,aAAa,gBAAgB,SAAS;;;;;;;wBAuBtC,qBAAqB,gBAAgB,SAAS;wBA4C9C,WAAW,gBAAgB,SAAS;;;;;;;wBAUpC,WAAW,gBAAgB,SAAS;;wBAKpC,cAAc,gBAAgB;wBAI9B,cAAc,gBAAgB;iBAI7B;EACf,SAAS;EACT;EACA;;;;;;;;;wBAUc,kCAAkC,YAAY,gBAAgB,iBAAiB;wBAiC/E,oBAAoB,gBAAgB,QAAQ,iBAAiB"}

package/dist/src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.mjs

@@ -0,0 +1,142 @@
+import { canonicalizeTasks } from "../../../../../../services/invariants/index.mjs";
+//#region src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.ts
+function visibleTasks(tasks) {
+	return canonicalizeTasks(tasks).filter((task) => task.status !== "deleted");
+}
+function indexStatuses(tasks) {
+	return new Map(tasks.map((task) => [task.id, task.status]));
+}
+function hasUnresolvedBlocker(task, statuses) {
+	return task.blockedBy?.some((id) => {
+		const status = statuses.get(id);
+		return status !== void 0 && status !== "completed" && status !== "deleted";
+	}) ?? false;
+}
+/**
+* Derive all overlay-facing state in O(tasks + dependency edges).
+*
+* The id index replaces one full task-list scan per dependency, while the
+* ordered pass keeps group ordering identical to the source document.
+*/
+function deriveTaskProjection(tasks) {
+	const canonical = canonicalizeTasks(tasks);
+	const statuses = indexStatuses(canonical);
+	const visible = [];
+	const counts = {
+		total: 0,
+		completed: 0,
+		inProgress: 0,
+		pending: 0,
+		failed: 0,
+		blocked: 0
+	};
+	const groups = {
+		inProgress: [],
+		blocked: [],
+		pending: [],
+		completed: [],
+		failed: []
+	};
+	let showIds = false;
+	for (const task of canonical) {
+		if (task.status === "deleted") continue;
+		visible.push(task);
+		counts.total += 1;
+		showIds ||= Boolean(task.blockedBy?.length);
+		switch (task.status) {
+			case "in_progress":
+				counts.inProgress += 1;
+				groups.inProgress.push(task);
+				break;
+			case "pending":
+				counts.pending += 1;
+				if (hasUnresolvedBlocker(task, statuses)) {
+					counts.blocked += 1;
+					groups.blocked.push(task);
+				} else groups.pending.push(task);
+				break;
+			case "failed":
+				counts.failed += 1;
+				groups.failed.push(task);
+				break;
+			case "completed":
+				counts.completed += 1;
+				groups.completed.push(task);
+		}
+	}
+	return {
+		visible,
+		counts,
+		groups,
+		showIds,
+		hasActiveWork: counts.inProgress > 0
+	};
+}
+function countTasks(tasks) {
+	return deriveTaskProjection(tasks).counts;
+}
+/**
+* Group tasks for display.
+*
+* Blocked tasks split out of `pending` because a reader scanning the overlay
+* needs to know at a glance what is actually actionable right now.
+*/
+function groupTasks(tasks) {
+	return deriveTaskProjection(tasks).groups;
+}
+/** Ids are only worth the visual noise once dependencies are in play. */
+function shouldShowIds(tasks) {
+	return tasks.some((task) => task.status !== "deleted" && Boolean(task.blockedBy?.length));
+}
+function hasActiveWork(tasks) {
+	return tasks.some((task) => task.status === "in_progress");
+}
+/**
+* Choose which rows fit the overlay budget.
+*
+* Active work wins limited space: in-progress first, then failed, blocked, and
+* pending. Selected rows are always returned in source order, however, so a
+* status update does not reshuffle an otherwise unchanged overlay.
+*/
+function selectOverlayLayoutFromProjection(projection, budget) {
+	const { groups, visible: sourceOrder } = projection;
+	const active = [
+		...groups.inProgress,
+		...groups.failed,
+		...groups.blocked,
+		...groups.pending
+	];
+	if (budget <= 0) return {
+		visible: [],
+		hiddenCompleted: groups.completed.length,
+		truncatedTail: active.length
+	};
+	if (sourceOrder.length <= budget) return {
+		visible: sourceOrder,
+		hiddenCompleted: 0,
+		truncatedTail: 0
+	};
+	if (active.length <= budget) {
+		const remaining = budget - active.length;
+		const shownCompleted = groups.completed.slice(0, remaining);
+		const selected = /* @__PURE__ */ new Set([...active, ...shownCompleted]);
+		return {
+			visible: sourceOrder.filter((task) => selected.has(task)),
+			hiddenCompleted: groups.completed.length - shownCompleted.length,
+			truncatedTail: 0
+		};
+	}
+	const selected = new Set(active.slice(0, budget));
+	return {
+		visible: sourceOrder.filter((task) => selected.has(task)),
+		hiddenCompleted: groups.completed.length,
+		truncatedTail: active.length - budget
+	};
+}
+function selectOverlayLayout(tasks, budget) {
+	return selectOverlayLayoutFromProjection(deriveTaskProjection(tasks), budget);
+}
+//#endregion
+export { countTasks, deriveTaskProjection, groupTasks, hasActiveWork, selectOverlayLayout, selectOverlayLayoutFromProjection, shouldShowIds, visibleTasks };
+
+//# sourceMappingURL=selectors.mjs.map

package/dist/src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.mjs","names":[],"sources":["../../../../../../../../src/extensions/workspaces/sessions/(frontend)/overlay/_lib/selectors.ts"],"sourcesContent":["import type { Task } from '../../../../../../models/task';\nimport { canonicalizeTasks } from '../../../../../../services/invariants';\n\nexport interface TaskCounts {\n  total: number;\n  completed: number;\n  inProgress: number;\n  pending: number;\n  failed: number;\n  blocked: number;\n}\n\nexport interface TaskGroups {\n  inProgress: Task[];\n  blocked: Task[];\n  pending: Task[];\n  completed: Task[];\n  failed: Task[];\n}\n\nexport interface TaskProjection {\n  visible: Task[];\n  counts: TaskCounts;\n  groups: TaskGroups;\n  showIds: boolean;\n  hasActiveWork: boolean;\n}\n\nexport function visibleTasks(tasks: readonly Task[]): Task[] {\n  return canonicalizeTasks(tasks).filter((task) => task.status !== 'deleted');\n}\n\nfunction indexStatuses(tasks: readonly Task[]): Map<number, Task['status']> {\n  return new Map(tasks.map((task) => [task.id, task.status]));\n}\n\nfunction hasUnresolvedBlocker(task: Task, statuses: ReadonlyMap<number, Task['status']>): boolean {\n  return (\n    task.blockedBy?.some((id) => {\n      const status = statuses.get(id);\n      return status !== undefined && status !== 'completed' && status !== 'deleted';\n    }) ?? false\n  );\n}\n\n/**\n * Derive all overlay-facing state in O(tasks + dependency edges).\n *\n * The id index replaces one full task-list scan per dependency, while the\n * ordered pass keeps group ordering identical to the source document.\n */\nexport function deriveTaskProjection(tasks: readonly Task[]): TaskProjection {\n  const canonical = canonicalizeTasks(tasks);\n  const statuses = indexStatuses(canonical);\n  const visible: Task[] = [];\n  const counts: TaskCounts = { total: 0, completed: 0, inProgress: 0, pending: 0, failed: 0, blocked: 0 };\n  const groups: TaskGroups = { inProgress: [], blocked: [], pending: [], completed: [], failed: [] };\n  let showIds = false;\n\n  for (const task of canonical) {\n    if (task.status === 'deleted') continue;\n\n    visible.push(task);\n    counts.total += 1;\n    showIds ||= Boolean(task.blockedBy?.length);\n\n    switch (task.status) {\n      case 'in_progress':\n        counts.inProgress += 1;\n        groups.inProgress.push(task);\n        break;\n      case 'pending': {\n        counts.pending += 1;\n        if (hasUnresolvedBlocker(task, statuses)) {\n          counts.blocked += 1;\n          groups.blocked.push(task);\n        } else {\n          groups.pending.push(task);\n        }\n        break;\n      }\n      case 'failed':\n        counts.failed += 1;\n        groups.failed.push(task);\n        break;\n      case 'completed':\n        counts.completed += 1;\n        groups.completed.push(task);\n        break;\n    }\n  }\n\n  return { visible, counts, groups, showIds, hasActiveWork: counts.inProgress > 0 };\n}\n\nexport function countTasks(tasks: readonly Task[]): TaskCounts {\n  return deriveTaskProjection(tasks).counts;\n}\n\n/**\n * Group tasks for display.\n *\n * Blocked tasks split out of `pending` because a reader scanning the overlay\n * needs to know at a glance what is actually actionable right now.\n */\nexport function groupTasks(tasks: readonly Task[]): TaskGroups {\n  return deriveTaskProjection(tasks).groups;\n}\n\n/** Ids are only worth the visual noise once dependencies are in play. */\nexport function shouldShowIds(tasks: readonly Task[]): boolean {\n  return tasks.some((task) => task.status !== 'deleted' && Boolean(task.blockedBy?.length));\n}\n\nexport function hasActiveWork(tasks: readonly Task[]): boolean {\n  return tasks.some((task) => task.status === 'in_progress');\n}\n\nexport interface OverlayLayout {\n  visible: Task[];\n  hiddenCompleted: number;\n  truncatedTail: number;\n}\n\n/**\n * Choose which rows fit the overlay budget.\n *\n * Active work wins limited space: in-progress first, then failed, blocked, and\n * pending. Selected rows are always returned in source order, however, so a\n * status update does not reshuffle an otherwise unchanged overlay.\n */\nexport function selectOverlayLayoutFromProjection(projection: TaskProjection, budget: number): OverlayLayout {\n  const { groups, visible: sourceOrder } = projection;\n  const active = [...groups.inProgress, ...groups.failed, ...groups.blocked, ...groups.pending];\n  if (budget <= 0) {\n    return {\n      visible: [],\n      hiddenCompleted: groups.completed.length,\n      truncatedTail: active.length,\n    };\n  }\n  if (sourceOrder.length <= budget) {\n    return { visible: sourceOrder, hiddenCompleted: 0, truncatedTail: 0 };\n  }\n\n  if (active.length <= budget) {\n    const remaining = budget - active.length;\n    const shownCompleted = groups.completed.slice(0, remaining);\n    const selected = new Set([...active, ...shownCompleted]);\n    return {\n      visible: sourceOrder.filter((task) => selected.has(task)),\n      hiddenCompleted: groups.completed.length - shownCompleted.length,\n      truncatedTail: 0,\n    };\n  }\n\n  const selected = new Set(active.slice(0, budget));\n  return {\n    visible: sourceOrder.filter((task) => selected.has(task)),\n    hiddenCompleted: groups.completed.length,\n    truncatedTail: active.length - budget,\n  };\n}\n\nexport function selectOverlayLayout(tasks: readonly Task[], budget: number): OverlayLayout {\n  return selectOverlayLayoutFromProjection(deriveTaskProjection(tasks), budget);\n}\n"],"mappings":"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"}

package/dist/src/extensions/workspaces/sessions/(frontend)/overlay/_lib/task-space.cli.cjs

@@ -0,0 +1,358 @@
+const require_taskGraph = require("../../../../../../models/taskGraph.cjs");
+const require_format_cli = require("../../_shared/format.cli.cjs");
+const require_selectors = require("./selectors.cjs");
+const require_task = require("../../../../../../schemas/task.cjs");
+const require_index = require("../../../../../../services/reducer/index.cjs");
+let _earendil_works_pi_tui = require("@earendil-works/pi-tui");
+let node_os = require("node:os");
+let _agimon_ai_doompi_ui_doom_overlay = require("@agimon-ai/doompi-ui/doom-overlay");
+let _agimon_ai_doompi_ui_rendering = require("@agimon-ai/doompi-ui/rendering");
+//#region src/extensions/workspaces/sessions/(frontend)/overlay/_lib/task-space.cli.ts
+/**
+* Task Space: the `SPC t l` overlay.
+*
+* The task list and detail pane render from plain values so the whole surface
+* can be asserted as text without a live terminal.
+*
+* The overlay reads the store on every render rather than caching rows, so an
+* external write by a delegated child shows up without closing the overlay.
+*
+* Every commit it makes is a single-entry `upsert` that carries the selected
+* task's id. That id is what keeps creating a task a tool-only path: an entry
+* without one would create rather than be rejected.
+*/
+const TASK_SPACE_OVERLAY_OPTIONS = _agimon_ai_doompi_ui_doom_overlay.DOOM_FULLSCREEN_UI_OPTIONS.overlayOptions;
+const KEY_BACKSPACE = "";
+const KEY_ENTER = "\r";
+const KEY_NEWLINE = "\n";
+const FIRST_PRINTABLE_CODE_POINT = 32;
+const DELETE_CODE_POINT = 127;
+/**
+* Keystrokes that carry no text: escape sequences, control keys, delete.
+* Indexed rather than iterated so surrogate pairs stay intact; both halves sit
+* far above the control range, so no emoji is ever mistaken for one.
+*/
+function isControlInput(data) {
+	for (let index = 0; index < data.length; index++) {
+		const code = data.charCodeAt(index);
+		if (code < FIRST_PRINTABLE_CODE_POINT || code === DELETE_CODE_POINT) return true;
+	}
+	return false;
+}
+/**
+* Store path for the list heading: home collapses to `~`, and an over-long path
+* loses leading segments rather than its tail, because the file name identifies
+* the store while `/var/folders/...` does not.
+*/
+function storeLabel(storePath, width) {
+	const home = (0, node_os.homedir)();
+	const abbreviated = home && storePath.startsWith(home) ? `~${storePath.slice(home.length)}` : storePath;
+	if ((0, _earendil_works_pi_tui.visibleWidth)(abbreviated) <= width) return abbreviated;
+	const segments = abbreviated.split("/");
+	let tail = segments.pop() ?? abbreviated;
+	while (segments.length > 0) {
+		const candidate = `${segments[segments.length - 1]}/${tail}`;
+		if ((0, _earendil_works_pi_tui.visibleWidth)(`…/${candidate}`) > width) break;
+		tail = candidate;
+		segments.pop();
+	}
+	return (0, _earendil_works_pi_tui.truncateToWidth)(`…/${tail}`, width, "");
+}
+/** Each task occupies a heading row and a metadata row beneath it. */
+const ROWS_PER_TASK = 2;
+/** Hanging indent for the metadata row: clears marker, glyph and id. */
+const META_INDENT = 6;
+const MIN_WIDTH = 48;
+/** A third for the list, two thirds for the task being read or edited. */
+const LIST_PANE_RATIO = 1 / 3;
+/** One blank column each side of the pane divider so neither column touches it. */
+const PANE_GUTTER = 1;
+const MIN_PANE_WIDTH = 18;
+const SELECTION_MARKER = "›";
+const CURRENT_MARKER = "▸";
+const CURSOR_BLOCK = "█";
+const ELLIPSIS = "…";
+const NO_VALUE = "none";
+const TITLE = "TASK SPACE";
+const BREADCRUMB = "SPC › t › t / tasks";
+/** Key/label pairs rendered as capped keys, matching the mockup's footer. */
+const LIST_HINTS = [
+	["↑↓", "select"],
+	["enter", "edit subject"],
+	["s", "status"],
+	["esc", "close"]
+];
+const LIST_HEADER_RIGHT = "esc close";
+const STATUS_HINT = "STATUS   s cycles · enter commits";
+const SUBJECT_HINT = "SUBJECT  enter commits · esc cancels";
+function fitRow(text, width) {
+	return (0, _agimon_ai_doompi_ui_rendering.fitStyledLine)(text, width, ELLIPSIS);
+}
+function rightAligned(left, right, width) {
+	const rightWidth = (0, _earendil_works_pi_tui.visibleWidth)(right);
+	const leftWidth = Math.max(0, width - rightWidth - 1);
+	return fitRow(left, leftWidth) + " ".repeat(Math.max(1, width - leftWidth - rightWidth)) + fitRow(right, rightWidth);
+}
+function wrap(text, width) {
+	if (width <= 0) return [];
+	const lines = [];
+	let current = "";
+	for (const word of text.split(/\s+/).filter(Boolean)) if (current.length === 0) current = word;
+	else if (current.length + 1 + word.length <= width) current += ` ${word}`;
+	else {
+		lines.push(current);
+		current = word;
+	}
+	if (current.length > 0) lines.push(current);
+	return lines;
+}
+/**
+* Task Space overlay component.
+*
+* Rendering is pure: `render(width)` reads the live store and returns lines with
+* no side effects, so the fidelity job can capture it and unit tests can assert on it.
+*/
+var TaskSpaceComponent = class extends _agimon_ai_doompi_ui_doom_overlay.DoomOverlay {
+	options;
+	done;
+	unwatch;
+	mode = "browse";
+	selected = 0;
+	statusIndex = 0;
+	draft = "";
+	notice;
+	bodyHeight = 1;
+	constructor(tui, theme, options, done) {
+		super(tui, theme);
+		this.options = options;
+		this.done = done;
+		this.unwatch = options.store.onExternalChange(() => this.tui.requestRender());
+	}
+	tasks() {
+		return require_selectors.visibleTasks(this.options.store.snapshot.tasks);
+	}
+	selectedTask() {
+		const tasks = this.tasks();
+		if (tasks.length === 0) return void 0;
+		return tasks[Math.min(this.selected, tasks.length - 1)];
+	}
+	move(delta) {
+		const tasks = this.tasks();
+		if (tasks.length === 0) return;
+		this.selected = Math.max(0, Math.min(tasks.length - 1, this.selected + delta));
+		this.tui.requestRender();
+	}
+	/** Commits through the same reducer the task tool uses, so both paths share every invariant. */
+	commit(item) {
+		this.options.store.mutate((document) => {
+			const result = require_index.applyTaskMutation(document, "upsert", { tasks: [item] });
+			if (!require_index.isCommittingOp(result.op)) return { value: result.op };
+			return {
+				document: result.document,
+				value: result.op
+			};
+		}).then((outcome) => {
+			const single = require_index.singleItemOutcome(outcome.value);
+			this.notice = single?.kind === "failed" ? single.message : void 0;
+			this.tui.requestRender();
+		}).catch((error) => {
+			this.notice = error instanceof Error ? error.message : String(error);
+			this.tui.requestRender();
+		});
+	}
+	handleStatusInput(data) {
+		const task = this.selectedTask();
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "up")) this.statusIndex = Math.max(0, this.statusIndex - 1);
+		else if ((0, _earendil_works_pi_tui.matchesKey)(data, "down")) this.statusIndex = Math.min(require_task.TASK_STATUSES.length - 1, this.statusIndex + 1);
+		else if (data === "s") this.statusIndex = (this.statusIndex + 1) % require_task.TASK_STATUSES.length;
+		else if (data === KEY_ENTER || data === KEY_NEWLINE) {
+			this.mode = "browse";
+			if (task) this.commit({
+				id: task.id,
+				status: require_task.TASK_STATUSES[this.statusIndex]
+			});
+		} else if ((0, _earendil_works_pi_tui.matchesKey)(data, "escape")) this.mode = "browse";
+		this.tui.requestRender();
+	}
+	handleSubjectInput(data) {
+		const task = this.selectedTask();
+		if (data === KEY_ENTER || data === KEY_NEWLINE) {
+			this.mode = "browse";
+			if (task) this.commit({
+				id: task.id,
+				subject: this.draft
+			});
+		} else if ((0, _earendil_works_pi_tui.matchesKey)(data, "escape")) this.mode = "browse";
+		else if (data === KEY_BACKSPACE) this.draft = this.draft.slice(0, -1);
+		else if (!isControlInput(data)) this.draft += data;
+		this.tui.requestRender();
+	}
+	handleInput(data) {
+		if (this.mode === "status") {
+			this.handleStatusInput(data);
+			return;
+		}
+		if (this.mode === "subject") {
+			this.handleSubjectInput(data);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "escape") || (0, _earendil_works_pi_tui.matchesKey)(data, "ctrl+c")) {
+			this.done(void 0);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "up")) {
+			this.move(-1);
+			return;
+		}
+		if ((0, _earendil_works_pi_tui.matchesKey)(data, "down")) {
+			this.move(1);
+			return;
+		}
+		const task = this.selectedTask();
+		if (!task) return;
+		if (data === "s") {
+			this.mode = "status";
+			this.statusIndex = Math.max(0, require_task.TASK_STATUSES.indexOf(task.status));
+			this.tui.requestRender();
+			return;
+		}
+		if (data === KEY_ENTER || data === KEY_NEWLINE) {
+			this.mode = "subject";
+			this.draft = task.subject;
+			this.tui.requestRender();
+		}
+	}
+	/**
+	* A padded, background-filled chip. Foreground is applied inside the fill so
+	* the colour closes with it, rather than a reset stripping the background
+	* partway through the label.
+	*/
+	badge(text, background, colour = "text") {
+		return this.theme.bg(background, this.theme.fg(colour, ` ${text} `));
+	}
+	/** Footer hints as capped keys: `[ enter ] edit subject`, per the mockup. */
+	hintLine(hints) {
+		return hints.map(([key, label]) => `${this.badge(key, "selectedBg")}${this.theme.fg("dim", ` ${label}`)}`).join(this.theme.fg("dim", "   "));
+	}
+	listLines(width) {
+		const tasks = this.tasks();
+		const label = this.theme.bold("TASKS");
+		const pathWidth = Math.max(0, width - (0, _earendil_works_pi_tui.visibleWidth)("TASKS") - 2);
+		const lines = [`${label}  ${this.theme.fg("dim", storeLabel(this.options.store.storePath, pathWidth))}`, ""];
+		if (tasks.length === 0) {
+			lines.push(this.theme.fg("dim", require_task.MSG_NO_TASKS));
+			return lines;
+		}
+		const budget = Math.max(1, Math.floor((this.bodyHeight - lines.length) / ROWS_PER_TASK));
+		const start = Math.max(0, Math.min(this.selected - budget + 1, Math.max(0, tasks.length - budget)));
+		for (const [offset, task] of tasks.slice(start, start + budget).entries()) {
+			const active = start + offset === Math.min(this.selected, tasks.length - 1);
+			const marker = active ? this.theme.fg("accent", SELECTION_MARKER) : " ";
+			const subject = active ? this.theme.bold(task.subject) : task.subject;
+			const glyph = require_format_cli.overlayStatusGlyph(task.status, this.theme);
+			const owner = task.owner ?? task.delegation?.agent ?? NO_VALUE;
+			const state = task.status === "pending" && require_taskGraph.isBlocked(this.options.store.snapshot.tasks, task) ? this.theme.fg("warning", `blocked by ${(task.blockedBy ?? []).map((id) => `#${id}`).join(", ")}`) : this.theme.fg("dim", require_format_cli.STATUS_LABEL[task.status]);
+			const heading = `${marker} ${glyph} ${this.theme.fg("dim", `#${task.id}`)} ${subject}`;
+			const meta = `${" ".repeat(META_INDENT)}${this.badge(owner, "userMessageBg", "muted")} ${state}`;
+			const background = active ? "selectedBg" : "userMessageBg";
+			for (const row of [heading, meta]) lines.push(this.theme.bg(background, fitRow(row, width)));
+		}
+		return lines;
+	}
+	statusLines(task, width) {
+		if (this.mode !== "status") {
+			const glyph = require_format_cli.overlayStatusGlyph(task.status, this.theme);
+			return [this.theme.fg("dim", "STATUS"), `${glyph} ${require_format_cli.STATUS_LABEL[task.status]}`];
+		}
+		const lines = [this.theme.fg("dim", STATUS_HINT)];
+		for (const [index, status] of require_task.TASK_STATUSES.entries()) {
+			const selected = index === this.statusIndex;
+			const marker = selected ? this.theme.fg("accent", CURRENT_MARKER) : " ";
+			const label = selected ? this.theme.bold(this.theme.fg("accent", status)) : this.theme.fg("muted", status);
+			const current = status === task.status ? this.theme.fg("dim", "current") : "";
+			const row = rightAligned(`  ${marker} ${label}`, current, width);
+			lines.push(this.theme.bg(selected ? "selectedBg" : "userMessageBg", row));
+		}
+		return lines;
+	}
+	/** The subject as an input: a filled field with a caret, as in the mockup. */
+	subjectField(task, width) {
+		const editing = this.mode === "subject";
+		const value = editing ? `${this.draft}${CURSOR_BLOCK}` : task.subject;
+		return [this.theme.fg("dim", editing ? SUBJECT_HINT : "SUBJECT"), this.theme.bg(editing ? "selectedBg" : "userMessageBg", fitRow(` ${value}`, width))];
+	}
+	detailLines(width) {
+		const task = this.selectedTask();
+		if (!task) return [this.theme.fg("dim", "No task selected")];
+		const badge = this.mode === "subject" || this.mode === "status" ? this.badge("EDIT", "toolSuccessBg", "warning") : "";
+		const lines = [rightAligned(this.theme.bold(this.theme.fg("accent", `TASK #${task.id}`)), badge, width), ""];
+		lines.push(...this.subjectField(task, width));
+		lines.push("", ...this.statusLines(task, width), "");
+		if (task.activeForm) lines.push(this.theme.fg("dim", "ACTIVE FORM"), task.activeForm, "");
+		const owner = task.owner ?? task.delegation?.agent ?? NO_VALUE;
+		const delegated = task.delegation?.runId ? this.theme.fg("success", `delegated run ${task.delegation.runId}`) : "";
+		lines.push(this.theme.fg("dim", "OWNER"), delegated ? `${owner}   ${this.theme.fg("dim", "·")}   ${delegated}` : owner, "");
+		lines.push(this.theme.fg("dim", "BLOCKED BY"), task.blockedBy?.length ? task.blockedBy.map((id) => `#${id}`).join(" · ") : NO_VALUE);
+		if (task.description) lines.push("", this.theme.fg("dim", "DESCRIPTION"), ...wrap(task.description, width));
+		if (this.notice) lines.push("", this.theme.fg("error", this.notice));
+		return lines;
+	}
+	headerSummary() {
+		const counts = require_selectors.countTasks(this.options.store.snapshot.tasks);
+		const summary = [`${counts.completed}/${counts.total} completed`];
+		if (counts.inProgress > 0) summary.push(`${counts.inProgress} in progress`);
+		if (counts.blocked > 0) summary.push(`${counts.blocked} blocked`);
+		if (counts.failed > 0) summary.push(`${counts.failed} failed`);
+		return summary.join(" · ");
+	}
+	getChrome() {
+		return {
+			title: TITLE,
+			accent: _agimon_ai_doompi_ui_doom_overlay.DOOM_OVERLAY_ACCENT,
+			breadcrumb: BREADCRUMB,
+			headerRight: `${this.headerSummary()} · ${LIST_HEADER_RIGHT}`,
+			footer: this.hintLine(LIST_HINTS)
+		};
+	}
+	renderBody(width, height) {
+		this.bodyHeight = height;
+		if (width < MIN_WIDTH) return this.renderStacked(width, height);
+		const leftWidth = Math.max(MIN_PANE_WIDTH, Math.floor((width - 1) * LIST_PANE_RATIO));
+		const rightWidth = Math.max(1, width - leftWidth - 1);
+		const leftContent = Math.max(1, leftWidth - PANE_GUTTER);
+		const rightContent = Math.max(1, rightWidth - PANE_GUTTER);
+		const left = this.listLines(leftContent);
+		const right = this.detailLines(rightContent);
+		const divider = this.theme.fg("borderMuted", "│");
+		return Array.from({ length: height }, (_, index) => {
+			const row = `${fitRow(left[index] ?? "", leftContent)} ${divider} ${fitRow(right[index] ?? "", rightContent)}`;
+			return (0, _earendil_works_pi_tui.truncateToWidth)(row, width, ELLIPSIS);
+		});
+	}
+	renderStacked(width, height) {
+		const topHeight = Math.max(1, Math.floor((height - 1) / 2));
+		const bottomHeight = Math.max(0, height - topHeight - 1);
+		this.bodyHeight = topHeight;
+		const top = this.listLines(width);
+		const bottom = this.detailLines(width);
+		return [
+			...top.slice(0, topHeight),
+			...Array.from({ length: Math.max(0, topHeight - top.length) }, () => ""),
+			this.theme.fg("borderMuted", "─".repeat(width)),
+			...bottom.slice(0, bottomHeight)
+		];
+	}
+	dispose() {
+		this.unwatch();
+	}
+};
+async function openTaskSpace(ctx, options) {
+	await ctx.ui.custom((tui, theme, _keybindings, done) => new TaskSpaceComponent(tui, theme, options, done), _agimon_ai_doompi_ui_doom_overlay.DOOM_FULLSCREEN_UI_OPTIONS);
+}
+//#endregion
+exports.TASK_SPACE_OVERLAY_OPTIONS = TASK_SPACE_OVERLAY_OPTIONS;
+exports.TaskSpaceComponent = TaskSpaceComponent;
+exports.default = openTaskSpace;
+exports.openTaskSpace = openTaskSpace;
+
+//# sourceMappingURL=task-space.cli.cjs.map