@pantheon.ai/agents 0.3.1 → 0.3.3

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/db/migrations/db9/20260305_0002_add_agent_config_envs.sql

@@ -0,0 +1,5 @@
+-- introduced_in: 0.3.2
+-- Add optional env overrides for per-project agent config (db9/PostgreSQL).
+
+ALTER TABLE agent_project_config
+  ADD COLUMN IF NOT EXISTS envs JSONB;

package/dist/db/migrations/tidb/20260305_0002_add_agent_config_envs.sql

@@ -0,0 +1,5 @@
+-- introduced_in: 0.3.2
+-- Add optional env overrides for per-project agent config (TiDB/MySQL).
+
+ALTER TABLE agent_project_config
+  ADD COLUMN IF NOT EXISTS envs JSON NULL;

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.3";
 
 //#endregion
 //#region src/db/db9.ts
@@ -639,6 +639,7 @@ var TaskListDb9Provider = class extends TaskListProvider {
 			"agent_project_config.retry_backoff_seconds",
 			"agent_project_config.role",
 			"agent_project_config.skills",
+			"agent_project_config.envs",
 			"agent_project_config.prototype_url",
 			"agent_project_config.execute_agent"
 		]).select((eb) => eb.ref("task.status").$castTo().as("config_task_status")).where("agent_project_config.project_id", "=", projectId).where("agent_project_config.agent", "=", this.agentName).executeTakeFirst();
@@ -657,26 +658,30 @@ var TaskListDb9Provider = class extends TaskListProvider {
 			"agent_project_config.retry_backoff_seconds",
 			"agent_project_config.role",
 			"agent_project_config.skills",
+			"agent_project_config.envs",
 			"agent_project_config.prototype_url",
 			"agent_project_config.execute_agent"
 		]).select((eb) => eb.ref("task.status").$castTo().as("config_task_status")).where("agent_project_config.agent", "=", this.agentName).execute();
 	}
