pty-manager 1.6.2 → 1.6.4

package/dist/index.mjs

@@ -310,6 +310,8 @@ var PTYSession = class _PTYSession extends EventEmitter {
   _stallBackoffMs = 0;
   // Initialized in constructor from _stallTimeoutMs
   static MAX_STALL_BACKOFF_MS = 3e4;
+  _stallEmissionCount = 0;
+  static MAX_STALL_EMISSIONS = 5;
   // Task completion detection (idle detection when busy)
   _taskCompleteTimer = null;
   _taskCompletePending = false;
@@ -427,6 +429,7 @@ var PTYSession = class _PTYSession extends EventEmitter {
       return;
     }
     this._lastContentHash = hash;
+    this._stallEmissionCount = 0;
     if (this._stallTimer) {
       clearTimeout(this._stallTimer);
       this._stallTimer = null;
@@ -449,6 +452,7 @@ var PTYSession = class _PTYSession extends EventEmitter {
     this._stallStartedAt = null;
     this._lastContentHash = null;
     this._stallBackoffMs = this._stallTimeoutMs;
+    this._stallEmissionCount = 0;
   }
   /**
    * Called when the stall timer fires (no output for stallTimeoutMs).
@@ -485,6 +489,15 @@ var PTYSession = class _PTYSession extends EventEmitter {
       );
       return;
     }
+    this._stallEmissionCount++;
+    if (this._stallEmissionCount > _PTYSession.MAX_STALL_EMISSIONS) {
+      this.logger.warn(
+        { sessionId: this.id, count: this._stallEmissionCount },
+        "Max stall emissions reached \u2014 suspending stall detection for this task"
+      );
+      this.clearStallTimer();
+      return;
+    }
     const recentRaw = this.outputBuffer.slice(-2e3);
     const recentOutput = this.stripAnsiForStall(recentRaw);
     const stallDurationMs = this._stallStartedAt ? Date.now() - this._stallStartedAt : this._stallTimeoutMs;
@@ -524,6 +537,8 @@ var PTYSession = class _PTYSession extends EventEmitter {
     let result = str.replace(/\x1b\[\d*[CDABGdEF]/g, " ");
     result = result.replace(/\x1b\[\d*(?:;\d+)?[Hf]/g, " ");
     result = result.replace(/\x1b\[\d*[JK]/g, " ");
+    result = result.replace(/\x1b\](?:[^\x07\x1b]|\x1b[^\\])*(?:\x07|\x1b\\)/g, "");
+    result = result.replace(/\x1bP(?:[^\x1b]|\x1b[^\\])*\x1b\\/g, "");
     result = result.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
     result = result.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
     result = result.replace(/\xa0/g, " ");
@@ -607,10 +622,15 @@ var PTYSession = class _PTYSession extends EventEmitter {
    * being a no-op when already scheduled. This allows TUI agents that
    * continue rendering decorative output (status bar, update notices) after
    * the prompt to eventually settle, rather than having the timer cancelled
-   * by every new data chunk. The callback re-verifies detectReady() before
-   * transitioning, so stale triggers are safe.
+   * by every new data chunk. The callback re-verifies the task-complete
+   * signal before transitioning, so stale triggers are safe.
    */
   scheduleTaskComplete() {
+    const wasPending = this._taskCompletePending;
+    this.traceTaskCompletion("debounce_schedule", {
+      wasPending,
+      debounceMs: _PTYSession.TASK_COMPLETE_DEBOUNCE_MS
+    });
     if (this._taskCompleteTimer) {
       clearTimeout(this._taskCompleteTimer);
     }
@@ -618,17 +638,72 @@ var PTYSession = class _PTYSession extends EventEmitter {
     this._taskCompleteTimer = setTimeout(() => {
       this._taskCompleteTimer = null;
       this._taskCompletePending = false;
-      if (this._status !== "busy") return;
-      if (!this.adapter.detectReady(this.outputBuffer)) return;
+      const signal = this.isTaskCompleteSignal(this.outputBuffer);
+      this.traceTaskCompletion("debounce_fire", { signal });
+      if (this._status !== "busy") {
+        this.traceTaskCompletion("debounce_reject_status", { signal });
+        return;
+      }
+      if (!signal) {
+        this.traceTaskCompletion("debounce_reject_signal", { signal });
+        return;
+      }
       this._status = "ready";
       this._lastBlockingPromptHash = null;
       this.outputBuffer = "";
       this.clearStallTimer();
       this.emit("status_changed", "ready");
       this.emit("task_complete");
+      this.traceTaskCompletion("transition_ready", { signal: true });
       this.logger.info({ sessionId: this.id }, "Task complete \u2014 agent returned to idle prompt");
     }, _PTYSession.TASK_COMPLETE_DEBOUNCE_MS);
   }
+  /**
+   * Adapter-level task completion check with compatibility fallback.
+   * Prefer detectTaskComplete() because detectReady() may be broad for TUIs.
+   */
+  isTaskCompleteSignal(output) {
+    if (this.adapter.detectTaskComplete) {
+      return this.adapter.detectTaskComplete(output);
+    }
+    return this.adapter.detectReady(output);
+  }
+  /**
+   * Claude-oriented task completion traces for PTY debugging.
+   * Enabled by config.traceTaskCompletion, otherwise defaults to enabled for Claude.
+   */
+  traceTaskCompletion(event, ctx = {}) {
+    if (!this.shouldTraceTaskCompletion()) return;
+    const output = this.outputBuffer;
+    const detectTaskComplete = this.adapter.detectTaskComplete ? this.adapter.detectTaskComplete(output) : void 0;
+    const detectReady = this.adapter.detectReady(output);
+    const detectLoading = this.adapter.detectLoading ? this.adapter.detectLoading(output) : void 0;
+    const normalizedTail = this.stripAnsiForStall(output.slice(-280));
+    this.logger.debug(
+      {
+        sessionId: this.id,
+        adapterType: this.adapter.adapterType,
+        event,
+        status: this._status,
+        taskCompletePending: this._taskCompletePending,
+        signal: ctx.signal,
+        wasPending: ctx.wasPending,
+        debounceMs: ctx.debounceMs,
+        detectTaskComplete,
+        detectReady,
+        detectLoading,
+        tailHash: this.simpleHash(normalizedTail),
+        tailSnippet: normalizedTail.slice(-140)
+      },
+      "Task completion trace"
+    );
+  }
+  shouldTraceTaskCompletion() {
+    if (typeof this.config.traceTaskCompletion === "boolean") {
+      return this.config.traceTaskCompletion;
+    }
+    return this.adapter.adapterType === "claude";
+  }
   /**
    * Cancel a pending task_complete timer (new output arrived that
    * doesn't match the idle prompt, so the agent is still working).
@@ -781,7 +856,9 @@ var PTYSession = class _PTYSession extends EventEmitter {
       return;
     }
     if (this._status === "busy") {
-      if (this._taskCompletePending || this.adapter.detectReady(this.outputBuffer)) {
+      const signal = this.isTaskCompleteSignal(this.outputBuffer);
+      if (this._taskCompletePending || signal) {
+        this.traceTaskCompletion("busy_signal", { signal });
         this.scheduleTaskComplete();
       }
     }
@@ -1532,6 +1609,171 @@ var PTYManager = class extends EventEmitter2 {
   }
 };
 
+// src/task-completion-trace.ts
+function extractTaskCompletionTraceRecords(entries) {
+  const out = [];
+  for (const entry of entries) {
+    let obj = null;
+    if (typeof entry === "string") {
+      const line = entry.trim();
+      if (!line.startsWith("{") || !line.endsWith("}")) continue;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        continue;
+      }
+    } else if (entry && typeof entry === "object") {
+      obj = entry;
+    }
+    if (!obj) continue;
+    if (obj.msg !== "Task completion trace") continue;
+    if (typeof obj.event !== "string") continue;
+    out.push({
+      sessionId: asString(obj.sessionId),
+      adapterType: asString(obj.adapterType),
+      event: obj.event,
+      status: asString(obj.status),
+      taskCompletePending: asBool(obj.taskCompletePending),
+      signal: asBool(obj.signal),
+      wasPending: asBool(obj.wasPending),
+      debounceMs: asNumber(obj.debounceMs),
+      detectTaskComplete: asBool(obj.detectTaskComplete),
+      detectReady: asBool(obj.detectReady),
+      detectLoading: asBool(obj.detectLoading),
+      tailHash: asString(obj.tailHash),
+      tailSnippet: asString(obj.tailSnippet),
+      timestamp: asTimestamp(obj.time) ?? asTimestamp(obj.timestamp)
+    });
+  }
+  return out;
+}
+function buildTaskCompletionTimeline(records, options = {}) {
+  const filtered = records.filter((r) => {
+    if (!options.adapterType) return true;
+    return r.adapterType === options.adapterType;
+  });
+  const turns = [];
+  let current = null;
+  let ignored = 0;
+  filtered.forEach((record, index) => {
+    if (record.event === "busy_signal" && current && current.completed) {
+      current = null;
+    }
+    if (!current) {
+      current = {
+        turn: turns.length + 1,
+        startIndex: index,
+        endIndex: index,
+        completed: false,
+        maxConfidence: 0,
+        finalConfidence: 0,
+        events: []
+      };
+      turns.push(current);
+    }
+    const step = toStep(record, index);
+    if (!step) {
+      ignored++;
+      return;
+    }
+    current.events.push(step);
+    current.endIndex = index;
+    current.maxConfidence = Math.max(current.maxConfidence, step.confidence);
+    current.finalConfidence = step.confidence;
+    if (step.status === "completed") {
+      current.completed = true;
+    }
+  });
+  return {
+    turns,
+    totalRecords: filtered.length,
+    ignoredRecords: ignored
+  };
+}
+function toStep(record, atIndex) {
+  const event = record.event;
+  const confidence = scoreConfidence(record);
+  if (event === "transition_ready") {
+    return withCommon(record, {
+      event,
+      atIndex,
+      status: "completed",
+      confidence: 100
+    });
+  }
+  if (event === "debounce_reject_signal" || event === "debounce_reject_status") {
+    return withCommon(record, {
+      event,
+      atIndex,
+      status: "rejected",
+      confidence
+    });
+  }
+  if (record.detectLoading) {
+    return withCommon(record, {
+      event,
+      atIndex,
+      status: "active_loading",
+      confidence
+    });
+  }
+  if (event === "debounce_fire" && record.signal) {
+    return withCommon(record, {
+      event,
+      atIndex,
+      status: "likely_complete",
+      confidence
+    });
+  }
+  if (event === "busy_signal" || event === "debounce_schedule" || event === "debounce_fire") {
+    return withCommon(record, {
+      event,
+      atIndex,
+      status: "active",
+      confidence
+    });
+  }
+  return null;
+}
+function scoreConfidence(record) {
+  let score = 10;
+  if (record.detectLoading) score -= 40;
+  if (record.detectReady) score += 20;
+  if (record.detectTaskComplete) score += 45;
+  if (record.signal) score += 20;
+  if (record.event === "debounce_reject_signal" || record.event === "debounce_reject_status") {
+    score -= 30;
+  }
+  if (record.event === "transition_ready") score = 100;
+  if (score < 0) return 0;
+  if (score > 100) return 100;
+  return score;
+}
+function withCommon(record, step) {
+  return {
+    ...step,
+    signal: record.signal,
+    detectTaskComplete: record.detectTaskComplete,
+    detectReady: record.detectReady,
+    detectLoading: record.detectLoading
+  };
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asBool(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function asTimestamp(value) {
+  if (typeof value === "string" || typeof value === "number" || value instanceof Date) {
+    return value;
+  }
+  return void 0;
+}
+
 // src/adapters/base-adapter.ts
 import { spawn } from "child_process";
 var BaseCLIAdapter = class {
@@ -1761,7 +2003,9 @@ var BaseCLIAdapter = class {
    */
   stripAnsi(str) {
     const withSpaces = str.replace(/\x1b\[\d*C/g, " ");
-    return withSpaces.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+    const withoutOsc = withSpaces.replace(/\x1b\](?:[^\x07\x1b]|\x1b[^\\])*(?:\x07|\x1b\\)/g, "");
+    const withoutDcs = withoutOsc.replace(/\x1bP(?:[^\x1b]|\x1b[^\\])*\x1b\\/g, "");
+    return withoutDcs.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
   }
 };
 
@@ -2455,8 +2699,10 @@ export {
   PTYSession,
   SPECIAL_KEYS,
   ShellAdapter,
+  buildTaskCompletionTimeline,
   createAdapter,
   createPTYManager,
+  extractTaskCompletionTraceRecords,
   isBun
 };
 //# sourceMappingURL=index.mjs.map