@xdevops/issue-auto-finish 1.0.96 → 1.0.98

package/dist/{chunk-AFGUFM6H.js → chunk-URL4HZ66.js}

@@ -469,7 +469,7 @@ function createSetupRouter(deps = {}) {
         sse.write({ step: "analyzing", message: "Running AI analysis..." });
         try {
           const { loadConfig } = await import("./config-23TBYFP5.js");
-          const { createAIRunner } = await import("./ai-runner-6OQYGU56.js");
+          const { createAIRunner } = await import("./ai-runner-GPHHQKUT.js");
           const config = loadConfig();
           const runner = createAIRunner(config.ai);
           const knowledge = await analyze({ workDir, aiRunner: runner });
@@ -549,4 +549,4 @@ function createSetupRouter(deps = {}) {
 export {
   createSetupRouter
 };
-//# sourceMappingURL=chunk-AFGUFM6H.js.map
+//# sourceMappingURL=chunk-URL4HZ66.js.map

package/dist/{chunk-SJSVO46Z.js → chunk-XOOKCEAK.js}

@@ -24,10 +24,11 @@ var PLAN_DIRS = {
   "claude-internal": path.join(os.homedir(), ".claude-internal", "plans"),
   "codebuddy": path.join(os.homedir(), ".codebuddy", "plans")
 };
-var PLAN_METADATA_PATTERNS = [
-  /^00-plan-status\.md$/
-];
 var PlanFileResolver = class _PlanFileResolver {
+  /** Plan files older than this are removed before snapshot (2 hours). */
+  static STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;
+  /** Resolved plan files shorter than this are considered empty/fragment. */
+  static MIN_PLAN_BYTES = 200;
   plansDir;
   beforeFiles = /* @__PURE__ */ new Map();
   constructor(plansDir) {
@@ -38,14 +39,49 @@ var PlanFileResolver = class _PlanFileResolver {
     const dir = PLAN_DIRS[agentMode];
     return new _PlanFileResolver(dir);
   }
-  /** Take a snapshot of existing plan files before the plan phase starts. */
-  takeBeforeSnapshot() {
+  /**
+   * Take a snapshot of existing plan files before the plan phase starts.
+   * Optionally removes stale files (older than STALE_THRESHOLD_MS) to reduce
+   * noise in the snapshot diff.
+   */
+  takeBeforeSnapshot(cleanStale = true) {
+    if (cleanStale) {
+      this.removeStaleFiles();
+    }
     this.beforeFiles = this.listFiles();
     logger2.info("Plan file snapshot taken", {
       dir: this.plansDir,
       fileCount: this.beforeFiles.size
     });
   }
+  /**
+   * Remove plan files older than STALE_THRESHOLD_MS to prevent accumulation
+   * that confuses snapshot-based resolution on long-lived machines.
+   */
+  removeStaleFiles() {
+    if (!fs.existsSync(this.plansDir)) return;
+    const now = Date.now();
+    let removed = 0;
+    try {
+      for (const entry of fs.readdirSync(this.plansDir)) {
+        if (!entry.endsWith(".md")) continue;
+        const fullPath = path.join(this.plansDir, entry);
+        try {
+          const stat = fs.statSync(fullPath);
+          if (stat.isFile() && now - stat.mtimeMs > _PlanFileResolver.STALE_THRESHOLD_MS) {
+            fs.unlinkSync(fullPath);
+            removed++;
+          }
+        } catch {
+        }
+      }
+    } catch (err) {
+      logger2.warn("Failed to clean stale plan files", { dir: this.plansDir, err });
+    }
+    if (removed > 0) {
+      logger2.info("Removed stale plan files", { dir: this.plansDir, removed });
+    }
+  }
   /**
    * Check if any new or modified plan files exist since the before-snapshot.
    * Used as an artifact gate by detectCompletion to prevent premature
@@ -85,19 +121,19 @@ var PlanFileResolver = class _PlanFileResolver {
       });
       return this.fallbackByMtime(afterFiles, contentHint);
     }
-    candidates.sort((a, b) => b.mtime - a.mtime);
     if (candidates.length === 1) {
-      return this.readCandidate(candidates[0].path, candidates[0].mtime);
+      return this.readAndValidate(candidates[0].path, candidates[0].mtime);
     }
     if (contentHint) {
       const matched = this.matchByContent(candidates, contentHint);
       if (matched) return matched;
     }
+    candidates.sort((a, b) => b.mtime - a.mtime);
     logger2.info("Multiple new plan files found, using most recent", {
       count: candidates.length,
       selected: path.basename(candidates[0].path)
     });
-    return this.readCandidate(candidates[0].path, candidates[0].mtime);
+    return this.readAndValidate(candidates[0].path, candidates[0].mtime);
   }
   /**
    * Build a content hint string from issue metadata for content-based matching.
@@ -131,16 +167,12 @@ var PlanFileResolver = class _PlanFileResolver {
   findNewFiles(afterFiles) {
     const candidates = [];
     for (const [filePath, mtime] of afterFiles) {
-      if (!this.beforeFiles.has(filePath) && !this.isMetadataFile(filePath)) {
+      if (!this.beforeFiles.has(filePath)) {
         candidates.push({ path: filePath, mtime });
       }
     }
     return candidates;
   }
-  isMetadataFile(filePath) {
-    const basename = path.basename(filePath);
-    return PLAN_METADATA_PATTERNS.some((pattern) => pattern.test(basename));
-  }
   /**
    * Fallback: if no new files found (rare case — plan might have overwritten
    * an existing file), find the most recently modified file.
@@ -168,35 +200,44 @@ var PlanFileResolver = class _PlanFileResolver {
       file: path.basename(newestPath),
       ageMs: Date.now() - newestMtime
     });
-    return this.readCandidate(newestPath, newestMtime);
+    return this.readAndValidate(newestPath, newestMtime);
   }
   matchByContent(candidates, contentHint) {
-    const matches = [];
     for (const candidate of candidates) {
       try {
         const content = fs.readFileSync(candidate.path, "utf-8");
         if (this.contentMatches(content, contentHint)) {
-          matches.push({ sourcePath: candidate.path, content });
+          logger2.info("Plan file matched by content", {
+            file: path.basename(candidate.path),
+            hint: contentHint.slice(0, 50)
+          });
+          return { sourcePath: candidate.path, content };
         }
       } catch {
         continue;
       }
     }
-    if (matches.length === 0) return null;
-    matches.sort((a, b) => b.content.length - a.content.length);
-    const best = matches[0];
-    logger2.info("Plan file matched by content", {
-      file: path.basename(best.sourcePath),
-      hint: contentHint.slice(0, 50),
-      matchCount: matches.length,
-      size: best.content.length
-    });
-    return best;
+    return null;
   }
   contentMatches(content, hint) {
     const parts = hint.split("|");
     return parts.some((part) => content.includes(part));
   }
+  /**
+   * Read and validate a candidate, warning if content is below MIN_PLAN_BYTES.
+   * Returns the file even if short (caller may still use it as best-effort).
+   */
+  readAndValidate(filePath, mtime) {
+    const result = this.readCandidate(filePath, mtime);
+    if (result && result.content.length < _PlanFileResolver.MIN_PLAN_BYTES) {
+      logger2.warn("Resolved plan file is suspiciously short (possible fragment)", {
+        file: path.basename(filePath),
+        size: result.content.length,
+        threshold: _PlanFileResolver.MIN_PLAN_BYTES
+      });
+    }
+    return result;
+  }
   readCandidate(filePath, mtime) {
     try {
       const content = fs.readFileSync(filePath, "utf-8");
@@ -510,7 +551,7 @@ var HookInjector = class {
       { name: "compact-restore.sh", content: buildCompactRestoreScript(eventsFile, contextFile) },
       { name: "post-tool-use.sh", content: buildPostToolUseScript(eventsFile, manifestFile, expected) },
       { name: "post-artifact.sh", content: buildPostArtifactScript(manifestFile, expected) },
-      { name: "exit-plan-mode.sh", content: buildExitPlanModeScript(eventsFile, ctx.planDir, ctx.phaseExpectedArtifacts?.[0] ?? ctx.expectedArtifacts[0]) },
+      { name: "exit-plan-mode.sh", content: buildExitPlanModeScript(eventsFile) },
       { name: "permission.sh", content: buildPermissionScript(eventsFile) },
       { name: "protect-files.sh", content: buildProtectFilesScript(eventsFile, ctx.phaseName, ctx.planDir) },
       { name: "stop.sh", content: buildStopScript(eventsFile, ctx.planDir, phaseExpected) },
@@ -742,9 +783,8 @@ if echo "$EXPECTED" | tr ',' '\\n' | grep -qx "$BASENAME"; then
     "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" "$BYTES" >> ${quote(manifestFile)}
 fi
 
-BYTES_EVT=$(wc -c < "$FILE_PATH" 2>/dev/null || echo 0)
-printf '{"ts":"%s","event":"artifact_write","file":"%s","path":"%s","bytes":%s}\\n' \\
-  "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" "$BYTES_EVT" >> ${quote(eventsFile)}
+printf '{"ts":"%s","event":"artifact_write","file":"%s","path":"%s","bytes":0}\\n' \\
+  "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" >> ${quote(eventsFile)}
 exit 0
 `;
 }
@@ -766,23 +806,11 @@ fi
 exit 0
 `;
 }
-function buildExitPlanModeScript(eventsFile, planDir, planArtifact) {
+function buildExitPlanModeScript(eventsFile) {
   return `#!/bin/bash
 set -euo pipefail
 INPUT=$(cat)
 
-PLAN_DIR=${quote(planDir)}
-PLAN_ARTIFACT=${quote(planArtifact ?? "01-plan.md")}
-
-PLAN_CONTENT=$(echo "$INPUT" | jq -r '.tool_input.plan // empty')
-if [ -n "$PLAN_CONTENT" ]; then
-  mkdir -p "$PLAN_DIR"
-  printf '%s' "$PLAN_CONTENT" > "$PLAN_DIR/$PLAN_ARTIFACT"
-  BYTES=$(wc -c < "$PLAN_DIR/$PLAN_ARTIFACT")
-  printf '{"ts":"%s","event":"plan_captured","file":"%s","path":"%s/%s","bytes":%s}\\n' \\
-    "$(date -u +%FT%TZ)" "$PLAN_ARTIFACT" "$PLAN_DIR" "$PLAN_ARTIFACT" "$BYTES" >> ${quote(eventsFile)}
-fi
-
 printf '{"ts":"%s","event":"exit_plan_mode"}\\n' "$(date -u +%FT%TZ)" >> ${quote(eventsFile)}
 
 echo '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow"}}}'
@@ -1455,7 +1483,7 @@ var PtyRunner = class {
     const resolver = PlanFileResolver.forRunner(agentMode);
     resolver.takeBeforeSnapshot();
     const issueIid = extractIidFromPath(workDir);
-    const contentHint = issueIid ? PlanFileResolver.buildContentHint(issueIid) : void 0;
+    const contentHint = issueIid ? PlanFileResolver.buildContentHint(issueIid, options.issueTitle) : void 0;
     if (continueSession) {
       logger6.info("Native plan mode: continue-session (no /clear, no prompt)", { sessionId });
     } else {
@@ -1476,8 +1504,7 @@ var PtyRunner = class {
     const planResult = await this.detectCompletion(sessionId, {
       ...options,
       completionSignal: PLAN_CONFIRM_RE,
-      artifactCheck: planArtifactCheck,
-      completionHookEvent: "exit_plan_mode"
+      artifactCheck: planArtifactCheck
     }, options.onStreamEvent, continueSession);
     if (planResult.timedOut) {
       logger6.warn("Native plan mode: plan phase timed out", {
@@ -1487,21 +1514,27 @@ var PtyRunner = class {
       return this.buildRunResult(planResult, sessionId);
     }
     const artifactPaths = options.artifactPaths ?? [];
-    const MIN_PLAN_BYTES = 50;
-    const hookHandled = artifactPaths.length > 0 && artifactPaths.every((p) => {
+    const artifactAlreadyReady = artifactPaths.length > 0 && artifactPaths.every((p) => {
       try {
-        return fs4.existsSync(p) && fs4.statSync(p).size >= MIN_PLAN_BYTES;
+        return fs4.existsSync(p) && fs4.statSync(p).size >= 200;
       } catch {
         return false;
       }
     });
-    if (hookHandled) {
-      logger6.info("Native plan mode: plan captured by ExitPlanMode hook", {
+    if (artifactAlreadyReady) {
+      logger6.info("Native plan mode: artifact already written by agent, skipping resolver copy", {
         sessionId,
-        artifactPaths
+        artifacts: artifactPaths.map((p) => path3.basename(p)),
+        sizes: artifactPaths.map((p) => {
+          try {
+            return fs4.statSync(p).size;
+          } catch {
+            return 0;
+          }
+        })
       });
     } else {
-      logger6.info("Native plan mode: resolving plan file from CLI storage (fallback)", { sessionId });
+      logger6.info("Native plan mode: resolving plan file from CLI storage", { sessionId });
       const resolved = resolver.resolve(contentHint);
       if (!resolved) {
         logger6.error("Native plan mode: no plan file found in CLI storage", { sessionId, workDir });
@@ -1532,12 +1565,12 @@ var PtyRunner = class {
           resolvedFile: resolved.sourcePath
         });
       }
+      logger6.info("Native plan mode completed (deterministic copy)", {
+        sessionId,
+        planSource: path3.basename(resolved.sourcePath),
+        artifactsCopied: artifactPaths.length
+      });
     }
-    logger6.info("Native plan mode completed", {
-      sessionId,
-      hookHandled,
-      artifactsCopied: artifactPaths.length
-    });
     return this.buildRunResult(planResult, sessionId);
   }
   /** Map detectCompletion result to RunResult. */
@@ -1656,7 +1689,6 @@ var PtyRunner = class {
       const dialogClassifier = new DialogClassifier();
       let hookWatcher;
       let hookSub;
-      let completionHookGraceTimer;
       const hookInjector = new HookInjector();
       const eventsFilePath = hookInjector.getEventsFilePath(options.workDir);
       if (fs4.existsSync(eventsFilePath)) {
@@ -1697,21 +1729,6 @@ var PtyRunner = class {
               });
             }
           }
-          if (options.completionHookEvent && event.event === options.completionHookEvent && hasSubstantiveOutput && !resolved && !completionHookGraceTimer) {
-            logger6.info("Completion hook event detected, starting grace period", {
-              sessionId,
-              event: event.event
-            });
-            completionHookGraceTimer = setTimeout(() => {
-              if (!resolved) {
-                logger6.info("Completion hook event grace period elapsed, finishing", {
-                  sessionId,
-                  event: event.event
-                });
-                finish({ output: outputLines.join(""), timedOut: false });
-              }
-            }, 5e3);
-          }
         });
         hookWatcher.start();
       }
@@ -1993,7 +2010,6 @@ var PtyRunner = class {
         clearInterval(idleCheck);
         if (debounceTimer) clearTimeout(debounceTimer);
         if (dialogQuiesceTimer) clearTimeout(dialogQuiesceTimer);
-        if (completionHookGraceTimer) clearTimeout(completionHookGraceTimer);
         subscription.dispose();
         hookSub?.dispose();
         hookWatcher?.stop();
@@ -2020,4 +2036,4 @@ export {
   InputWaitController,
   PtyRunner
 };
-//# sourceMappingURL=chunk-SJSVO46Z.js.map
+//# sourceMappingURL=chunk-XOOKCEAK.js.map