@pantheon.ai/agents 0.3.1 → 0.3.2

package/README.md

@@ -60,15 +60,19 @@ Example migration added in this version:
 
 - `src/db/migrations/tidb/20260304_0001_add_task_retry_columns.sql`
 - `src/db/migrations/db9/20260304_0001_add_task_retry_columns.sql`
+- `src/db/migrations/tidb/20260305_0002_add_agent_config_envs.sql`
+- `src/db/migrations/db9/20260305_0002_add_agent_config_envs.sql`
 
 Apply manually:
 
 ```bash
 # TiDB/MySQL
 mysql --host 127.0.0.1 --port 4000 -u root pantheon_agents < src/db/migrations/tidb/20260304_0001_add_task_retry_columns.sql
+mysql --host 127.0.0.1 --port 4000 -u root pantheon_agents < src/db/migrations/tidb/20260305_0002_add_agent_config_envs.sql
 
 # db9/PostgreSQL
 psql "$DATABASE_URL" -f src/db/migrations/db9/20260304_0001_add_task_retry_columns.sql
+psql "$DATABASE_URL" -f src/db/migrations/db9/20260305_0002_add_agent_config_envs.sql
 ```
 
 ## Developer Local Setup
@@ -112,6 +116,9 @@ pantheon-agents config reviewer "Download some files" --project-id 019c0495-f77a
 
 # update role on later config request
 pantheon-agents config reviewer "Switch to review workflow" --project-id 019c0495-f77a-7b6c-ade0-6b59c6654617 --role reviewer
