@cjhyy/code-shell-capability-coding 0.9.0 → 0.9.2

package/dist/tools/drive-agent.js

@@ -275,6 +275,23 @@ function safeFinalizeDriveWorktree(managed) {
         };
     }
 }
+/**
+ * Finalize a managed worktree once `run` settles, never before.
+ *
+ * Aborting a run only starts the driver's async process-tree teardown, so the
+ * external CLI can still be holding the worktree (and git's index.lock) when
+ * abort() returns. Cleaning up synchronously races that; waiting for the run to
+ * settle does not. Doubles as the rejection sink for an aborted run.
+ */
+function finalizeDriveWorktreeAfter(run, managed) {
+    void run
+        .catch(() => undefined)
+        .then(() => {
+        // safeFinalizeDriveWorktree already degrades a failed cleanup to a
+        // "kept" note rather than throwing, so nothing can escape this chain.
+        safeFinalizeDriveWorktree(managed);
+    });
+}
 function summarizePrompt(prompt, max = 120) {
     const oneLine = prompt.replace(/\s+/g, " ").trim();
     if (oneLine.length <= max)
@@ -607,6 +624,16 @@ function attachDriveCompletion(params) {
     });
 }
 function trackBackgroundRun(params) {
+    const { sessionId } = params;
+    if (!isValidSessionId(sessionId)) {
+        // Mirrors the background:true refusal above: a job whose completion
+        // notification cannot be routed would run and then vanish. Say so instead
+        // of registering work nobody can track. The caller aborts the run and
+        // finalizes any managed worktree on this error path.
+        return {
+            error: "Error: cannot track this DriveAgent run without a session — its result notification would be dropped. Re-run inside a session, or keep the task short enough to finish in the foreground.",
+        };
+    }
     const conflict = duplicateCwdError(params.effectiveWorkspaceCwd, params.effectiveWorkspaceRoot, params.writable);
     if (conflict)
         return { error: conflict };
@@ -616,7 +643,7 @@ function trackBackgroundRun(params) {
         // Publish ownership before starting the external process. Registry
         // listeners are synchronous and may re-enter session teardown from the
         // start notification; starting first would leave that process orphaned.
-        backgroundJobRegistry.start(jobId, params.sessionId, params.label, {
+        backgroundJobRegistry.start(jobId, sessionId, params.label, {
             kind: "drive-agent",
             launchCwd: params.cwd,
             effectiveWorkspaceCwd: params.effectiveWorkspaceCwd,
@@ -660,7 +687,7 @@ function trackBackgroundRun(params) {
         backgroundJobRegistry.finish(jobId, { status: "failed", finalText: message });
         return { error: `Error: failed to start DriveAgent job: ${message}` };
     }
-    attachDriveCompletion({ ...params, jobId, run });
+    attachDriveCompletion({ ...params, sessionId, jobId, run });
     return { jobId };
 }
 async function waitForForegroundOrHandoff(run, handoffMs) {
@@ -963,13 +990,26 @@ export function makeDriveAgentTool(runner = defaultRunner, fixedCli, options = {
             lease.release();
             return appendLifecycleNote(`${cliName} 运行出错：${error instanceof Error ? error.message : String(error)}`, lifecycle);
         }
-        if (result.kind === "handoff" && isValidSessionId(ctx?.sessionId)) {
+        if (result.kind === "handoff") {
+            // Handing off is NOT gated on a valid ctx.sessionId. Gating it there left
+            // a session-less foreground run falling through to `await run`, blocking
+            // until the 30min tool cap whose abort kills the external CLI — the work
+            // was destroyed with no jobId and no notification path. trackBackgroundRun
+            // owns the session check instead: it registers a tracked job when the
+            // session can receive the completion, and otherwise returns an error the
+            // branch below turns into an abort + deferred cleanup + explanation.
+            //
             // Registration below is synchronous. Release the foreground lease and
             // replace it with the background registry entry in the same event-loop
-            // turn, so another dispatch cannot slip into a gap.
+            // turn, so another dispatch cannot slip into a gap. The same invariant
+            // covers the failure path: the lease is dropped and no job exists between
+            // here and the return below, so that span MUST stay synchronous — an
+            // await would open the gap to a concurrent writable dispatch. Worktree
+            // finalization is deliberately NOT in that span: it is deferred to run
+            // settlement, after this turn has already returned.
             lease.release();
             const tracked = trackBackgroundRun({
-                sessionId: ctx.sessionId,
+                sessionId: ctx?.sessionId,
                 label,
                 cli,
                 cwd,
@@ -993,9 +1033,16 @@ export function makeDriveAgentTool(runner = defaultRunner, fixedCli, options = {
                 originClientMessageId: ctx?.originClientMessageId,
             });
             if ("error" in tracked) {
+                // abort() only STARTS teardown (SIGTERM, grace, SIGKILL); the CLI is
+                // still alive when it returns. Finalizing here would race the live
+                // process for the worktree and git's index.lock, so defer cleanup to
+                // run settlement and consume the abort rejection while we are at it.
+                // The message must not claim a cleanup that has not happened yet.
                 foregroundAbort.abort();
-                const lifecycle = safeFinalizeDriveWorktree(managedWorktree);
-                return appendLifecycleNote(tracked.error, lifecycle);
+                finalizeDriveWorktreeAfter(run, managedWorktree);
+                return managedWorktree
+                    ? `${tracked.error}\n\n[worktree lifecycle] Cleaning up ${managedWorktree.session.worktreePath} once ${cliName} exits.`
+                    : tracked.error;
             }
             ctx?.runYield?.request("background_notification");
             return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.0"
+    "@cjhyy/code-shell-core": "0.9.2"
   },
   "engines": {
     "node": ">=20.10"