taskplane 0.1.6 → 0.1.8

package/extensions/taskplane/execution.ts

@@ -1,15 +1,16 @@
-/**
- * Lane execution, monitoring, wave execution loop
- * @module orch/execution
- */
-import { readFileSync, existsSync, statSync, unlinkSync, mkdirSync } from "fs";
-import { spawnSync } from "child_process";
-import { join, dirname, resolve, delimiter as pathDelimiter } from "path";
-
-import { DONE_GRACE_MS, EXECUTION_POLL_INTERVAL_MS, ExecutionError, SESSION_SPAWN_RETRY_MAX } from "./types.ts";
-import type { AllocatedLane, AllocatedTask, DependencyGraph, LaneExecutionResult, LaneMonitorSnapshot, LaneTaskOutcome, LaneTaskStatus, MonitorState, MtimeTracker, OrchestratorConfig, ParsedTask, TaskMonitorSnapshot, WaveExecutionResult } from "./types.ts";
-import { allocateLanes } from "./waves.ts";
-
+/**
+ * Lane execution, monitoring, wave execution loop
+ * @module orch/execution
+ */
+import { readFileSync, existsSync, statSync, unlinkSync, mkdirSync } from "fs";
+import { spawnSync } from "child_process";
+import { join, dirname, resolve, relative, delimiter as pathDelimiter } from "path";
+
+import { DONE_GRACE_MS, EXECUTION_POLL_INTERVAL_MS, ExecutionError, SESSION_SPAWN_RETRY_MAX } from "./types.ts";
+import type { AllocatedLane, AllocatedTask, DependencyGraph, LaneExecutionResult, LaneMonitorSnapshot, LaneTaskOutcome, LaneTaskStatus, MonitorState, MtimeTracker, OrchestratorConfig, ParsedTask, TaskMonitorSnapshot, WaveExecutionResult } from "./types.ts";
+import { allocateLanes } from "./waves.ts";
+import { runGit } from "./git.ts";
+
 // ── Execution Helpers ────────────────────────────────────────────────
 
 /**
@@ -479,6 +480,12 @@ export async function pollUntilTaskComplete(
 
 	let lastPaneTail = "";
 
+	// Abort signal file path — checked each poll cycle.
+	// Any process can create this file to trigger abort (belt-and-suspenders
+	// alongside the in-memory pauseSignal, since /orch-abort may not be able
+	// to run concurrently with the /orch command handler).
+	const abortSignalFile = join(repoRoot, ".pi", "orch-abort-signal");
+
 	// Main polling loop
 	while (true) {
 		// Check pause signal
@@ -493,6 +500,20 @@ export async function pollUntilTaskComplete(
 			};
 		}
 
+		// Check file-based abort signal
+		if (existsSync(abortSignalFile)) {
+			execLog(laneId, task.taskId, "abort signal file detected — killing session and aborting");
+			tmuxKillSession(sessionName);
+			// Also kill child sessions (worker, reviewer)
+			tmuxKillSession(`${sessionName}-worker`);
+			tmuxKillSession(`${sessionName}-reviewer`);
+			return {
+				status: "failed",
+				exitReason: "Aborted by signal file (.pi/orch-abort-signal)",
+				doneFileFound: false,
+			};
+		}
+
 		// Capture live pane output for diagnostics (best effort).
 		const paneTail = captureTmuxPaneTail(sessionName);
 		if (paneTail) {
@@ -725,7 +746,7 @@ export async function executeLane(
 	};
 }
 
-
+
 // ── STATUS.md Parsing for Worktree ───────────────────────────────────
 
 /**
@@ -873,7 +894,7 @@ export function parseWorktreeStatusMd(
 	};
 }
 
-
+
 // ── State Resolution ─────────────────────────────────────────────────
 
 /**
@@ -1063,7 +1084,7 @@ export function resolveTaskMonitorState(
 	};
 }
 
-
+
 // ── Core Monitor Loop ────────────────────────────────────────────────
 
 /**
@@ -1326,7 +1347,7 @@ export async function monitorLanes(
 	};
 }
 
-
+
 // ── Transitive Dependent Computation ─────────────────────────────────
 
 /**
@@ -1370,7 +1391,101 @@ export function computeTransitiveDependents(
 	return blocked;
 }
 
-
+
+// ── Pre-flight: Commit Untracked Task Files ─────────────────────────
+
+/**
+ * Ensure all task files for a wave are committed to git before worktree creation.
+ *
+ * Git worktrees only contain tracked (committed) files. If a user creates
+ * task folders (PROMPT.md, STATUS.md) but doesn't commit them, the worktree
+ * won't have those files and TASK_AUTOSTART will fail with "file not found".
+ *
+ * This function checks each wave task's folder for untracked or modified files,
+ * stages them, and creates a commit on the current branch. This must run BEFORE
+ * allocateLanes() so that worktrees (which are based on the integration branch)
+ * include the task files.
+ *
+ * Only task-specific folders are staged — no other working tree changes are touched.
+ *
+ * @param waveTasks  - Task IDs in this wave
+ * @param pending    - Full pending task map from discovery
+ * @param repoRoot   - Main repository root
+ * @param waveIndex  - Wave number for commit message
+ */
+export function ensureTaskFilesCommitted(
+	waveTasks: string[],
+	pending: Map<string, ParsedTask>,
+	repoRoot: string,
+	waveIndex: number,
+): void {
+	// Collect task folder paths for this wave
+	const foldersToCheck: { taskId: string; relPath: string }[] = [];
+	for (const taskId of waveTasks) {
+		const task = pending.get(taskId);
+		if (!task) continue;
+
+		const absFolder = resolve(task.taskFolder);
+		const relPath = relative(resolve(repoRoot), absFolder).replace(/\\/g, "/");
+
+		// Skip if path escapes the repo (shouldn't happen in normal use)
+		if (relPath.startsWith("..")) {
+			continue;
+		}
+		foldersToCheck.push({ taskId, relPath });
+	}
+
+	if (foldersToCheck.length === 0) return;
+
+	// Check which folders have untracked or uncommitted files
+	const foldersToStage: string[] = [];
+	for (const { taskId, relPath } of foldersToCheck) {
+		const status = runGit(["status", "--porcelain", "--", relPath], repoRoot);
+		if (status.ok && status.stdout.trim()) {
+			execLog("wave", `W${waveIndex}`, `task ${taskId} has uncommitted files, staging`, {
+				folder: relPath,
+				status: status.stdout.trim().split("\n").slice(0, 5).join("; "),
+			});
+			foldersToStage.push(relPath);
+		}
+	}
+
+	if (foldersToStage.length === 0) return;
+
+	// Stage only the task folders
+	for (const folder of foldersToStage) {
+		const addResult = runGit(["add", "--", folder], repoRoot);
+		if (!addResult.ok) {
+			execLog("wave", `W${waveIndex}`, `failed to stage task files: ${addResult.stderr}`, { folder });
+			throw new ExecutionError(
+				"EXEC_TASK_STAGE_FAILED",
+				`Failed to stage task files in "${folder}": ${addResult.stderr}`,
+				"wave",
+				folder,
+			);
+		}
+	}
+
+	// Commit
+	const taskIds = foldersToStage.map(f => f.split("/").pop() || f).join(", ");
+	const commitMsg = `chore: stage task files for orchestrator wave ${waveIndex} (${taskIds})`;
+	const commitResult = runGit(["commit", "-m", commitMsg], repoRoot);
+	if (!commitResult.ok) {
+		execLog("wave", `W${waveIndex}`, `failed to commit task files: ${commitResult.stderr}`);
+		throw new ExecutionError(
+			"EXEC_TASK_COMMIT_FAILED",
+			`Failed to commit task files for wave ${waveIndex}: ${commitResult.stderr}`,
+			"wave",
+			`W${waveIndex}`,
+		);
+	}
+
+	execLog("wave", `W${waveIndex}`, `committed ${foldersToStage.length} task folder(s) to ensure worktree visibility`, {
+		folders: foldersToStage,
+		commit: commitResult.stdout.trim().split("\n")[0],
+	});
+}
+
 // ── Wave Execution Core ──────────────────────────────────────────────
 
 /**
@@ -1432,6 +1547,34 @@ export async function executeWave(
 		batchId,
 	});
 
+	// ── Stage 0: Ensure task files are committed ────────────────
+	// Task folders may contain untracked files (PROMPT.md, STATUS.md) that
+	// won't appear in worktrees unless committed. Stage and commit them now,
+	// before worktree creation, so workers can find their TASK_AUTOSTART paths.
+	try {
+		ensureTaskFilesCommitted(waveTasks, pending, repoRoot, waveIndex);
+	} catch (err: unknown) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		execLog("wave", `W${waveIndex}`, `task file commit failed: ${errMsg}`);
+
+		return {
+			waveIndex,
+			startedAt,
+			endedAt: Date.now(),
+			laneResults: [],
+			policyApplied: policy,
+			stoppedEarly: true,
+			failedTaskIds: waveTasks,
+			skippedTaskIds: [],
+			succeededTaskIds: [],
+			blockedTaskIds: [...computeTransitiveDependents(new Set(waveTasks), dependencyGraph)],
+			laneCount: 0,
+			overallStatus: "failed",
+			finalMonitorState: null,
+			allocatedLanes: [],
+		};
+	}
+
 	// ── Stage 1: Allocate lanes ──────────────────────────────────
 	const allocResult = allocateLanes(waveTasks, pending, config, repoRoot, batchId);
 

package/extensions/taskplane/extension.ts

@@ -1,6 +1,8 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 
 import { execSync } from "child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
 
 import {
 	DEFAULT_ORCHESTRATOR_CONFIG,
@@ -10,7 +12,6 @@ import {
 	createOrchWidget,
 	deleteBatchState,
 	detectOrphanSessions,
-	executeAbort,
 	executeLane,
 	executeOrchBatch,
 	formatDependencyGraph,
@@ -347,113 +348,144 @@ export default function (pi: ExtensionAPI) {
 	pi.registerCommand("orch-abort", {
 		description: "Abort batch: /orch-abort [--hard]",
 		handler: async (args, ctx) => {
-			const hard = args?.trim() === "--hard";
-			const mode: AbortMode = hard ? "hard" : "graceful";
-			const prefix = orchConfig.orchestrator.tmux_prefix;
-			const gracePeriodMs = orchConfig.orchestrator.abort_grace_period * 1000;
-
-			// Check for active in-memory batch
-			const hasActiveBatch = orchBatchState.phase !== "idle" &&
-				orchBatchState.phase !== "completed" &&
-				orchBatchState.phase !== "failed" &&
-				orchBatchState.phase !== "stopped";
-
-			// Also check for persisted state (abort can work on orphaned batches too)
-			let persistedState: PersistedBatchState | null = null;
 			try {
-				persistedState = loadBatchState(ctx.cwd);
-			} catch {
-				// Ignore — we may still have in-memory state or orphan sessions
-			}
+				const hard = args?.trim() === "--hard";
+				const mode: AbortMode = hard ? "hard" : "graceful";
+				const prefix = orchConfig.orchestrator.tmux_prefix;
+				const gracePeriodMs = orchConfig.orchestrator.abort_grace_period * 1000;
+
+				ctx.ui.notify(`🛑 Abort requested (${mode} mode, prefix: ${prefix})...`, "info");
+
+				// ── Step 1: Write abort signal file immediately ──────────
+				// This is the primary abort mechanism. The orchestrator's polling
+				// loop checks for this file on every cycle, so even if this command
+				// handler runs concurrently with /orch (or is queued behind it),
+				// the signal file will be detected.
+				const abortSignalFile = join(ctx.cwd, ".pi", "orch-abort-signal");
+				try {
+					mkdirSync(join(ctx.cwd, ".pi"), { recursive: true });
+					writeFileSync(abortSignalFile, `abort requested at ${new Date().toISOString()} (mode: ${mode})`, "utf-8");
+					ctx.ui.notify("  ✓ Abort signal file written (.pi/orch-abort-signal)", "info");
+				} catch (err) {
+					ctx.ui.notify(`  ⚠ Failed to write abort signal file: ${err instanceof Error ? err.message : String(err)}`, "warning");
+				}
 
-			// If no in-memory batch AND no persisted state, check for orphan sessions
-			if (!hasActiveBatch && !persistedState) {
-				// Last chance: check for orphan sessions
-				const sessionNames = parseOrchSessionNames(
-					(() => {
-						try {
-							return execSync('tmux list-sessions -F "#{session_name}"', {
-								encoding: "utf-8",
-								timeout: 5000,
-							});
-						} catch {
-							return "";
-						}
-					})(),
-					prefix,
-				);
-				if (sessionNames.length === 0) {
-					ctx.ui.notify(ORCH_MESSAGES.abortNoBatch(), "warning");
-					return;
+				// ── Step 2: Set pause signal immediately ─────────────────
+				// Belt-and-suspenders: if the /orch polling loop can see this
+				// shared object, it will stop on the next iteration.
+				if (orchBatchState.pauseSignal) {
+					orchBatchState.pauseSignal.paused = true;
+					ctx.ui.notify("  ✓ Pause signal set on in-memory batch state", "info");
 				}
-				// If orphan sessions exist, proceed with abort (will kill them)
-			}
 
-			const batchId = orchBatchState.batchId || persistedState?.batchId || "unknown";
+				// ── Step 3: Check what we're aborting ────────────────────
+				const hasActiveBatch = orchBatchState.phase !== "idle" &&
+					orchBatchState.phase !== "completed" &&
+					orchBatchState.phase !== "failed" &&
+					orchBatchState.phase !== "stopped";
+
+				let persistedState: PersistedBatchState | null = null;
+				try {
+					persistedState = loadBatchState(ctx.cwd);
+				} catch {
+					// Ignore — we may still have in-memory state or orphan sessions
+				}
 
-			// Notify user of abort start
-			if (mode === "graceful") {
-				const sessionCount = orchBatchState.currentLanes.length || persistedState?.tasks.length || 0;
-				ctx.ui.notify(ORCH_MESSAGES.abortGracefulStarting(batchId, sessionCount), "info");
 				ctx.ui.notify(
-					ORCH_MESSAGES.abortGracefulWaiting(batchId, orchConfig.orchestrator.abort_grace_period),
+					`  Batch state: in-memory=${hasActiveBatch ? orchBatchState.phase : "none"}, ` +
+					`persisted=${persistedState ? persistedState.batchId : "none"}`,
 					"info",
 				);
-			} else {
-				const sessionCount = orchBatchState.currentLanes.length || persistedState?.tasks.length || 0;
-				ctx.ui.notify(ORCH_MESSAGES.abortHardStarting(batchId, sessionCount), "info");
-			}
 
-			// Execute abort
-			const result = await executeAbort(
-				mode,
-				prefix,
-				ctx.cwd,
-				orchBatchState,
-				persistedState,
-				gracePeriodMs,
-			);
+				// ── Step 4: Scan for tmux sessions ──────────────────────
+				let allSessionNames: string[] = [];
+				try {
+					const tmuxOutput = execSync('tmux list-sessions -F "#{session_name}"', {
+						encoding: "utf-8",
+						timeout: 5000,
+					}).trim();
+					const all = tmuxOutput ? tmuxOutput.split("\n").map(s => s.trim()).filter(Boolean) : [];
+					allSessionNames = all.filter(name => name.startsWith(`${prefix}-`));
+					ctx.ui.notify(`  Found ${allSessionNames.length} session(s) matching prefix "${prefix}-": ${allSessionNames.join(", ") || "(none)"}`, "info");
+				} catch {
+					ctx.ui.notify("  ⚠ Could not list tmux sessions (tmux not available?)", "warning");
+				}
 
-			// Update in-memory batch state
-			orchBatchState.phase = "stopped";
-			orchBatchState.endedAt = result.durationMs + Date.now() - result.durationMs; // Use actual time
-			updateOrchWidget();
+				// If no batch AND no sessions, nothing to abort
+				if (!hasActiveBatch && !persistedState && allSessionNames.length === 0) {
+					ctx.ui.notify(ORCH_MESSAGES.abortNoBatch(), "warning");
+					// Clean up signal file
+					try { unlinkSync(abortSignalFile); } catch {}
+					return;
+				}
+
+				const batchId = orchBatchState.batchId || persistedState?.batchId || "unknown";
 
-			// Notify results
-			const durationSec = Math.round(result.durationMs / 1000);
-			if (mode === "graceful") {
-				const forceKilled = result.sessionsKilled - result.gracefulExits;
-				if (forceKilled > 0) {
-					ctx.ui.notify(
-						ORCH_MESSAGES.abortGracefulForceKill(forceKilled),
-						"warning",
-					);
+				// ── Step 5: Kill sessions directly (fast path) ──────────
+				// For hard mode or when sessions are found, kill them immediately
+				// rather than waiting through the full executeAbort flow.
+				if (allSessionNames.length > 0) {
+					ctx.ui.notify(`  Killing ${allSessionNames.length} tmux session(s)...`, "info");
+					let killed = 0;
+					for (const name of allSessionNames) {
+						try {
+							// Kill child sessions first (worker, reviewer)
+							execSync(`tmux kill-session -t "${name}-worker" 2>/dev/null`, { timeout: 3000 }).toString();
+						} catch {}
+						try {
+							execSync(`tmux kill-session -t "${name}-reviewer" 2>/dev/null`, { timeout: 3000 }).toString();
+						} catch {}
+						try {
+							execSync(`tmux kill-session -t "${name}" 2>/dev/null`, { timeout: 3000 }).toString();
+							killed++;
+							ctx.ui.notify(`    ✓ Killed: ${name}`, "info");
+						} catch {
+							// Session may have already exited
+							ctx.ui.notify(`    · ${name} (already exited)`, "info");
+							killed++;
+						}
+					}
+					ctx.ui.notify(`  ✓ ${killed}/${allSessionNames.length} session(s) terminated`, "info");
+				} else {
+					ctx.ui.notify("  No tmux sessions to kill", "info");
 				}
+
+				// ── Step 6: Clean up batch state ────────────────────────
+				try {
+					orchBatchState.phase = "stopped";
+					orchBatchState.endedAt = Date.now();
+					updateOrchWidget();
+					ctx.ui.notify("  ✓ In-memory batch state set to 'stopped'", "info");
+				} catch (err) {
+					ctx.ui.notify(`  ⚠ Failed to update in-memory state: ${err instanceof Error ? err.message : String(err)}`, "warning");
+				}
+
+				try {
+					deleteBatchState(ctx.cwd);
+					ctx.ui.notify("  ✓ Batch state file deleted (.pi/batch-state.json)", "info");
+				} catch (err) {
+					ctx.ui.notify(`  ⚠ Failed to delete batch state file: ${err instanceof Error ? err.message : String(err)}`, "warning");
+				}
+
+				// ── Step 7: Clean up abort signal file ───────────────────
+				try { unlinkSync(abortSignalFile); } catch {}
+
+				// ── Done ─────────────────────────────────────────────────
 				ctx.ui.notify(
-					ORCH_MESSAGES.abortGracefulComplete(batchId, result.gracefulExits, forceKilled, durationSec),
-					"info",
-				);
-			} else {
-				ctx.ui.notify(
-					ORCH_MESSAGES.abortHardComplete(batchId, result.sessionsKilled, durationSec),
+					`✅ Abort complete for batch ${batchId}. Sessions killed, state cleaned up.\n` +
+					`   Worktrees and branches are preserved for inspection.`,
 					"info",
 				);
-			}
-
-			// Report errors if any
-			if (result.errors.length > 0) {
-				const errorDetails = result.errors.map(e => `  • [${e.code}] ${e.message}`).join("\n");
+			} catch (err) {
+				// Top-level catch: ensure the user ALWAYS sees something
 				ctx.ui.notify(
-					`${ORCH_MESSAGES.abortPartialFailure(result.errors.length)}\n${errorDetails}`,
-					"warning",
+					`❌ Abort failed with error: ${err instanceof Error ? err.message : String(err)}\n` +
+					`   Stack: ${err instanceof Error ? err.stack : "N/A"}\n\n` +
+					`   Manual cleanup: tmux kill-server (kills ALL tmux sessions)\n` +
+					`   Or: tmux kill-session -t <session-name> for each session`,
+					"error",
 				);
 			}
-
-			// Final message
-			ctx.ui.notify(
-				ORCH_MESSAGES.abortComplete(mode, result.sessionsKilled),
-				"info",
-			);
 		},
 	});
 

package/extensions/taskplane/types.ts

@@ -559,6 +559,8 @@ export const SESSION_SPAWN_RETRY_MAX = 2;
  * - EXEC_SPAWN_FAILED: TMUX session could not be created after retries
  * - EXEC_TASK_FAILED: task completed without .DONE (non-zero exit)
  * - EXEC_TASK_STALLED: STATUS.md unchanged for stall_timeout (handled by Step 3)
+ * - EXEC_TASK_STAGE_FAILED: git add failed for task files
+ * - EXEC_TASK_COMMIT_FAILED: git commit failed for staged task files
  * - EXEC_TMUX_NOT_AVAILABLE: tmux binary not found
  * - EXEC_WORKTREE_MISSING: lane worktree path doesn't exist
  */