+
+# set per-project branch envs (passed on every task start)
+pantheon-agents config reviewer "Use Anthropic model" --project-id 019c0495-f77a-7b6c-ade0-6b59c6654617 --envs '{"ANTHROPIC_MODEL":"claude-opus-4-5"}'
 ```
 
 ### 2) Add a task
@@ -159,6 +166,7 @@ pantheon-agents show-tasks --all
 pantheon-agents get-task <agent-name> <task-id>
 pantheon-agents cancel-task <agent-name> <task-id> [reason] --yes
 pantheon-agents retry-task <agent-name> <task-id> [reason] --yes
+pantheon-agents kill <agent-name> <task-id> [reason] --yes
 pantheon-agents skill.sh
 pantheon-agents gen-migration-sql --provider tidb --from 0.3.0
 pantheon-agents delete-task <agent-name> <task-id>

package/dist/index.js

@@ -399,7 +399,7 @@ var require_cli_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 
 //#endregion
 //#region package.json
-var version = "0.3.0";
+var version = "0.3.1";
 
 //#endregion
 //#region src/db/db9.ts
@@ -1664,7 +1664,9 @@ const projectSchema = z.object({
 	created_at: zodJsonDate,
 	updated_at: zodJsonDate,
 	branches_total: z.number().int().nullable().optional(),
-	background_tasks_total: z.number().int().nullable().optional()
+	background_tasks_total: z.number().int().nullable().optional(),
+	env_id: z.string().uuid().nullable().optional(),
+	env_display_name: z.string().nullable().optional()
 });
 const projectMessageSchema = z.object({
 	id: z.string(),
@@ -2025,6 +2027,7 @@ const executor = createApiExecutor({
 	headers: { Authorization: `Bearer ${process.env.PANTHEON_API_KEY}` },
 	validateResponse
 });
+const killProjectBranchExecutionApi = defineApi(post`/api/v1/projects/${"projectId"}/branches/${"branchId"}/kill`, typeOf(), "raw");
 async function getPantheonProjectInfo({ projectId }) {
 	return await executor.execute(getProject, { projectId }, null);
 }
@@ -2082,6 +2085,23 @@ async function executeOnPantheon({ projectId, branchId, prompt, agent }) {
 		parent_branch_id: branchId
 	})).branches[0];
 }
+function isNotFoundError(error) {
+	if (!(error instanceof Error)) return false;
+	const message = error.message.toLowerCase();
+	return message.includes("404") || message.includes("not found");
+}
+async function killPantheonBranchExecution({ projectId, branchId }) {
+	try {
+		await executor.execute(killProjectBranchExecutionApi, {
+			projectId,
+			branchId
+		}, {});
+		return [branchId];
+	} catch (error) {
+		if (isNotFoundError(error)) return [];
+		throw error;
+	}
+}
 
 //#endregion
 //#region src/core/task-list.ts
@@ -2807,6 +2827,7 @@ var WatchStepAggregator = class {
 //#region src/core/index.ts
 const DEFAULT_MAX_RETRY_ATTEMPTS = 3;
 const DEFAULT_RETRY_BACKOFF_SECONDS = 30;
+const DEFAULT_KILL_REASON = "Killed by user";
 async function runAgent(name, options, logger) {
 	const agentDir = path.join(options.dataDir, "agents", name);
 	const pidFile = path.join(agentDir, "pid");
@@ -3064,6 +3085,170 @@ async function retryTask(agentName, taskId, reason) {
 		await provider.close();
 	}
 }
+function resolveTaskAttemptCount(value) {
+	if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+	return 1;
+}
+function hasTaskBranchId(task) {
+	return "branch_id" in task && typeof task.branch_id === "string";
+}
+function collectKillBranchTargets(tasks, options = {}) {
+	const childrenByParentId = /* @__PURE__ */ new Map();
+	const taskById = /* @__PURE__ */ new Map();
+	for (const task of tasks) {
+		taskById.set(task.id, task);
+		if (!task.parent_task_id) continue;
+		const siblings = childrenByParentId.get(task.parent_task_id);
+		if (siblings) siblings.push(task);
+		else childrenByParentId.set(task.parent_task_id, [task]);
+	}
+	const roots = options.rootTaskIds && options.rootTaskIds.length > 0 ? options.rootTaskIds.map((taskId) => taskById.get(taskId)).filter((task) => task != null) : tasks.filter((task) => task.status === "pending" || task.status === "running");
+	if (roots.length === 0) return [];
+	const maxDepthByTaskId = /* @__PURE__ */ new Map();
+	const stack = roots.map((task) => ({
+		taskId: task.id,
+		depth: 0
+	}));
+	while (stack.length > 0) {
+		const item = stack.pop();
+		if (!item) continue;
+		const previousDepth = maxDepthByTaskId.get(item.taskId);
+		if (previousDepth != null && previousDepth >= item.depth) continue;
+		maxDepthByTaskId.set(item.taskId, item.depth);
+		const children = childrenByParentId.get(item.taskId) ?? [];
+		for (const child of children) stack.push({
+			taskId: child.id,
+			depth: item.depth + 1
+		});
+	}
+	const scoredTargets = [];
+	for (const [taskId, depth] of maxDepthByTaskId) {
+		const task = taskById.get(taskId);
+		if (!task || !hasTaskBranchId(task)) continue;
+		scoredTargets.push({
+			task_id: task.id,
+			project_id: task.project_id,
+			branch_id: task.branch_id,
+			depth,
+			queued_at_ms: task.queued_at.getTime()
+		});
+	}
+	scoredTargets.sort((a, b) => {
+		if (a.depth !== b.depth) return b.depth - a.depth;
+		return b.queued_at_ms - a.queued_at_ms;
+	});
+	const seen = /* @__PURE__ */ new Set();
+	const targets = [];
+	for (const target of scoredTargets) {
+		const key = `${target.project_id}:${target.branch_id}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		targets.push({
+			task_id: target.task_id,
+			project_id: target.project_id,
+			branch_id: target.branch_id
+		});
+	}
+	return targets;
+}
+function collectTaskSubtree(tasks, rootTaskId) {
+	const childrenByParentId = /* @__PURE__ */ new Map();
+	const taskById = /* @__PURE__ */ new Map();
+	for (const task of tasks) {
+		taskById.set(task.id, task);
+		if (!task.parent_task_id) continue;
+		const siblings = childrenByParentId.get(task.parent_task_id);
+		if (siblings) siblings.push(task);
+		else childrenByParentId.set(task.parent_task_id, [task]);
+	}
+	if (!taskById.has(rootTaskId)) return [];
+	const subtreeIds = /* @__PURE__ */ new Set();
+	const stack = [rootTaskId];
+	while (stack.length > 0) {
+		const taskId = stack.pop();
+		if (!taskId || subtreeIds.has(taskId)) continue;
+		subtreeIds.add(taskId);
+		const children = childrenByParentId.get(taskId) ?? [];
+		for (const child of children) stack.push(child.id);
+	}
+	return tasks.filter((task) => subtreeIds.has(task.id));
+}
+function toCancelledTask(task, reason, cancelledAt) {
+	return {
+		status: "cancelled",
+		id: task.id,
+		task: task.task,
+		type: task.type,
+		project_id: task.project_id,
+		base_branch_id: task.base_branch_id,
+		parent_task_id: task.parent_task_id ?? null,
+		config_version: task.config_version ?? null,
+		attempt_count: resolveTaskAttemptCount(task.attempt_count),
+		cancel_reason: reason,
+		queued_at: task.queued_at,
+		cancelled_at: cancelledAt
+	};
+}
+async function killAgentTasks(agentName, taskId, reason = DEFAULT_KILL_REASON, deps = {}) {
+	const provider = createTaskListProvider(agentName, pino());
+	try {
+		const tasks = await provider.getTasks({
+			order_by: "queued_at",
+			order_direction: "asc"
+		});
+		const subtreeTasks = collectTaskSubtree(tasks, taskId);
+		if (subtreeTasks.length === 0) return null;
+		const pendingTasks = subtreeTasks.filter((task) => task.status === "pending");
+		const runningTasks = subtreeTasks.filter((task) => task.status === "running");
+		for (const pendingTask of pendingTasks) await provider.cancelTask(pendingTask, reason);
+		const killTargets = collectKillBranchTargets(tasks, { rootTaskIds: [taskId] });
+		const killBranch = deps.killBranch ?? killPantheonBranchExecution;
+		const killedBranches = [];
+		const seenKilledBranchKeys = /* @__PURE__ */ new Set();
+		const failedBranchKills = [];
+		for (const target of killTargets) try {
+			const deletedBranchIds = await killBranch({
+				projectId: target.project_id,
+				branchId: target.branch_id
+			});
+			for (const deletedBranchId of deletedBranchIds) {
+				const branchKey = `${target.project_id}:${deletedBranchId}`;
+				if (seenKilledBranchKeys.has(branchKey)) continue;
+				seenKilledBranchKeys.add(branchKey);
+				killedBranches.push({
+					project_id: target.project_id,
+					branch_id: deletedBranchId
+				});
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			failedBranchKills.push({
+				task_id: target.task_id,
+				project_id: target.project_id,
+				branch_id: target.branch_id,
+				error: message
+			});
+		}
+		const now = /* @__PURE__ */ new Date();
+		const killedBranchKeys = new Set(killedBranches.map((item) => `${item.project_id}:${item.branch_id}`));
+		let runningCancelledCount = 0;
+		for (const runningTask of runningTasks) {
+			const branchKey = `${runningTask.project_id}:${runningTask.branch_id}`;
+			if (!killedBranchKeys.has(branchKey)) continue;
+			await provider.updateTask(toCancelledTask(runningTask, reason, now));
+			runningCancelledCount++;
+		}
+		return {
+			task_id: taskId,
+			pending_cancelled_count: pendingTasks.length,
+			running_cancelled_count: runningCancelledCount,
+			killed_branches: killedBranches,
+			failed_branch_kills: failedBranchKills
+		};
+	} finally {
+		await provider.close();
+	}
+}
 async function showAgentConfig(agentName, projectId) {
 	const provider = createTaskListProvider(agentName, pino());
 	try {
@@ -3477,6 +3662,56 @@ function createGetTaskCommand(version, deps = {}) {
 	});
 }
 
+//#endregion
+//#region src/cli/commands/kill.ts
+function createKillCommand(version, deps = {}) {
+	return createCommand("kill").version(version).description("Kill a task and its descendants recursively for an agent").argument("<name>", "The name of the agent.").argument("<task-id>", "Root task id to kill.").argument("[reason]", "Optional kill reason.").option("-y, --yes", "Skip confirmation prompt.").option("-f, --force", "Alias for --yes.").action(async function() {
+		const [name, taskId, reason] = this.args;
+		const options = this.opts();
+		if (!ensureEnv(["DATABASE_URL"])) return;
+		const rl = options.yes || options.force ? null : readline.createInterface({
+			input: process$1.stdin,
+			output: process$1.stdout
+		});
+		try {
+			if (rl) {
+				if ((await rl.question(`Type the agent name (${name}) to confirm kill: `)).trim() !== name) {
+					console.error("Confirmation failed. Agent name did not match.");
+					process$1.exitCode = 1;
+					return;
+				}
+				if ((await rl.question(`Type KILL ${taskId} to stop this task subtree and related branches: `)).trim() !== `KILL ${taskId}`) {
+					console.error("Confirmation failed. Aborting kill.");
+					process$1.exitCode = 1;
+					return;
+				}
+			}
+			const result = await (deps.killAgentTasks ?? killAgentTasks)(name, taskId, reason);
+			if (!result) {
+				console.error(`Task ${taskId} not found for agent ${name}.`);
+				process$1.exitCode = 1;
+				return;
+			}
+			const attemptedBranchKills = result.killed_branches.length + result.failed_branch_kills.length;
+			if (result.pending_cancelled_count === 0 && attemptedBranchKills === 0) {
+				console.log(`No actionable work found in task subtree ${taskId}.`);
+				return;
+			}
+			console.log(`Kill result for agent ${name} task ${taskId}: cancelled ${result.pending_cancelled_count} pending task(s), cancelled ${result.running_cancelled_count} running task(s).`);
+			if (result.killed_branches.length > 0) console.log(`Killed ${result.killed_branches.length} branch(es).`);
+			if (result.failed_branch_kills.length > 0) {
+				for (const failed of result.failed_branch_kills) console.error(`Failed to kill branch ${failed.branch_id} in project ${failed.project_id}: ${failed.error}`);
+				process$1.exitCode = 1;
+			}
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			process$1.exitCode = 1;
+		} finally {
+			rl?.close();
+		}
+	});
+}
+
 //#endregion
 //#region src/cli/commands/run.ts
 function createRunAgentCommand(version) {
@@ -6239,7 +6474,7 @@ function createWatchStreamCommand(version) {
 
 //#endregion
 //#region src/cli/index.ts
-const program = new Command().name("pantheon-agents").description("Pantheon agents CLI").version(version).showHelpAfterError().showSuggestionAfterError().addHelpCommand().addCommand(createAddTaskCommand(version)).addCommand(createConfigAgentCommand(version)).addCommand(createDeleteTaskCommand(version)).addCommand(createCancelTaskCommand(version)).addCommand(createGetTaskCommand(version)).addCommand(createRunAgentCommand(version)).addCommand(createRetryTaskCommand(version)).addCommand(createSkillShCommand(version)).addCommand(createGenMigrationSqlCommand(version)).addCommand(createShowConfigCommand(version)).addCommand(createShowTasksCommand(version)).addCommand(createWatchCommand(version)).addCommand(createWatchStreamCommand(version));
+const program = new Command().name("pantheon-agents").description("Pantheon agents CLI").version(version).showHelpAfterError().showSuggestionAfterError().addHelpCommand().addCommand(createAddTaskCommand(version)).addCommand(createConfigAgentCommand(version)).addCommand(createDeleteTaskCommand(version)).addCommand(createCancelTaskCommand(version)).addCommand(createGetTaskCommand(version)).addCommand(createKillCommand(version)).addCommand(createRunAgentCommand(version)).addCommand(createRetryTaskCommand(version)).addCommand(createSkillShCommand(version)).addCommand(createGenMigrationSqlCommand(version)).addCommand(createShowConfigCommand(version)).addCommand(createShowTasksCommand(version)).addCommand(createWatchCommand(version)).addCommand(createWatchStreamCommand(version));
 async function main() {
 	if (process$1.argv.length <= 2) {
 		program.outputHelp();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pantheon.ai/agents",
   "type": "module",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "bin": {
     "pantheon-agents": "dist/index.js"
   },