praxis-agent 0.59.1 → 0.60.1

package/README.md

@@ -102,6 +102,7 @@ Common non-interactive operations:
 
 ```sh
 praxis -p "Inspect this project"
+printf 'Inspect this project\n' | praxis -p
 praxis -p --output-format json "Summarize the test failures"
 praxis --resume
 praxis sessions --json
@@ -126,8 +127,11 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   composer grammar, compact stable tool rows, responsive density,
   terminal-native background, and a minimal composer/status row. Successful
   background Bash completion bursts collapse in normal reading, while
-  failed/stopped notifications remain detailed. Interactive
-  surfaces share the same presentation across terminals, with English
+  failed/stopped notifications remain detailed.
+  Prompt-like background Bash output that remains unchanged for 50 seconds
+  raises one warning and model follow-up without stopping or reclassifying the
+  running task; silent and ordinary output remain quiet.
+  Interactive surfaces share the same presentation across terminals, with English
   permission/configuration choices and a taught `❯` / Up/Down / Enter / Esc
   interaction grammar. While a regular turn is active, the composer remains
   editable: Enter steers at the next safe continuation boundary, Tab or
@@ -210,7 +214,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   Claude-compatible main-thread agent definitions with native prompt, model,
   tool, memory, first-turn, and resume behavior. Agent execution uses one
   durable lifecycle vocabulary with bounded cancellation and drain,
-  continuation, notifications, and single-owner orphan recovery. Experimental
+  continuation, notifications, and single-owner orphan recovery. Isolated
+  Workflow turns use ownership-recorded repo-local temporary worktrees and
+  retain dirty or committed results for inspection. Experimental
   local Teams (`PRAXIS_ENABLE_TEAMS=true`) stay absent from ordinary startup by
   default and add durable task ownership plus one ordered mailbox with stable
   identities, fixed broadcast recipients, durable cursors, bounded retention,

package/dist/application/background-bash-manager.d.ts

@@ -18,6 +18,7 @@ export interface BackgroundBashManagerOptions {
     stateRoot: string;
     maxOutputBytes?: number;
     eventSink?: RuntimeEventSink;
+    stallWatchdogMs?: number;
 }
 export interface BackgroundBashLaunchInput {
     command: string;
@@ -40,6 +41,7 @@ export declare class BackgroundBashManager {
     private readonly runner;
     private readonly outputRoot;
     private readonly sessionStateRoot;
+    private readonly stallWatchdogMs;
     constructor(options: BackgroundBashManagerOptions);
     has(taskId: string): boolean;
     snapshots(): Promise<readonly BackgroundBashSnapshot[]>;
@@ -56,6 +58,8 @@ export declare class BackgroundBashManager {
     stop(taskId: string): Promise<BackgroundBashToolResult>;
     notifications(waitForRunning: boolean): Promise<string[]>;
     private run;
+    private clearWatchdog;
+    private rearmWatchdog;
     private emitNotification;
     private complete;
     private outputResult;

package/dist/application/background-bash-manager.js

@@ -53,14 +53,48 @@ function escapeXml(value) {
         .replaceAll('"', '"')
         .replaceAll("'", ''');
 }
+function isPromptTail(output) {
+    const tail = output
+        .slice(-1024)
+        .replace(new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, 'gu'), '');
+    const lines = tail.split(/\r?\n/u);
+    const line = [...lines].reverse().find((item) => item.trim() !== '');
+    if (!line)
+        return false;
+    const value = line.trim().replace(/[\t ]+$/u, '');
+    if (/\?\s*(?:\[[^\]]{1,20}\]|\([^)]{1,20}\))$/u.test(value))
+        return true;
+    if (/^(?:password|passphrase|username)\s*:\s*$/iu.test(value) ||
+        /^(?:enter|input|select|selection|choice|confirm)\b[^\n:]{0,100}:\s*$/iu.test(value))
+        return true;
+    return /^(?:press|hit)\s+(?:enter|return|any key)(?:\s+to\b[^\n]*)?[.!?:…]?$/iu.test(value);
+}
+function watchdogNotification(task, summary) {
+    return `<task-notification>\n<task-id>${escapeXml(task.taskId)}</task-id>\n<tool-use-id>${escapeXml(task.toolUseId)}</tool-use-id>\n<output-file>${escapeXml(task.outputFile)}</output-file>\n<summary>${escapeXml(summary)}</summary>\n</task-notification>\nLast output:\n${task.output}\n\nThe command is likely blocked on an interactive prompt. Stop this task and re-run with piped input (e.g., \`echo y | command\`) or a non-interactive flag if one exists.`;
+}
+function createWatchdogWake() {
+    let resolveWake;
+    const promise = new Promise((resolve) => {
+        resolveWake = resolve;
+    });
+    return { promise, resolve: resolveWake };
+}
 export class BackgroundBashManager {
     options;
     tasks = new Map();
     runner;
     outputRoot;
     sessionStateRoot;
+    stallWatchdogMs;
     constructor(options) {
         this.options = options;
+        if (options.stallWatchdogMs !== undefined &&
+            (!Number.isFinite(options.stallWatchdogMs) ||
+                !Number.isInteger(options.stallWatchdogMs) ||
+                options.stallWatchdogMs <= 0)) {
+            throw new RangeError('stallWatchdogMs must be a positive integer');
+        }
+        this.stallWatchdogMs = options.stallWatchdogMs ?? 50_000;
         this.runner = new BoundedProcessRunner({
             cwd: options.cwd,
             maxOutputBytes: options.maxOutputBytes ?? 128 * 1024,
@@ -88,6 +122,7 @@ export class BackgroundBashManager {
         const outputFile = resolve(this.outputRoot, `${id}.output`);
         await writeFile(outputFile, '', { mode: 0o600 });
         const controller = new AbortController();
+        const watchdogWake = createWatchdogWake();
         const task = {
             taskId: id,
             command: input.command,
@@ -108,6 +143,11 @@ export class BackgroundBashManager {
                     parentAbort: () => controller.abort(),
                 }
                 : {}),
+            watchdogTimer: null,
+            watchdogFired: false,
+            pendingWatchdogMessage: null,
+            watchdogWake: watchdogWake.promise,
+            watchdogWakeResolve: watchdogWake.resolve,
         };
         if (task.parentSignal && task.parentAbort) {
             if (task.parentSignal.aborted)
@@ -192,12 +232,25 @@ export class BackgroundBashManager {
     async notifications(waitForRunning) {
         await this.hydratePersistedTasks();
         if (waitForRunning) {
-            await Promise.all([...this.tasks.values()]
-                .filter(({ status }) => status === 'running')
-                .map(({ completion }) => completion));
+            const hasPendingWatchdog = [...this.tasks.values()].some(({ pendingWatchdogMessage }) => pendingWatchdogMessage !== null);
+            const running = [...this.tasks.values()].filter(({ status }) => status === 'running');
+            const completions = Promise.all(running.map(({ completion }) => completion));
+            const wakes = running
+                .filter((task) => !task.watchdogFired)
+                .map(({ watchdogWake }) => watchdogWake);
+            if (!hasPendingWatchdog && wakes.length > 0)
+                await Promise.race([completions, ...wakes]);
+            else if (!hasPendingWatchdog)
+                await completions;
         }
         const messages = [];
         for (const task of this.tasks.values()) {
+            if (task.pendingWatchdogMessage) {
+                const pendingWatchdogMessage = task.pendingWatchdogMessage;
+                task.pendingWatchdogMessage = null;
+                if (!task.notified && task.status !== 'stopped')
+                    messages.push(pendingWatchdogMessage);
+            }
             if (task.status === 'running' ||
                 task.status === 'stopped' ||
                 task.notified) {
@@ -219,6 +272,7 @@ export class BackgroundBashManager {
                 signal: task.controller.signal,
                 onOutput: async (output) => {
                     task.output = output;
+                    this.rearmWatchdog(task);
                     await writeFile(task.outputFile, output, { mode: 0o600 });
                 },
             });
@@ -244,12 +298,45 @@ export class BackgroundBashManager {
             });
         }
         finally {
+            this.clearWatchdog(task);
             this.emitNotification(task);
             if (task.parentSignal && task.parentAbort) {
                 task.parentSignal.removeEventListener('abort', task.parentAbort);
             }
         }
     }
+    clearWatchdog(task) {
+        if (task.watchdogTimer !== null) {
+            clearTimeout(task.watchdogTimer);
+            task.watchdogTimer = null;
+        }
+    }
+    rearmWatchdog(task) {
+        this.clearWatchdog(task);
+        if (task.status !== 'running' ||
+            task.watchdogFired ||
+            !isPromptTail(task.output))
+            return;
+        task.watchdogTimer = setTimeout(() => {
+            task.watchdogTimer = null;
+            if (task.status !== 'running' ||
+                task.watchdogFired ||
+                !isPromptTail(task.output))
+                return;
+            task.watchdogFired = true;
+            const summary = `Background command "${task.description}" appears to be waiting for interactive input`;
+            task.pendingWatchdogMessage = watchdogNotification(task, summary);
+            this.options.eventSink?.({
+                type: 'task-input-waiting',
+                taskId: task.taskId,
+                toolUseId: task.toolUseId,
+                outputFile: task.outputFile,
+                summary,
+            });
+            task.watchdogWakeResolve?.();
+            task.watchdogWakeResolve = null;
+        }, this.stallWatchdogMs);
+    }
     emitNotification(task) {
         if (task.status === 'running')
             return;
@@ -330,6 +417,11 @@ export class BackgroundBashManager {
                 completion: Promise.resolve(),
                 startedAt: state.startedAt ?? Math.floor(metadata.mtimeMs),
                 durationMs: state.durationMs ?? null,
+                watchdogTimer: null,
+                watchdogFired: false,
+                pendingWatchdogMessage: null,
+                watchdogWake: createWatchdogWake().promise,
+                watchdogWakeResolve: null,
             };
             this.tasks.set(taskId, task);
             return task;

package/dist/application/managed-worktree.d.ts

@@ -6,6 +6,16 @@ export interface ManagedWorktree {
     cwd: string;
     cleanup(): Promise<ManagedWorktreeCleanup>;
 }
+export interface OwnedManagedWorktreeOptions {
+    cwd: string;
+    stateRoot: string;
+    directoryName: string;
+    ownerId: string;
+    label: 'Agent' | 'Workflow' | 'Team';
+    kind: 'workflow' | 'agent' | 'team';
+    policy: 'ephemeral' | 'durable';
+}
+export declare function createOwnedManagedWorktree(options: OwnedManagedWorktreeOptions): Promise<ManagedWorktree>;
 export declare function createManagedWorktree(options: {
     cwd: string;
     parentDirectory: string;