@@ -566,6 +568,8 @@ export type ExecutionErrorCode =
 	| "EXEC_SPAWN_FAILED"
 	| "EXEC_TASK_FAILED"
 	| "EXEC_TASK_STALLED"
+	| "EXEC_TASK_STAGE_FAILED"
+	| "EXEC_TASK_COMMIT_FAILED"
 	| "EXEC_TMUX_NOT_AVAILABLE"
 	| "EXEC_WORKTREE_MISSING";
 

package/package.json

@@ -1,57 +1,57 @@
-{
-  "name": "taskplane",
-  "version": "0.1.6",
-  "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
-  "keywords": [
-    "pi-package",
-    "ai",
-    "agent",
-    "orchestration",
-    "task-runner",
-    "parallel"
-  ],
-  "bin": {
-    "taskplane": "bin/taskplane.mjs"
-  },
-  "pi": {
-    "extensions": [
-      "./extensions/task-runner.ts",
-      "./extensions/task-orchestrator.ts"
-    ],
-    "skills": [
-      "./skills"
-    ]
-  },
-  "type": "module",
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "files": [
-    "bin/",
-    "dashboard/",
-    "extensions/task-runner.ts",
-    "extensions/task-orchestrator.ts",
-    "extensions/taskplane/",
-    "skills/",
-    "templates/"
-  ],
-  "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
-    "@mariozechner/pi-ai": "*",
-    "@sinclair/typebox": "*"
-  },
-  "dependencies": {
-    "yaml": "^2.4.0"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/HenryLach/taskplane.git"
-  },
-  "homepage": "https://github.com/HenryLach/taskplane#readme",
-  "bugs": {
-    "url": "https://github.com/HenryLach/taskplane/issues"
-  },
-  "author": "Henry Lach"
-}
+{
+  "name": "taskplane",
+  "version": "0.1.8",
+  "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
+  "keywords": [
+    "pi-package",
+    "ai",
+    "agent",
+    "orchestration",
+    "task-runner",
+    "parallel"
+  ],
+  "bin": {
+    "taskplane": "bin/taskplane.mjs"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/task-runner.ts",
+      "./extensions/task-orchestrator.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "bin/",
+    "dashboard/",
+    "extensions/task-runner.ts",
+    "extensions/task-orchestrator.ts",
+    "extensions/taskplane/",
+    "skills/",
+    "templates/"
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@mariozechner/pi-ai": "*",
+    "@sinclair/typebox": "*"
+  },
+  "dependencies": {
+    "yaml": "^2.4.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HenryLach/taskplane.git"
+  },
+  "homepage": "https://github.com/HenryLach/taskplane#readme",
+  "bugs": {
+    "url": "https://github.com/HenryLach/taskplane/issues"
+  },
+  "author": "Henry Lach"
+}