pi-long-task 0.3.7 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "type": "module",
   "description": "Pi extension for breaking down and running long coding tasks safely.",
   "keywords": [

package/src/coordinator.ts

@@ -11,6 +11,7 @@ import type {
 import { commitAfterSession, gitDirtyPaths, shouldCommitOutcome, type CommitAfterSessionResult } from "./git.ts";
 import { formatCoordinatorResultMessage } from "./render.ts";
 import { extractResultSummary } from "./result_writer.ts";
+import { parseWorkerRuntimeConfig } from "./worker_config.ts";
 import { buildTaskProgressModel, type TaskProgressModel, type TaskProgressStatus } from "./task_progress.ts";
 import {
   buildTodoCreationPrompt,
@@ -97,6 +98,8 @@ export interface RunCoordinatorOptions extends PiLongTaskInput {
   todoPlanner?: TodoPlanner;
   workerSessionFactory?: WorkerSessionFactory;
   todoSessionFactory?: WorkerSessionFactory;
+  workerModel?: unknown;
+  workerModelName?: string;
   maxAttemptsPerTask?: number;
   taskTimeoutMs?: number;
   maxBashTimeoutMs?: number;
@@ -111,6 +114,7 @@ export interface TodoPlannerOptions {
   cwd: string;
   runDir: string;
   thinkingLevel: string;
+  model?: unknown;
   abortSignal?: AbortSignal;
   sessionFactory?: WorkerSessionFactory;
 }
@@ -167,6 +171,8 @@ interface RuntimeOptions {
   maxAttemptsPerTask: number;
   taskTimeoutSeconds: number;
   maxBashTimeoutSeconds: number;
+  workerModel?: unknown;
+  workerModelName?: string;
   taskThinking: string;
   todoThinking: string;
   workerRunner: WorkerRunner;
@@ -240,6 +246,8 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
         globalInstructions: todoGlobalInstructions(todoMarkdown),
         maxBashTimeoutSeconds: runtime.maxBashTimeoutSeconds,
         taskTimeoutSeconds: runtime.taskTimeoutSeconds,
+        model: runtime.workerModel,
+        modelName: runtime.workerModelName,
         thinkingLevel: runtime.taskThinking,
         abortSignal: runtime.abortSignal,
         sessionFactory: runtime.workerSessionFactory,
@@ -422,6 +430,7 @@ async function generateOrNormalizeTodoMarkdown(inputText: string, runtime: Runti
     cwd: runtime.cwd,
     runDir: runtime.runDir,
     thinkingLevel: runtime.todoThinking,
+    model: runtime.workerModel,
     abortSignal: runtime.abortSignal,
     sessionFactory: runtime.todoSessionFactory,
   });
@@ -435,6 +444,7 @@ export async function runTodoPlanner(options: TodoPlannerOptions): Promise<strin
     const result = await sessionFactory({
       cwd: options.cwd,
       tools: [],
+      model: options.model,
       thinkingLevel: options.thinkingLevel,
     });
     session = result.session;
@@ -460,6 +470,12 @@ function buildRuntimeOptions(options: RunCoordinatorOptions): RuntimeOptions {
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const runId = sanitizeRunId(options.runId ?? defaultRunId(options.now?.() ?? new Date()));
   const runDir = path.join(cwd, "tmp", "pi-long-task", runId);
+  const parsedWorkerConfig = parseWorkerRuntimeConfig(options.inputText);
+  const configuredAttempts = options.maxAttemptsPerTask ?? parsedWorkerConfig.maxAttemptsPerTask;
+  const configuredTaskTimeoutMs = options.taskTimeoutMs ?? parsedWorkerConfig.taskTimeoutMs;
+  const configuredMaxBashTimeoutMs = options.maxBashTimeoutMs ?? parsedWorkerConfig.maxBashTimeoutMs;
+  const workerModelName = options.workerModelName ?? parsedWorkerConfig.modelName;
+  const workerModel = workerModelName ? undefined : options.workerModel;
 
   return {
     cwd,
@@ -467,10 +483,12 @@ function buildRuntimeOptions(options: RunCoordinatorOptions): RuntimeOptions {
     runDir,
     todoPath: path.join(runDir, "TODO.md"),
     taskResultPath: path.join(runDir, "TASK_RESULT.md"),
-    maxAttemptsPerTask: positiveInteger(options.maxAttemptsPerTask, DEFAULT_COORDINATOR_OPTIONS.maxAttemptsPerTask),
-    taskTimeoutSeconds: positiveMilliseconds(options.taskTimeoutMs, DEFAULT_COORDINATOR_OPTIONS.taskTimeoutMs) / 1000,
+    maxAttemptsPerTask: positiveInteger(configuredAttempts, DEFAULT_COORDINATOR_OPTIONS.maxAttemptsPerTask),
+    taskTimeoutSeconds: positiveMilliseconds(configuredTaskTimeoutMs, DEFAULT_COORDINATOR_OPTIONS.taskTimeoutMs) / 1000,
     maxBashTimeoutSeconds:
-      positiveMilliseconds(options.maxBashTimeoutMs, DEFAULT_COORDINATOR_OPTIONS.maxBashTimeoutMs) / 1000,
+      positiveMilliseconds(configuredMaxBashTimeoutMs, DEFAULT_COORDINATOR_OPTIONS.maxBashTimeoutMs) / 1000,
+    workerModel,
+    workerModelName,
     taskThinking: options.taskThinking ?? DEFAULT_COORDINATOR_OPTIONS.taskThinking,
     todoThinking: options.todoThinking ?? DEFAULT_COORDINATOR_OPTIONS.todoThinking,
     workerRunner: options.workerRunner ?? runWorkerTask,

package/src/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
-import { truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, type Component, type OverlayHandle, type TUI } from "@earendil-works/pi-tui";
 
 import { runCoordinator, type CoordinatorProgressUpdate, type CoordinatorResult } from "./coordinator.ts";
 import { longTaskInputTransform } from "./input_router.ts";
@@ -118,20 +118,24 @@ export function createLongTaskSidebarController(ctx: UiContext | undefined): Lon
   }
 
   let latestUpdate: CoordinatorProgressUpdate | undefined;
-  let sidebarComponent: PiLongTaskSidebarComponent | undefined;
-  let sidebarTui: TUI | undefined;
+  let widgetComponent: PiLongTaskSidebarComponent | undefined;
+  let widgetTui: TUI | undefined;
+  let overlayComponent: PiLongTaskSidebarComponent | undefined;
+  let overlayTui: TUI | undefined;
+  let overlayDone: ((result: undefined) => void) | undefined;
+  let overlayHandle: OverlayHandle | undefined;
   let closed = false;
 
   if (supportsTuiWidget(ctx)) {
     ctx.ui.setWidget(
       LONG_TASK_WIDGET_KEY,
       (tui, theme) => {
-        sidebarTui = tui;
-        sidebarComponent = new PiLongTaskSidebarComponent(theme, () => sidebarWidgetLineLimit(tui));
+        widgetTui = tui;
+        widgetComponent = new PiLongTaskSidebarComponent(theme, () => sidebarWidgetLineLimit(tui));
         if (latestUpdate) {
-          sidebarComponent.setUpdate(latestUpdate);
+          widgetComponent.setUpdate(latestUpdate);
         }
-        return sidebarComponent;
+        return widgetComponent;
       },
       { placement: "aboveEditor" },
     );
@@ -139,15 +143,59 @@ export function createLongTaskSidebarController(ctx: UiContext | undefined): Lon
     ctx.ui.setWidget(LONG_TASK_WIDGET_KEY, ["Pi Long Task: preparing sidebar..."], { placement: "aboveEditor" });
   }
 
+  if (supportsTuiOverlay(ctx)) {
+    try {
+      const overlayPromise = ctx.ui.custom<undefined>(
+        (tui, theme, _keybindings, done) => {
+          overlayTui = tui;
+          overlayDone = done;
+          overlayComponent = new PiLongTaskSidebarComponent(theme);
+          if (latestUpdate) {
+            overlayComponent.setUpdate(latestUpdate);
+          }
+          if (closed) {
+            done(undefined);
+          }
+          return overlayComponent;
+        },
+        {
+          overlay: true,
+          overlayOptions: {
+            anchor: "right-center",
+            width: "34%",
+            minWidth: 32,
+            maxHeight: "85%",
+            margin: 1,
+            nonCapturing: true,
+            visible: (termWidth, termHeight) => termWidth >= 96 && termHeight >= 16,
+          },
+          onHandle: (handle) => {
+            overlayHandle = handle;
+            handle.unfocus();
+          },
+        },
+      );
+      void overlayPromise.catch(() => {
+        // The widget fallback remains active if overlay registration is unavailable.
+      });
+    } catch {
+      // The widget fallback remains active if overlay registration is unavailable.
+    }
+  }
+
   return {
     update(update: CoordinatorProgressUpdate): void {
       if (closed) {
         return;
       }
       latestUpdate = update;
-      sidebarComponent?.setUpdate(update);
-      sidebarTui?.requestRender();
-      if (!sidebarComponent) {
+      widgetComponent?.setUpdate(update);
+      overlayComponent?.setUpdate(update);
+      widgetTui?.requestRender();
+      if (overlayTui && overlayTui !== widgetTui) {
+        overlayTui.requestRender();
+      }
+      if (!widgetComponent) {
         ctx.ui.setWidget(LONG_TASK_WIDGET_KEY, renderSidebarWidgetLines(update), { placement: "aboveEditor" });
       }
     },
@@ -157,8 +205,17 @@ export function createLongTaskSidebarController(ctx: UiContext | undefined): Lon
       }
       closed = true;
       ctx.ui.setWidget(LONG_TASK_WIDGET_KEY, undefined);
-      sidebarComponent = undefined;
-      sidebarTui = undefined;
+      if (overlayHandle) {
+        overlayHandle.hide();
+      } else {
+        overlayDone?.(undefined);
+      }
+      widgetComponent = undefined;
+      widgetTui = undefined;
+      overlayComponent = undefined;
+      overlayTui = undefined;
+      overlayDone = undefined;
+      overlayHandle = undefined;
     },
   };
 }
@@ -168,6 +225,11 @@ function supportsTuiWidget(ctx: UiContext): boolean {
   return mode === "tui" || mode === undefined;
 }
 
+function supportsTuiOverlay(ctx: UiContext): boolean {
+  const mode = (ctx as UiContext & { mode?: string }).mode;
+  return mode === "tui" || mode === undefined;
+}
+
 function sidebarWidgetLineLimit(tui: TUI): number {
   const terminalRows = tui.terminal.rows;
   const rows = Number.isFinite(terminalRows) ? Math.max(0, Math.floor(terminalRows)) : 24;
@@ -679,6 +741,7 @@ export default function registerPiLongTaskExtension(pi: ExtensionAPI) {
         const result = await runCoordinator({
           ...params,
           cwd: ctx?.cwd,
+          workerModel: ctx?.model,
           abortSignal: signal,
           onProgress: publishProgress,
         });

package/src/worker_config.ts

@@ -0,0 +1,291 @@
+export interface ParsedWorkerRuntimeConfig {
+  modelName?: string;
+  maxAttemptsPerTask?: number;
+  taskTimeoutMs?: number;
+  maxBashTimeoutMs?: number;
+}
+
+const MODEL_TOKEN_RE = /[A-Za-z0-9][A-Za-z0-9._~:+/@-]*/;
+const STOP_WORDS = new Set([
+  "and",
+  "as",
+  "for",
+  "from",
+  "in",
+  "is",
+  "of",
+  "on",
+  "per",
+  "please",
+  "task",
+  "tasks",
+  "the",
+  "to",
+  "use",
+  "with",
+  "worker",
+  "workers",
+]);
+
+export function parseWorkerRuntimeConfig(text: string): ParsedWorkerRuntimeConfig {
+  const state: ParsedWorkerRuntimeConfig & { provider?: string; model?: string } = {};
+
+  parseLineDirectives(text, state);
+  parseNaturalLanguageDirectives(text, state);
+
+  const modelName = combineProviderAndModel(state.provider, state.model);
+  return {
+    ...(modelName ? { modelName } : {}),
+    ...(state.maxAttemptsPerTask !== undefined ? { maxAttemptsPerTask: state.maxAttemptsPerTask } : {}),
+    ...(state.taskTimeoutMs !== undefined ? { taskTimeoutMs: state.taskTimeoutMs } : {}),
+    ...(state.maxBashTimeoutMs !== undefined ? { maxBashTimeoutMs: state.maxBashTimeoutMs } : {}),
+  };
+}
+
+function parseLineDirectives(
+  text: string,
+  state: ParsedWorkerRuntimeConfig & { provider?: string; model?: string },
+): void {
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.replace(/^\s{0,3}>+\s?/, "").trim();
+    const match = line.match(
+      /^(?:[-*+]\s*)?(?:(pi\s+long\s+task|long\s+task|worker|workers?|task)\s+)?([a-z][a-z\s-]{0,40})\s*(?::|=)\s*(.+)$/i,
+    );
+    if (!match) {
+      continue;
+    }
+
+    const prefix = normalizeWords(match[1] ?? "");
+    const key = normalizeWords(match[2] ?? "");
+    const fullKey = normalizeWords(`${prefix} ${key}`);
+    const value = match[3] ?? "";
+
+    applyDirective(fullKey, value, state);
+  }
+}
+
+function parseNaturalLanguageDirectives(
+  text: string,
+  state: ParsedWorkerRuntimeConfig & { provider?: string; model?: string },
+): void {
+  captureTokens(
+    text,
+    /\bworker\s+(?:model|provider\/model)\s*(?:is|=|:|to|as)?\s*[`'"]?([A-Za-z0-9][A-Za-z0-9._~:+/@-]*)/gi,
+    (token) => {
+      state.model = token;
+    },
+  );
+  captureTokens(
+    text,
+    /\b(?:use|using|with|set|run(?:ning)?)\s+(?:the\s+)?(?:worker\s+)?model\s*(?:to|as|is|=|:)?\s*[`'"]?([A-Za-z0-9][A-Za-z0-9._~:+/@-]*)/gi,
+    (token) => {
+      state.model = token;
+    },
+  );
+  captureTokens(text, /\bmodel\s*(?:=|:)\s*[`'"]?([A-Za-z0-9][A-Za-z0-9._~:+/@-]*)/gi, (token) => {
+    state.model = token;
+  });
+
+  captureTokens(
+    text,
+    /\bworker\s+provider\s*(?:is|=|:|to|as)?\s*[`'"]?([A-Za-z0-9][A-Za-z0-9._~:+/@-]*)/gi,
+    (token) => {
+      state.provider = token;
+    },
+  );
+  captureTokens(text, /\bprovider\s*(?:=|:)\s*[`'"]?([A-Za-z0-9][A-Za-z0-9._~:+/@-]*)/gi, (token) => {
+    state.provider = token;
+  });
+  captureTokens(
+    text,
+    /\b(?:use|using|with|set)\s+(?:the\s+)?(?:worker\s+)?provider\s*(?:to|as|is|=|:)?\s*[`'"]?([A-Za-z0-9][A-Za-z0-9._~:+/@-]*)/gi,
+    (token) => {
+      state.provider = token;
+    },
+  );
+
+  captureNumbers(
+    text,
+    /\b(?:max(?:imum)?\s+)?(?:worker\s+|task\s+)?attempts?\s*(?:per\s+task)?\s*(?:is|=|:|to|at)?\s*(\d+)/gi,
+    (value) => {
+      state.maxAttemptsPerTask = value;
+    },
+  );
+  captureNumbers(text, /\b(\d+)\s+(?:worker\s+|task\s+)?attempts?\b/gi, (value) => {
+    state.maxAttemptsPerTask = value;
+  });
+  captureNumbers(text, /\btry\s+(?:each\s+task\s+)?(?:up\s+to\s+)?(\d+)\s+times\b/gi, (value) => {
+    state.maxAttemptsPerTask = value;
+  });
+
+  captureDurations(
+    text,
+    /\b(?<!bash\s)(?<!max\s)(?:worker\s+|task\s+)?timeout\s*(?:is|=|:|to|of)?\s*(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?)/gi,
+    (value) => {
+      state.taskTimeoutMs = value;
+    },
+  );
+  captureDurations(
+    text,
+    /\b(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h))\s+(?:worker\s+|task\s+)?timeout\b/gi,
+    (value) => {
+      state.taskTimeoutMs = value;
+    },
+  );
+  captureDurations(
+    text,
+    /\b(?:max\s+)?bash\s+timeout\s*(?:is|=|:|to|of)?\s*(\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?)/gi,
+    (value) => {
+      state.maxBashTimeoutMs = value;
+    },
+  );
+}
+
+function applyDirective(
+  key: string,
+  value: string,
+  state: ParsedWorkerRuntimeConfig & { provider?: string; model?: string },
+): void {
+  if (/\bprovider\b/.test(key)) {
+    const token = modelToken(value);
+    if (token) {
+      state.provider = token;
+    }
+    return;
+  }
+
+  if (/\bmodel\b/.test(key)) {
+    const token = modelToken(value);
+    if (token) {
+      state.model = token;
+    }
+    return;
+  }
+
+  if (/\b(?:attempt|attempts|retry|retries)\b/.test(key)) {
+    const attempts = positiveIntegerFromText(value);
+    if (attempts !== undefined) {
+      state.maxAttemptsPerTask = attempts;
+    }
+    return;
+  }
+
+  if (/\bbash\b/.test(key) && /\btimeout\b/.test(key)) {
+    const timeout = durationMsFromText(value, { allowBareSeconds: true });
+    if (timeout !== undefined) {
+      state.maxBashTimeoutMs = timeout;
+    }
+    return;
+  }
+
+  if (/\btimeout\b/.test(key)) {
+    const timeout = durationMsFromText(value, { allowBareSeconds: true });
+    if (timeout !== undefined) {
+      state.taskTimeoutMs = timeout;
+    }
+  }
+}
+
+function captureTokens(text: string, pattern: RegExp, apply: (token: string) => void): void {
+  for (const match of text.matchAll(pattern)) {
+    const token = modelToken(match[1] ?? "");
+    if (token) {
+      apply(token);
+    }
+  }
+}
+
+function captureNumbers(text: string, pattern: RegExp, apply: (value: number) => void): void {
+  for (const match of text.matchAll(pattern)) {
+    const value = positiveIntegerFromText(match[1] ?? "");
+    if (value !== undefined) {
+      apply(value);
+    }
+  }
+}
+
+function captureDurations(text: string, pattern: RegExp, apply: (value: number) => void): void {
+  for (const match of text.matchAll(pattern)) {
+    const value = durationMsFromText(match[1] ?? "", { allowBareSeconds: true });
+    if (value !== undefined) {
+      apply(value);
+    }
+  }
+}
+
+function combineProviderAndModel(provider: string | undefined, model: string | undefined): string | undefined {
+  if (!model) {
+    return undefined;
+  }
+  if (model.includes("/") || !provider) {
+    return model;
+  }
+  return `${provider}/${model}`;
+}
+
+function modelToken(value: string): string | undefined {
+  const trimmed = trimDirectiveValue(value);
+  const match = MODEL_TOKEN_RE.exec(trimmed);
+  if (!match) {
+    return undefined;
+  }
+  const token = match[0].replace(/[.,;:]+$/g, "");
+  return token && !STOP_WORDS.has(token.toLowerCase()) ? token : undefined;
+}
+
+function trimDirectiveValue(value: string): string {
+  return value
+    .trim()
+    .replace(/^['"`]+/, "")
+    .replace(/['"`]+$/, "")
+    .trim();
+}
+
+function positiveIntegerFromText(value: string): number | undefined {
+  const match = /\d+/.exec(value);
+  if (!match) {
+    return undefined;
+  }
+  const parsed = Number.parseInt(match[0], 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function durationMsFromText(value: string, options: { allowBareSeconds: boolean }): number | undefined {
+  const match = /(\d+(?:\.\d+)?)\s*(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h)?\b/i.exec(
+    value,
+  );
+  if (!match) {
+    return undefined;
+  }
+
+  const amount = Number.parseFloat(match[1] ?? "");
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return undefined;
+  }
+
+  const unit = (match[2] ?? "").toLowerCase();
+  if (!unit && !options.allowBareSeconds) {
+    return undefined;
+  }
+
+  const multiplier = durationMultiplier(unit || "seconds");
+  const milliseconds = Math.round(amount * multiplier);
+  return Number.isSafeInteger(milliseconds) && milliseconds > 0 ? milliseconds : undefined;
+}
+
+function durationMultiplier(unit: string): number {
+  if (unit === "ms" || unit.startsWith("millisecond") || unit.startsWith("msec")) {
+    return 1;
+  }
+  if (unit === "h" || unit.startsWith("hour") || unit.startsWith("hr")) {
+    return 60 * 60 * 1000;
+  }
+  if (unit === "m" || unit.startsWith("minute") || unit.startsWith("min")) {
+    return 60 * 1000;
+  }
+  return 1000;
+}
+
+function normalizeWords(value: string): string {
+  return value.toLowerCase().replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim();
+}

package/src/worker_session.ts

@@ -186,7 +186,6 @@ export const extractAssistantTextFromEvent = assistantTextFromEvent;
 export const extractLastAssistantTextFromEvents = lastAssistantTextFromEvents;
 
 export const DEFAULT_WORKER_TOOLS = ["read", "bash", "edit", "write", "grep", "find", "ls"] as const;
-export const DEFAULT_WORKER_MODEL = "openai-codex/gpt-5.5";
 export const DEFAULT_WORKER_THINKING_LEVEL = "high";
 export const DEFAULT_TASK_TIMEOUT_SECONDS = 60 * 60;
 export const DEFAULT_GRACEFUL_SHUTDOWN_SECONDS = 60;
@@ -309,7 +308,8 @@ export async function createIsolatedWorkerSession(
   const resourceLoader = disableExtensionsForWorker(discoveredResourceLoader, () => pi.createExtensionRuntime());
   await resourceLoader.reload();
 
-  const model = options.model ?? (await resolveWorkerModel(modelRegistry, options.modelName ?? DEFAULT_WORKER_MODEL));
+  const model =
+    options.model ?? (options.modelName ? await resolveWorkerModel(modelRegistry, options.modelName) : undefined);
   const createOptions: Record<string, unknown> = {
     cwd,
     agentDir,