@code-yeongyu/senpi 2026.7.10 → 2026.7.13

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/agent-bridge.ts

@@ -0,0 +1,197 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { type Static, Type } from "typebox";
+import { Check, Errors } from "typebox/value";
+import type { EvalStatusEvent, ExecuteTool } from "../tool/types.ts";
+
+const agentArgsSchema = Type.Object(
+	{
+		prompt: Type.String({ minLength: 1 }),
+		agent: Type.Optional(Type.String({ minLength: 1 })),
+		model: Type.Optional(Type.String({ minLength: 1 })),
+		label: Type.Optional(Type.String()),
+		schema: Type.Optional(Type.Unknown()),
+		handle: Type.Optional(Type.Boolean()),
+		isolated: Type.Optional(Type.Boolean()),
+		apply: Type.Optional(Type.Boolean()),
+		merge: Type.Optional(Type.Boolean()),
+	},
+	{ additionalProperties: false },
+);
+
+const unsupportedIsolationWarning = "isolated/apply/merge unsupported (no isolation in task engine)";
+const taskIdPattern = /\bst_[A-Za-z0-9_-]+\b/;
+const droppedOptionNames = ["isolated", "apply", "merge"] as const;
+
+type AgentArgs = Static<typeof agentArgsSchema>;
+type TaskParams = {
+	readonly prompt: string;
+	readonly subagent_type?: string;
+	readonly model?: string;
+	readonly name?: string;
+	readonly run_in_background: boolean;
+};
+type ProgressContext = { readonly fallbackId: string; readonly warning?: string };
+
+export type AgentExecuteTool = ExecuteTool & {
+	readonly isToolAvailable?: (name: string) => boolean;
+};
+
+export interface RunEvalAgentOptions {
+	readonly callId: string;
+	readonly taskToolName: string;
+	readonly executeTool: AgentExecuteTool;
+	readonly signal?: AbortSignal;
+	readonly emitStatus?: (event: EvalStatusEvent) => void;
+}
+
+export type EvalAgentResult =
+	| { readonly text: string }
+	| { readonly text: string; readonly data: unknown }
+	| { readonly text: string; readonly parseError: string }
+	| { readonly text: string; readonly id: string; readonly handle: string };
+
+class AgentArgumentsError extends Error {
+	readonly name = "AgentArgumentsError";
+
+	constructor(summary: string) {
+		super(`agent() received invalid arguments: ${summary}`);
+	}
+}
+
+class AgentUnavailableError extends Error {
+	readonly name = "AgentUnavailableError";
+
+	constructor(toolName: string) {
+		super(`agent() unavailable: no "${toolName}" tool is registered in this session`);
+	}
+}
+
+class AgentHandleError extends Error {
+	readonly name = "AgentHandleError";
+
+	constructor() {
+		super("agent() background task result did not include a task id");
+	}
+}
+
+export async function runEvalAgent(args: unknown, options: RunEvalAgentOptions): Promise<EvalAgentResult> {
+	const parsed = parseAgentArgs(args);
+	const structured = Object.hasOwn(parsed, "schema");
+	const warning = droppedOptionsWarning(parsed);
+	const fallbackId = parsed.label ?? options.callId;
+	if (warning) options.emitStatus?.({ op: "agent", id: fallbackId, status: "running", warning });
+
+	// omp assertNotPlanMode intentionally dropped: senpi has no plan mode
+	// senpi-task children lose task tools, so recursion self-gates without a depth counter.
+	if (options.executeTool.isToolAvailable?.(options.taskToolName) === false) {
+		throw new AgentUnavailableError(options.taskToolName);
+	}
+
+	let result: AgentToolResult<unknown>;
+	try {
+		result = await options.executeTool(options.taskToolName, toTaskParams(parsed, structured), {
+			...(options.signal ? { signal: options.signal } : {}),
+			...(options.emitStatus
+				? {
+						onUpdate: (update: AgentToolResult<unknown>) =>
+							options.emitStatus?.(toProgressEvent(update, { fallbackId, ...(warning ? { warning } : {}) })),
+					}
+				: {}),
+		});
+	} catch (error) {
+		if (isUnavailableToolError(error)) throw new AgentUnavailableError(options.taskToolName);
+		throw error;
+	}
+
+	const text = resultText(result);
+	if (parsed.handle === true) {
+		const id = resultTaskId(result, text);
+		if (!id) throw new AgentHandleError();
+		return { text, id, handle: `agent://${id}` };
+	}
+	if (!structured) return { text };
+	return parseStructuredText(text);
+}
+
+function parseAgentArgs(value: unknown): AgentArgs {
+	if (Check(agentArgsSchema, value)) return value;
+	const summary = Errors(agentArgsSchema, value)
+		.map((error) => `${error.instancePath || "/"} ${error.message}`)
+		.join("; ");
+	throw new AgentArgumentsError(summary || "invalid value");
+}
+
+function toTaskParams(args: AgentArgs, structured: boolean): TaskParams {
+	return {
+		prompt: structured
+			? `${args.prompt}\n\nRespond ONLY with JSON matching this JSON-Schema:\n${JSON.stringify(args.schema)}`
+			: args.prompt,
+		...(args.agent === undefined ? {} : { subagent_type: args.agent }),
+		...(args.model === undefined ? {} : { model: args.model }),
+		...(args.label === undefined ? {} : { name: args.label }),
+		run_in_background: args.handle === true,
+	};
+}
+
+function parseStructuredText(text: string): EvalAgentResult {
+	try {
+		const data: unknown = JSON.parse(text);
+		return { text, data };
+	} catch (error) {
+		if (error instanceof SyntaxError) return { text, parseError: error.message };
+		throw error;
+	}
+}
+
+function droppedOptionsWarning(args: AgentArgs): string | undefined {
+	return droppedOptionNames.some((name) => Object.hasOwn(args, name)) ? unsupportedIsolationWarning : undefined;
+}
+
+function toProgressEvent(update: AgentToolResult<unknown>, context: ProgressContext): EvalStatusEvent {
+	const details = isRecord(update.details) ? update.details : undefined;
+	const id = firstString(details, ["task_id", "taskId", "id"]) ?? context.fallbackId;
+	const status = firstString(details, ["status"]) ?? "running";
+	const agent = firstString(details, ["subagent_type", "agent"]);
+	return {
+		op: "agent",
+		id,
+		status,
+		...(agent === undefined ? {} : { agent }),
+		...(context.warning === undefined ? {} : { warning: context.warning }),
+	};
+}
+
+function resultText(result: AgentToolResult<unknown>): string {
+	return result.content
+		.filter((part): part is Extract<(typeof result.content)[number], { type: "text" }> => part.type === "text")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+function resultTaskId(result: AgentToolResult<unknown>, text: string): string | undefined {
+	const details = isRecord(result.details) ? result.details : undefined;
+	const detailId = firstString(details, ["task_id", "taskId", "id"]);
+	if (detailId) return detailId;
+	return text.match(taskIdPattern)?.[0];
+}
+
+function firstString(
+	record: Readonly<Record<string, unknown>> | undefined,
+	keys: readonly string[],
+): string | undefined {
+	if (!record) return undefined;
+	for (const key of keys) {
+		const value = record[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function isUnavailableToolError(error: unknown): boolean {
+	if (!isRecord(error)) return false;
+	return error.code === "unknown_tool" || error.code === "inactive_tool";
+}
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/output-bridge.ts

@@ -0,0 +1,96 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { type Static, Type } from "typebox";
+import { Check, Errors } from "typebox/value";
+import type { ExecuteTool } from "../tool/types.ts";
+
+const outputArgsSchema = Type.Object(
+	{
+		ids: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+		format: Type.Optional(Type.Union([Type.Literal("raw"), Type.Literal("tail")])),
+		offset: Type.Optional(Type.Integer({ minimum: 1 })),
+		limit: Type.Optional(Type.Integer({ minimum: 1 })),
+	},
+	{ additionalProperties: false },
+);
+
+type OutputArgs = Static<typeof outputArgsSchema>;
+
+export type OutputExecuteTool = ExecuteTool & {
+	readonly isToolAvailable?: (name: string) => boolean;
+};
+
+export type MarshalledToolResult = {
+	readonly text: string;
+};
+
+export interface RunEvalOutputOptions {
+	readonly taskOutputToolName: string;
+	readonly executeTool: OutputExecuteTool;
+	readonly signal?: AbortSignal;
+	readonly marshalToolResult: (result: AgentToolResult<unknown>) => MarshalledToolResult;
+}
+
+class OutputArgumentsError extends Error {
+	readonly name = "OutputArgumentsError";
+
+	constructor(summary: string) {
+		super(`output() received invalid arguments: ${summary}`);
+	}
+}
+
+class OutputUnavailableError extends Error {
+	readonly name = "OutputUnavailableError";
+
+	constructor(toolName: string) {
+		super(`output() unavailable: no "${toolName}" tool is registered in this session`);
+	}
+}
+
+export async function runEvalOutput(args: unknown, options: RunEvalOutputOptions): Promise<string | readonly string[]> {
+	const parsed = parseOutputArgs(args);
+	if (options.executeTool.isToolAvailable?.(options.taskOutputToolName) === false) {
+		throw new OutputUnavailableError(options.taskOutputToolName);
+	}
+
+	const mode = parsed.format === "tail" ? "tail" : "full";
+	const transcripts = await Promise.all(
+		parsed.ids.map(async (id) => {
+			let result: AgentToolResult<unknown>;
+			try {
+				result = await options.executeTool(
+					options.taskOutputToolName,
+					{
+						...(id.startsWith("st_") ? { task_id: id } : { name: id }),
+						mode,
+						block: true,
+					},
+					options.signal === undefined ? undefined : { signal: options.signal },
+				);
+			} catch (error) {
+				if (isUnavailableToolError(error)) throw new OutputUnavailableError(options.taskOutputToolName);
+				throw error;
+			}
+
+			// ADAPTATION: task_output owns transcripts, so no AgentOutputManager cache or
+			// oh-my-pi query/json/stripped formats exist on this bridge.
+			const transcript = options.marshalToolResult(result).text;
+			const lines = transcript.split(/\r?\n/u);
+			const start = (parsed.offset ?? 1) - 1;
+			return lines.slice(start, parsed.limit === undefined ? undefined : start + parsed.limit).join("\n");
+		}),
+	);
+	return transcripts.length === 1 ? transcripts[0] : transcripts;
+}
+
+function parseOutputArgs(value: unknown): OutputArgs {
+	if (Check(outputArgsSchema, value)) return value;
+	const summary = Errors(outputArgsSchema, value)
+		.map((error) => `${error.instancePath || "/"} ${error.message}`)
+		.join("; ");
+	throw new OutputArgumentsError(summary || "invalid value");
+}
+
+function isUnavailableToolError(error: unknown): boolean {
+	if (typeof error !== "object" || error === null || Array.isArray(error)) return false;
+	return "code" in error && (error.code === "unknown_tool" || error.code === "inactive_tool");
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/schema-injection.ts

@@ -0,0 +1,3 @@
+export function injectSchemaInstruction(prompt: string, schema: unknown): string {
+	return `${prompt}\n\nRespond ONLY with JSON matching this JSON-Schema:\n${JSON.stringify(schema)}`;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/completion/handler.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { Api, AssistantMessage, Context, Model, SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
+import { injectSchemaInstruction } from "../bridges/schema-injection.ts";
 
 export interface CompletionRequest {
 	readonly prompt: string;
@@ -20,19 +21,27 @@ export type CompleteSimple = (
 	options?: SimpleStreamOptions,
 ) => Promise<AssistantMessage>;
 
-interface CompletionDetails {
+type CompletionDetails = {
 	readonly model: string;
 	readonly structured: boolean;
+};
+
+type CompletionTier = "smol" | "default" | "slow";
+
+class CompletionUnknownTierError extends Error {
+	readonly name = "CompletionUnknownTierError";
+
+	constructor(tier: string) {
+		super(`completion() could not resolve the "${tier}" model tier; expected "smol", "default", or "slow".`);
+	}
 }
 
-interface ResolvedAuth {
-	readonly ok: boolean;
-	readonly apiKey?: string;
-	readonly headers?: Record<string, string>;
-	readonly env?: Record<string, string>;
-	readonly extraBody?: Record<string, unknown>;
-	readonly upstreamModelId?: string;
-	readonly error?: string;
+class CompletionTierUnavailableError extends Error {
+	readonly name = "CompletionTierUnavailableError";
+
+	constructor(tier: Exclude<CompletionTier, "default">) {
+		super(`completion() could not resolve the "${tier}" model tier: no configured models are available.`);
+	}
 }
 
 export function createCompletionHandler(
@@ -46,16 +55,20 @@ async function runCompletion(
 	request: CompletionRequest,
 	complete: CompleteSimple,
 ): Promise<CompletionResult> {
-	const model = resolveRequestedModel(ctx.model, request.model);
-	if (!model) throw noModelCredentialsError();
-	const auth = (await ctx.modelRegistry.getApiKeyAndHeaders(model)) as ResolvedAuth;
-	if (!auth.ok || !auth.apiKey) throw noModelCredentialsError(auth.error);
+	const tier = resolveCompletionTier(request.model);
+	const model = resolveRequestedModel(ctx, tier);
+	if (!model) throw unavailableModelError(tier);
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (!auth.ok) throw noModelCredentialsError(auth.error);
+	if (!auth.apiKey) throw noModelCredentialsError();
 	const requestModel = auth.upstreamModelId ? { ...model, id: auth.upstreamModelId } : model;
+	const structured = request.schema !== undefined;
+	const prompt = structured ? injectSchemaInstruction(request.prompt, request.schema) : request.prompt;
 	const message = await complete(
 		requestModel,
 		{
 			systemPrompt: request.system ?? "You are a helpful assistant.",
-			messages: [{ role: "user", content: [{ type: "text", text: request.prompt }], timestamp: Date.now() }],
+			messages: [{ role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() }],
 		},
 		{
 			apiKey: auth.apiKey,
@@ -65,7 +78,7 @@ async function runCompletion(
 			signal: ctx.signal,
 		},
 	);
-	return formatCompletion(message, model, request.schema !== undefined);
+	return formatCompletion(message, model, structured);
 }
 
 function normalizeRequest(request: CompletionRequest): CompletionRequest {
@@ -78,25 +91,77 @@ function normalizeRequest(request: CompletionRequest): CompletionRequest {
 	};
 }
 
-function resolveRequestedModel(current: Model<Api> | undefined, requested: string | undefined): Model<Api> | undefined {
-	if (requested === undefined || requested === "default") return current;
-	if (requested === "smol" || requested === "slow") {
-		throw new Error('completion() model roles are not supported; use model: "default" or omit model.');
+function resolveCompletionTier(requested: string | undefined): CompletionTier {
+	switch (requested) {
+		case undefined:
+		case "default":
+			return "default";
+		case "smol":
+			return "smol";
+		case "slow":
+			return "slow";
+		default:
+			throw new CompletionUnknownTierError(requested);
+	}
+}
+
+function resolveRequestedModel(ctx: ExtensionContext, tier: CompletionTier): Model<Api> | undefined {
+	switch (tier) {
+		case "default":
+			return ctx.model;
+		case "smol":
+			return lowestCostModel(ctx.modelRegistry.getAvailable());
+		case "slow":
+			return highestCostModel(ctx.modelRegistry.getAvailable());
+		default:
+			return assertNever(tier);
+	}
+}
+
+function unavailableModelError(tier: CompletionTier): Error {
+	switch (tier) {
+		case "default":
+			return noModelCredentialsError();
+		case "smol":
+		case "slow":
+			return new CompletionTierUnavailableError(tier);
+		default:
+			return assertNever(tier);
+	}
+}
+
+function lowestCostModel(models: readonly Model<Api>[]): Model<Api> | undefined {
+	let selected: Model<Api> | undefined;
+	for (const model of models) {
+		if (selected === undefined || promptAndResponseCost(model) < promptAndResponseCost(selected)) selected = model;
 	}
-	if (!current) return undefined;
-	if (requested === current.id || requested === `${current.provider}/${current.id}`) return current;
-	throw new Error(`completion() could not resolve requested model "${requested}" from the current session model.`);
+	return selected;
+}
+
+function highestCostModel(models: readonly Model<Api>[]): Model<Api> | undefined {
+	let selected: Model<Api> | undefined;
+	for (const model of models) {
+		if (selected === undefined || promptAndResponseCost(model) > promptAndResponseCost(selected)) selected = model;
+	}
+	return selected;
+}
+
+function promptAndResponseCost(model: Model<Api>): number {
+	return model.cost.input + model.cost.output;
 }
 
 function formatCompletion(message: AssistantMessage, model: Model<Api>, structured: boolean): CompletionResult {
 	if (message.stopReason === "error") throw new Error(message.errorMessage ?? "completion() request failed.");
 	if (message.stopReason === "aborted") throw new Error("completion() request aborted.");
 	const text = extractText(message);
-	if (!structured) return { text, details: { model: formatModel(model), structured: false } };
+	const details = { model: formatModel(model), structured };
+	if (!structured) return { text, details };
 	try {
-		return { value: JSON.parse(text) as unknown, details: { model: formatModel(model), structured: true } };
-	} catch {
-		throw new Error("completion() did not return a structured JSON response.");
+		const value: unknown = JSON.parse(text);
+		return { value, details };
+	} catch (error) {
+		if (error instanceof SyntaxError) return { value: { parseError: error.message }, details };
+		throw error;
 	}
 }
 
@@ -121,3 +186,7 @@ function formatModel(model: Model<Api>): string {
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
 }
+
+function assertNever(value: never): never {
+	throw new CompletionUnknownTierError(String(value));
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/completion/tool-bridge.ts

@@ -8,17 +8,25 @@ export interface CompletionToolCallOptions {
 	readonly kernel: EvalKernel;
 	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 	readonly ctx: ExtensionContext;
+	readonly isActive: () => boolean;
 }
 
 export type CompletionToolCallSummary = { readonly ok: true } | { readonly ok: false; readonly error: string };
 
 export async function handleCompletionToolCall(options: CompletionToolCallOptions): Promise<CompletionToolCallSummary> {
 	try {
-		const value = await options.complete(toCompletionRequest(options.message.args), options.ctx);
-		options.kernel.deliverToolReply({ type: "tool-reply", callId: options.message.callId, ok: true, value });
+		const result = await options.complete(toCompletionRequest(options.message.args), options.ctx);
+		if (!options.isActive()) return { ok: false, error: "completion() result ignored after eval finalization" };
+		options.kernel.deliverToolReply({
+			type: "tool-reply",
+			callId: options.message.callId,
+			ok: true,
+			value: completionReplyValue(result),
+		});
 		return { ok: true };
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
+		if (!options.isActive()) return { ok: false, error: message };
 		options.kernel.deliverToolReply({
 			type: "tool-reply",
 			callId: options.message.callId,
@@ -41,3 +49,7 @@ function toCompletionRequest(value: unknown): CompletionRequest {
 	}
 	throw new Error("completion() received invalid arguments");
 }
+
+function completionReplyValue(result: CompletionResult): unknown {
+	return "value" in result ? result.value : result.text;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/config/settings.ts

@@ -20,12 +20,41 @@ export const codemodeSettingsSchema = Type.Object(
 		),
 		cellTimeoutSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		parallelPoolWidth: Type.Optional(Type.Number({ minimum: 1 })),
+		taskTools: Type.Optional(
+			Type.Object(
+				{
+					task: Type.Optional(Type.String()),
+					output: Type.Optional(Type.String()),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		outputSink: Type.Optional(
+			Type.Object(
+				{
+					headBytes: Type.Optional(Type.Number({ minimum: 0 })),
+					maxColumns: Type.Optional(Type.Number({ minimum: 0 })),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		statusEvents: Type.Optional(Type.Boolean()),
 	},
 	{ additionalProperties: false },
 );
 
 export type CodemodeSettingsInput = Static<typeof codemodeSettingsSchema>;
 
+export interface CodemodeTaskTools {
+	readonly task: string;
+	readonly output: string;
+}
+
+export interface CodemodeOutputSink {
+	readonly headBytes: number;
+	readonly maxColumns: number;
+}
+
 export interface CodemodeSettings {
 	readonly languages: {
 		readonly py: boolean;
@@ -35,22 +64,31 @@ export interface CodemodeSettings {
 	};
 	readonly cellTimeoutSeconds: number;
 	readonly parallelPoolWidth: number;
+	readonly taskTools?: CodemodeTaskTools;
+	readonly outputSink?: CodemodeOutputSink;
+	readonly statusEvents?: boolean;
 }
 
+export type ResolvedCodemodeSettings = CodemodeSettings & {
+	readonly taskTools: CodemodeTaskTools;
+	readonly outputSink: CodemodeOutputSink;
+	readonly statusEvents: boolean;
+};
+
 export interface LoadCodemodeSettingsOptions {
 	readonly cwd?: string;
 	readonly homeDir?: string;
 }
 
 export interface LoadedCodemodeSettings {
-	readonly settings: CodemodeSettings;
+	readonly settings: ResolvedCodemodeSettings;
 	readonly source: string | null;
 	readonly warnings: readonly string[];
 }
 
 // OMP settings-schema.ts:3211-3299 has language/path settings only; eval.ts:427
 // defaults timeout to 30s, and codemode pins concurrency-bridge.ts:30 width to 4.
-export const defaultCodemodeSettings: CodemodeSettings = {
+export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
 	languages: {
 		py: true,
 		js: true,
@@ -59,8 +97,26 @@ export const defaultCodemodeSettings: CodemodeSettings = {
 	},
 	cellTimeoutSeconds: 30,
 	parallelPoolWidth: 4,
+	taskTools: {
+		task: "task",
+		output: "task_output",
+	},
+	outputSink: {
+		headBytes: 20_480,
+		maxColumns: 768,
+	},
+	statusEvents: true,
 };
 
+const languageEnvironmentFlags = {
+	py: "SENPI_CODEMODE_PY",
+	js: "SENPI_CODEMODE_JS",
+	rb: "SENPI_CODEMODE_RB",
+	jl: "SENPI_CODEMODE_JL",
+} as const;
+
+type Environment = Readonly<Record<string, string | undefined>>;
+
 export async function loadCodemodeSettings(options: LoadCodemodeSettingsOptions = {}): Promise<LoadedCodemodeSettings> {
 	const cwd = options.cwd ?? process.cwd();
 	const homeDir = options.homeDir ?? homedir();
@@ -76,16 +132,29 @@ export async function loadCodemodeSettings(options: LoadCodemodeSettingsOptions
 	return { settings: defaultCodemodeSettings, source: null, warnings: [] };
 }
 
+export function resolveEnabledLanguages(
+	settings: CodemodeSettings,
+	env: Environment = process.env,
+): CodemodeSettings["languages"] {
+	return {
+		py: resolveLanguage(settings.languages.py, env[languageEnvironmentFlags.py]),
+		js: resolveLanguage(settings.languages.js, env[languageEnvironmentFlags.js]),
+		rb: resolveLanguage(settings.languages.rb, env[languageEnvironmentFlags.rb]),
+		jl: resolveLanguage(settings.languages.jl, env[languageEnvironmentFlags.jl]),
+	};
+}
+
 async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
 	const raw = await readFile(path, "utf8");
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(raw);
 	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
 		return {
 			settings: defaultCodemodeSettings,
 			source: path,
-			warnings: [`Invalid JSON in ${path}: ${errorMessage(error)}. Falling back to codemode defaults.`],
+			warnings: [`Invalid JSON in ${path}: ${message}. Falling back to codemode defaults.`],
 		};
 	}
 
@@ -100,7 +169,7 @@ async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
 	return { settings: mergeSettings(parsed), source: path, warnings: [] };
 }
 
-function mergeSettings(input: CodemodeSettingsInput): CodemodeSettings {
+function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
 	return {
 		languages: {
 			py: input.languages?.py ?? defaultCodemodeSettings.languages.py,
@@ -110,9 +179,32 @@ function mergeSettings(input: CodemodeSettingsInput): CodemodeSettings {
 		},
 		cellTimeoutSeconds: input.cellTimeoutSeconds ?? defaultCodemodeSettings.cellTimeoutSeconds,
 		parallelPoolWidth: input.parallelPoolWidth ?? defaultCodemodeSettings.parallelPoolWidth,
+		taskTools: {
+			task: input.taskTools?.task ?? defaultCodemodeSettings.taskTools.task,
+			output: input.taskTools?.output ?? defaultCodemodeSettings.taskTools.output,
+		},
+		outputSink: {
+			headBytes: input.outputSink?.headBytes ?? defaultCodemodeSettings.outputSink.headBytes,
+			maxColumns: input.outputSink?.maxColumns ?? defaultCodemodeSettings.outputSink.maxColumns,
+		},
+		statusEvents: input.statusEvents ?? defaultCodemodeSettings.statusEvents,
 	};
 }
 
+function resolveLanguage(fileSetting: boolean, environmentValue: string | undefined): boolean {
+	if (environmentValue === undefined) return fileSetting;
+	switch (environmentValue.trim().toLowerCase()) {
+		case "0":
+		case "false":
+			return false;
+		case "1":
+		case "true":
+			return true;
+		default:
+			return fileSetting;
+	}
+}
+
 async function fileExists(path: string): Promise<boolean> {
 	try {
 		await access(path);
@@ -121,7 +213,3 @@ async function fileExists(path: string): Promise<boolean> {
 		return false;
 	}
 }
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}