-	async setAgentConfig({ skills, ...config }) {
+	async setAgentConfig({ skills, envs, ...config }) {
 		const maxRetryAttempts = config.max_retry_attempts ?? 3;
 		const retryBackoffSeconds = config.retry_backoff_seconds ?? 30;
 		await this.db.insertInto("agent_project_config").values({
 			agent: this.agentName,
 			skills: JSON.stringify(skills),
+			envs: JSON.stringify(envs ?? {}),
 			...config,
 			max_retry_attempts: maxRetryAttempts,
 			retry_backoff_seconds: retryBackoffSeconds
 		}).execute();
 	}
-	async updateAgentConfig({ skills, ...config }) {
+	async updateAgentConfig({ skills, envs, ...config }) {
 		const maxRetryAttempts = config.max_retry_attempts;
 		const retryBackoffSeconds = config.retry_backoff_seconds;
+		const resolvedEnvs = envs == null ? void 0 : JSON.stringify(envs);
 		const result = await this.db.updateTable("agent_project_config").set({
 			skills: JSON.stringify(skills),
+			...resolvedEnvs == null ? {} : { envs: resolvedEnvs },
 			...config,
 			...maxRetryAttempts == null ? {} : { max_retry_attempts: maxRetryAttempts },
 			...retryBackoffSeconds == null ? {} : { retry_backoff_seconds: retryBackoffSeconds }
@@ -783,22 +788,25 @@ var TaskListTidbProvider = class extends TaskListProvider {
 	async getAgentConfigs() {
 		return await this.db.selectFrom("agent_project_config").innerJoin("task", "task.id", "agent_project_config.config_task_id").selectAll("agent_project_config").select((eb) => eb.ref("task.status").$castTo().as("config_task_status")).where("agent_project_config.agent", "=", this.agentName).execute();
 	}
-	async setAgentConfig({ skills, ...config }) {
+	async setAgentConfig({ skills, envs, ...config }) {
 		const maxRetryAttempts = config.max_retry_attempts ?? 3;
 		const retryBackoffSeconds = config.retry_backoff_seconds ?? 30;
 		await this.db.insertInto("agent_project_config").values({
 			agent: this.agentName,
 			skills: JSON.stringify(skills),
+			envs: JSON.stringify(envs ?? {}),
 			...config,
 			max_retry_attempts: maxRetryAttempts,
 			retry_backoff_seconds: retryBackoffSeconds
 		}).execute();
 	}
-	async updateAgentConfig({ skills, ...config }) {
+	async updateAgentConfig({ skills, envs, ...config }) {
 		const maxRetryAttempts = config.max_retry_attempts;
 		const retryBackoffSeconds = config.retry_backoff_seconds;
+		const resolvedEnvs = envs == null ? void 0 : JSON.stringify(envs);
 		const result = await this.db.updateTable("agent_project_config").set({
 			skills: JSON.stringify(skills),
+			...resolvedEnvs == null ? {} : { envs: resolvedEnvs },
 			...config,
 			...maxRetryAttempts == null ? {} : { max_retry_attempts: maxRetryAttempts },
 			...retryBackoffSeconds == null ? {} : { retry_backoff_seconds: retryBackoffSeconds }
@@ -902,6 +910,20 @@ function normalizeSkills(value) {
 	}
 	return [];
 }
+function normalizeEnvs(value) {
+	const parseRecord = (input) => {
+		if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+		const result = {};
+		for (const [key, item] of Object.entries(input)) if (typeof item === "string") result[key] = item;
+		return result;
+	};
+	if (typeof value === "string") try {
+		return parseRecord(JSON.parse(value));
+	} catch {
+		return {};
+	}
+	return parseRecord(value);
+}
 function buildConfigSetupStep(options) {
 	const prototypeRepoUrl = normalizeRepoUrl(options.prototypeRepoUrl);
 	const skillsArg = JSON.stringify(options.skills.join(","));
@@ -1664,7 +1686,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(),
@@ -1785,6 +1809,7 @@ const listProjectBackgroundTasks = defineApi(get`/api/v1/projects/${"projectId"}
 const createProjectExploration = defineApi(post`/api/v1/projects/${"projectId"}/explorations`, typeOf(), createExplorationResultSchema);
 const listProjectExplorations = defineApi(get`/api/v1/projects/${"projectId"}/explorations`, null, explorationSchema.array());
 const getProjectExplorationResult = defineApi(get`/api/v1/projects/${"projectId"}/explorations/${"explorationId"}/result`, null, explorationResultSchema);
+const killProjectBranch = defineApi(post`/api/v1/projects/${"projectId"}/branches/${"branchId"}/kill`, typeOf(), snapSchema.nullable());
 const getProjectBranchFs = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/fs/${"path*"}`, null, FSResponseValidator);
 const getProjectBranchFsPreview = defineApi(get`/api/v1/projects/${"projectId"}/branches/${"branchId"}/preview/${"path*"}`, null, FSResponseValidator);
 
@@ -2073,15 +2098,33 @@ async function getPantheonBranchInfo({ projectId, branchId }) {
 		branchId
 	}, null);
 }
-async function executeOnPantheon({ projectId, branchId, prompt, agent }) {
+async function executeOnPantheon({ projectId, branchId, prompt, agent, envs }) {
 	const promptSequence = Array.isArray(prompt) ? prompt : [prompt];
 	return (await executor.execute(createProjectExploration, { projectId }, {
 		shared_prompt_sequence: promptSequence,
 		num_branches: 1,
 		agent,
-		parent_branch_id: branchId
+		parent_branch_id: branchId,
+		envs
 	})).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(killProjectBranch, {
+			projectId,
+			branchId
+		}, {});
+		return [branchId];
+	} catch (error) {
+		if (isNotFoundError(error)) return [];
+		throw error;
+	}
+}
 
 //#endregion
 //#region src/core/task-list.ts
@@ -2226,6 +2269,7 @@ async function pollRunningTaskState(provider, state, logger) {
 			execute_agent: config.execute_agent,
 			role: config.role,
 			skills: normalizeSkills(config.skills),
+			envs: normalizeEnvs(config.envs),
 			prototype_url: config.prototype_url
 		});
 	} else if (newStatus.state === "failed") {
@@ -2330,7 +2374,8 @@ async function startPendingTask(provider, task, config, logger) {
 			projectId: taskToStart.project_id,
 			branchId: taskToStart.base_branch_id,
 			prompt: promptSequence,
-			agent: config.execute_agent
+			agent: config.execute_agent,
+			envs: normalizeEnvs(config.envs)
 		});
 	});
 	logger.info(`Task ${taskToStart.id} started successfully on branch [id = ${taskBranch.branch_id}, snap_id = ${taskBranch.latest_snap_id}]`);
@@ -2807,6 +2852,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");
@@ -2856,6 +2902,7 @@ async function configAgent(name, options) {
 			return;
 		}
 		const resolvedSkills = options.skills ?? normalizeSkills(previousConfig?.skills);
+		const resolvedEnvs = options.envs ?? normalizeEnvs(previousConfig?.envs);
 		const resolvedExecuteAgent = options.executeAgent.trim() || previousConfig?.execute_agent || "codex";
 		const resolvedPrototypeUrl = options.prototypeUrl.trim() || previousConfig?.prototype_url || "https://github.com/pingcap-inc/pantheon-agents";
 		const baseBranchId = previousConfig ? previousConfig.base_branch_id : await resolveInitialBaseBranchId(options.projectId, options.rootBranchId);
@@ -2890,6 +2937,7 @@ async function configAgent(name, options) {
 				execute_agent: resolvedExecuteAgent,
 				role: resolvedRole ?? previousConfig.role,
 				skills: resolvedSkills,
+				envs: resolvedEnvs,
 				prototype_url: resolvedPrototypeUrl
 			});
 			if (!options.prompt) await provider.updateTask({
@@ -2959,6 +3007,7 @@ async function configAgent(name, options) {
 				execute_agent: resolvedExecuteAgent,
 				role: resolvedRole,
 				skills: resolvedSkills,
+				envs: resolvedEnvs,
 				prototype_url: resolvedPrototypeUrl
 			});
 			else await provider.updateAgentConfig({
@@ -2972,6 +3021,7 @@ async function configAgent(name, options) {
 				execute_agent: resolvedExecuteAgent,
 				role: resolvedRole ?? previousConfig.role,
 				skills: resolvedSkills,
+				envs: resolvedEnvs,
 				prototype_url: resolvedPrototypeUrl
 			});
 			for (const pendingTask of pendingTasks) {
@@ -3064,6 +3114,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 {
@@ -3364,8 +3578,25 @@ function parsePositiveInteger(value, fieldName) {
 	if (!Number.isInteger(parsed) || parsed <= 0) throw new InvalidArgumentError(`${fieldName} must be a positive integer.`);
 	return parsed;
 }
+function parseEnvs(value) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new InvalidArgumentError("envs must be a JSON object of string values.");
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		throw new InvalidArgumentError("envs must be valid JSON.");
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new InvalidArgumentError("envs must be a JSON object.");
+	const out = {};
+	for (const [key, item] of Object.entries(parsed)) {
+		if (typeof item !== "string") throw new InvalidArgumentError(`envs.${key} must be a string value.`);
+		out[key] = item;
+	}
+	return out;
+}
 function createConfigAgentCommand(version, deps = {}) {
-	return createCommand("config").version(version).description("Queue a configuration task for an agent/project").argument("<name>", "The name of the agent.").argument("[prompt]", "The configuration task prompt.").option("--project-id <project-id>", "The project id of the agent. Defaults to DEFAULT_PANTHEON_PROJECT_ID.").option("--task-id <task-id>", "Optional parent task id.").option("--role <role>", "Role metadata. Required for first-time project config; optional override later.").option("--skills <skills>", "The skills of the agent. Multiple values are separated by comma.", parseUniqueCommaList).option("--execute-agent <agent>", "The execute agent of the agent.", "codex").option("--concurrency <number>", "Max number of parallel running tasks for this project.", parseConcurrency).option("--max-retry-attempts <number>", "Max automatic retry attempts per task after failures.", (value) => parseNonNegativeInteger(value, "max-retry-attempts")).option("--retry-backoff-seconds <seconds>", "Base delay (seconds) for exponential retry backoff.", (value) => parsePositiveInteger(value, "retry-backoff-seconds")).option("--root-branch-id <branchId>", "The root branch id of the agent. Defaults to DEFAULT_PANTHEON_ROOT_BRANCH_ID, then project root branch id.").option("--prototype-url <url>", "Role and skill definitions repo.", "https://github.com/pingcap-inc/pantheon-agents").action(async function() {
+	return createCommand("config").version(version).description("Queue a configuration task for an agent/project").argument("<name>", "The name of the agent.").argument("[prompt]", "The configuration task prompt.").option("--project-id <project-id>", "The project id of the agent. Defaults to DEFAULT_PANTHEON_PROJECT_ID.").option("--task-id <task-id>", "Optional parent task id.").option("--role <role>", "Role metadata. Required for first-time project config; optional override later.").option("--skills <skills>", "The skills of the agent. Multiple values are separated by comma.", parseUniqueCommaList).option("--execute-agent <agent>", "The execute agent of the agent.", "codex").option("--concurrency <number>", "Max number of parallel running tasks for this project.", parseConcurrency).option("--max-retry-attempts <number>", "Max automatic retry attempts per task after failures.", (value) => parseNonNegativeInteger(value, "max-retry-attempts")).option("--retry-backoff-seconds <seconds>", "Base delay (seconds) for exponential retry backoff.", (value) => parsePositiveInteger(value, "retry-backoff-seconds")).option("--root-branch-id <branchId>", "The root branch id of the agent. Defaults to DEFAULT_PANTHEON_ROOT_BRANCH_ID, then project root branch id.").option("--prototype-url <url>", "Role and skill definitions repo.", "https://github.com/pingcap-inc/pantheon-agents").option("--envs <json>", "Pantheon branch envs in JSON object format, e.g. '{\"ANTHROPIC_MODEL\":\"claude-opus-4-5\"}'.", parseEnvs).action(async function() {
 		const [name, prompt] = this.args;
 		const options = this.opts();
 		const resolvedProjectId = resolvePantheonProjectId(options.projectId);
@@ -3386,6 +3617,7 @@ function createConfigAgentCommand(version, deps = {}) {
 			maxRetryAttempts: options.maxRetryAttempts,
 			retryBackoffSeconds: options.retryBackoffSeconds,
 			skills: options.skills,
+			envs: options.envs,
 			prototypeUrl: options.prototypeUrl,
 			rootBranchId: resolvedRootBranchId
 		});
@@ -3477,6 +3709,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) {
@@ -3539,7 +3821,8 @@ function createShowConfigCommand(version) {
 				role: config.role,
 				execute_agent: config.execute_agent,
 				prototype_url: config.prototype_url,
-				skills: Array.isArray(config.skills) ? config.skills.join(", ") : String(config.skills)
+				skills: Array.isArray(config.skills) ? config.skills.join(", ") : String(config.skills),
+				envs: config.envs && typeof config.envs === "object" ? JSON.stringify(config.envs) : String(config.envs ?? "{}")
 			}]);
 			return;
 		}
@@ -3565,7 +3848,8 @@ function createShowConfigCommand(version) {
 			role: config.role,
 			execute_agent: config.execute_agent,
 			prototype_url: config.prototype_url,
-			skills: Array.isArray(config.skills) ? config.skills.join(", ") : String(config.skills)
+			skills: Array.isArray(config.skills) ? config.skills.join(", ") : String(config.skills),
+			envs: config.envs && typeof config.envs === "object" ? JSON.stringify(config.envs) : String(config.envs ?? "{}")
 		})));
 	});
 }
@@ -6239,7 +6523,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.3",
   "bin": {
     "pantheon-agents": "dist/index.js"
   },