fix: stabilize async completion flow and bump version

Author: bfly123

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## v5.2.7 (2026-03-07)
+
+### 🔧 Stability Fixes
+
+- **Completion Status**: Completion hook now distinguishes `completed`, `cancelled`, `failed`, and `incomplete` instead of reporting every terminal state as completed
+- **Cancellation Handling**: Gemini and Claude adapters now consistently honor cancellation and emit a terminal status instead of leaving requests stuck in processing
+- **Routing Safety**: Completion routing now keeps parent-project to subdirectory compatibility while preventing nested child sessions from hijacking parent notifications
+- **Codex Session Binding**: Bound Codex requests no longer drift to a newer session log in the same worktree
+- **askd Startup Guardrails**: `bin/ask` now respects `CCB_ASKD_AUTOSTART=0` and scrubs inherited daemon lifecycle env before spawning askd
+- **Claude Session Backfill**: `ccb` startup again backfills `work_dir` and `work_dir_norm` into existing `.claude-session` files
+- **Regression Tests**: Added focused tests for completion status handling, caller routing, autostart behavior, cancellation paths, and Codex session binding
+
 ## v5.2.5 (2026-02-15)
 
 ### 🔧 Bug Fixes

bin/ask

@@ -221,6 +221,10 @@ def _maybe_start_unified_daemon() -> bool:
     from askd_runtime import state_file_path
     from askd.daemon import ping_daemon
 
+    autostart_raw = (os.environ.get("CCB_ASKD_AUTOSTART") or "").strip().lower()
+    if autostart_raw in ("0", "false", "no", "off"):
+        return False
+
     # Check if already running
     state_file = state_file_path("askd.json")
     if ping_daemon(timeout_s=0.5, state_file=state_file):
@@ -247,11 +251,15 @@ def _maybe_start_unified_daemon() -> bool:
 
     # Start daemon in background with platform-specific flags
     try:
+        child_env = os.environ.copy()
+        child_env.pop("CCB_PARENT_PID", None)
+        child_env.pop("CCB_MANAGED", None)
         kwargs = {
             "stdin": subprocess.DEVNULL,
             "stdout": subprocess.DEVNULL,
             "stderr": subprocess.DEVNULL,
             "close_fds": True,
+            "env": child_env,
         }
         if os.name == "nt":
             kwargs["creationflags"] = getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
@@ -583,6 +591,15 @@ def main(argv: list[str]) -> int:
                 return EXIT_ERROR
 
     # Default async mode: background task
+    if _use_unified_daemon():
+        from askd_runtime import state_file_path
+        from askd.daemon import ping_daemon
+
+        state_file = state_file_path("askd.json")
+        if not ping_daemon(timeout_s=0.5, state_file=state_file) and not _maybe_start_unified_daemon():
+            print("[ERROR] Unified askd daemon not running", file=sys.stderr)
+            return EXIT_ERROR
+
     task_id = make_task_id()
     log_dir = Path(tempfile.gettempdir()) / "ccb-tasks"
     log_dir.mkdir(parents=True, exist_ok=True)

bin/ccb-completion-hook

@@ -33,6 +33,12 @@ lib_dir = script_dir.parent / "lib"
 sys.path.insert(0, str(lib_dir))
 
 from compat import read_stdin_text, setup_windows_encoding
+from completion_hook import (
+    completion_status_label,
+    completion_status_marker,
+    default_reply_for_status,
+    normalize_completion_status,
+)
 from session_utils import find_project_session_file
 
 setup_windows_encoding()
@@ -96,11 +102,9 @@ def _path_is_same_or_parent(parent: str, child: str) -> bool:
 def _work_dirs_compatible(session_work_dir: str, request_work_dir: str) -> bool:
     if not session_work_dir or not request_work_dir:
         return True
-    # Accept exact match and parent/child relationship to support calls from subdirectories.
-    return (
-        _path_is_same_or_parent(session_work_dir, request_work_dir)
-        or _path_is_same_or_parent(request_work_dir, session_work_dir)
-    )
+    # Accept exact match and parent->child relationship to support subdirectory calls
+    # without letting nested child projects hijack parent-project notifications.
+    return _path_is_same_or_parent(session_work_dir, request_work_dir)
 
 
 def send_via_terminal(pane_id: str, message: str, terminal: str, session_data: dict) -> bool:
@@ -243,7 +247,37 @@ def find_ask_command() -> str | None:
     return None
 
 
-def send_email_reply(provider: str, reply_content: str) -> bool:
+def _render_terminal_message(
+    provider_display: str,
+    req_id: str,
+    reply_content: str,
+    *,
+    output_file: str | None,
+    status: str,
+) -> str:
+    marker = completion_status_marker(status)
+    status_label = completion_status_label(status)
+    if output_file:
+        return f"""CCB_REQ_ID: {req_id}
+
+{marker}
+Provider: {provider_display}
+Status: {status_label}
+Output file: {output_file}
+
+Result: {reply_content}
+"""
+    return f"""CCB_REQ_ID: {req_id}
+
+{marker}
+Provider: {provider_display}
+Status: {status_label}
+
+Result: {reply_content}
+"""
+
+
+def send_email_reply(provider: str, reply_content: str, *, status: str) -> bool:
     """Send reply via email when CCB_CALLER=email."""
     try:
         from mail import load_config, SmtpSender
@@ -300,8 +334,9 @@ def send_email_reply(provider: str, reply_content: str) -> bool:
         # Remove common reply prefixes (case insensitive)
         subject = re.sub(r'^(Re:\s*|RE:\s*|回复：\s*|回复:\s*)+', '', subject, flags=re.IGNORECASE)
 
+    status_label = completion_status_label(status)
     if not subject:
-        subject = f"[CCB] {provider.capitalize()} response"
+        subject = f"[CCB] {provider.capitalize()} {status_label.lower()}"
 
     # Build references chain for threading
     refs = ""
@@ -313,7 +348,7 @@ def send_email_reply(provider: str, reply_content: str) -> bool:
         refs = msg_id
 
     sender = SmtpSender(config)
-    body = f"[{provider.capitalize()}] {reply_content}"
+    body = f"[{provider.capitalize()} {status_label}] {reply_content}"
 
     success, result = sender.send_reply(
         to_addr=from_addr,
@@ -361,13 +396,20 @@ def main() -> int:
         reply_content = read_stdin_text()
     if not reply_content:
         reply_content = args.reply or ""
+    done_seen = env_bool("CCB_DONE_SEEN", True)
+    status = normalize_completion_status(os.environ.get("CCB_COMPLETION_STATUS", ""), done_seen=done_seen)
+    if not reply_content:
+        reply_content = default_reply_for_status(status, done_seen=done_seen)
 
     # Handle email caller - send reply via email
     if caller == "email":
-        if send_email_reply(provider, reply_content):
+        if send_email_reply(provider, reply_content, status=status):
             return 0
         return 1
 
+    if caller == "manual":
+        return 0
+
     # Terminal caller - construct notification message
     provider_names = {
         "codex": "Codex",
@@ -378,23 +420,13 @@ def main() -> int:
     provider_display = provider_names.get(provider, provider.capitalize())
     req_id = args.req_id or "unknown"
 
-    if output_file:
-        message = f"""CCB_REQ_ID: {req_id}
-
-[CCB_TASK_COMPLETED]
-Provider: {provider_display}
-Output file: {output_file}
-
-Result: {reply_content}
-"""
-    else:
-        message = f"""CCB_REQ_ID: {req_id}
-
-[CCB_TASK_COMPLETED]
-Provider: {provider_display}
-
-Result: {reply_content}
-"""
+    message = _render_terminal_message(
+        provider_display,
+        req_id,
+        reply_content,
+        output_file=output_file,
+        status=status,
+    )
 
     # Find caller's pane_id from session file
     session_files = {

ccb

@@ -52,7 +52,7 @@ backend_env = get_backend_env()
 if backend_env and not os.environ.get("CCB_BACKEND_ENV"):
     os.environ["CCB_BACKEND_ENV"] = backend_env
 
-VERSION = "5.2.4"
+VERSION = "5.2.7"
 GIT_COMMIT = "c539e79"
 GIT_DATE = "2026-02-25"
 
@@ -1354,6 +1354,27 @@ class AILauncher:
     def _claude_session_file(self) -> Path:
         return self._project_session_file(".claude-session")
 
+    def _backfill_claude_session_work_dir_fields(self) -> None:
+        path = self._claude_session_file()
+        if not path.exists():
+            return
+        data = self._read_json_file(path)
+        if not isinstance(data, dict) or not data:
+            return
+        changed = False
+        work_dir = str(self.project_root)
+        work_dir_norm = _normalize_path_for_match(work_dir)
+        if not str(data.get("work_dir") or "").strip():
+            data["work_dir"] = work_dir
+            changed = True
+        if not str(data.get("work_dir_norm") or "").strip():
+            data["work_dir_norm"] = work_dir_norm
+            changed = True
+        if not changed:
+            return
+        payload = json.dumps(data, ensure_ascii=False, indent=2)
+        safe_write_session(path, payload)
+
     def _read_local_claude_session_id(self) -> str | None:
         data = self._read_json_file(self._claude_session_file())
         sid = data.get("claude_session_id")
@@ -3320,6 +3341,8 @@ class AILauncher:
         if not self._require_project_config_dir():
             return 2
 
+        self._backfill_claude_session_work_dir_fields()
+
         if not self.providers:
             print("❌ No providers configured. Define providers in ccb.config or pass them on the command line.", file=sys.stderr)
             return 2

lib/askd/adapters/base.py

@@ -44,6 +44,7 @@ class ProviderResult:
     fallback_scan: bool = False
     log_path: Optional[str] = None
     extra: Optional[dict] = None
+    status: str = ""
 
 
 class QueuedTaskLike(Protocol):
@@ -118,6 +119,7 @@ def handle_exception(self, exc: Exception, task: QueuedTask) -> ProviderResult:
             req_id=task.req_id,
             session_key=f"{self.key}:unknown",
             done_seen=False,
+            status="failed",
         )
 
     def on_start(self) -> None:

lib/askd/adapters/claude.py

@@ -15,7 +15,14 @@
 from askd_runtime import log_path, write_log
 from ccb_protocol import BEGIN_PREFIX, REQ_ID_PREFIX
 from claude_comm import ClaudeLogReader
-from completion_hook import notify_completion
+from completion_hook import (
+    COMPLETION_STATUS_CANCELLED,
+    COMPLETION_STATUS_COMPLETED,
+    COMPLETION_STATUS_FAILED,
+    COMPLETION_STATUS_INCOMPLETE,
+    default_reply_for_status,
+    notify_completion,
+)
 from laskd_registry import get_session_registry
 from laskd_protocol import extract_reply_for_req, is_done_text, wrap_claude_prompt
 from laskd_session import compute_session_key, load_project_session
@@ -502,6 +509,7 @@ def handle_task(self, task: QueuedTask) -> ProviderResult:
                 req_id=task.req_id,
                 session_key=session_key,
                 done_seen=False,
+                status=COMPLETION_STATUS_FAILED,
             )
 
         ok, pane_or_err = session.ensure_pane()
@@ -512,6 +520,7 @@ def handle_task(self, task: QueuedTask) -> ProviderResult:
                 req_id=task.req_id,
                 session_key=session_key,
                 done_seen=False,
+                status=COMPLETION_STATUS_FAILED,
             )
         pane_id = pane_or_err
 
@@ -523,6 +532,7 @@ def handle_task(self, task: QueuedTask) -> ProviderResult:
                 req_id=task.req_id,
                 session_key=session_key,
                 done_seen=False,
+                status=COMPLETION_STATUS_FAILED,
             )
 
         deadline = None if float(req.timeout_s) < 0.0 else (time.time() + float(req.timeout_s))
@@ -553,20 +563,24 @@ def _finalize_result(self, result: ProviderResult, req: ProviderRequest, task: Q
         _write_log(f"[INFO] done provider=claude req_id={result.req_id} exit={result.exit_code}")
 
         reply_for_hook = result.reply
-        notify_done_seen = result.done_seen
+        status = result.status or (COMPLETION_STATUS_COMPLETED if result.done_seen else COMPLETION_STATUS_INCOMPLETE)
         if task.cancelled:
-            _write_log(f"[WARN] Task cancelled, sending failure completion hook: req_id={task.req_id}")
-            notify_done_seen = False
-            if not (reply_for_hook or "").strip():
-                reply_for_hook = "Task cancelled or timed out before completion."
-
-        _write_log(f"[INFO] notify_completion caller={req.caller} done_seen={notify_done_seen} email_req_id={req.email_req_id}")
+            _write_log(f"[WARN] Task cancelled, sending cancellation completion hook: req_id={task.req_id}")
+            status = COMPLETION_STATUS_CANCELLED
+        if not (reply_for_hook or "").strip():
+            reply_for_hook = default_reply_for_status(status, done_seen=result.done_seen)
+
+        _write_log(
+            f"[INFO] notify_completion caller={req.caller} status={status} "
+            f"done_seen={result.done_seen} email_req_id={req.email_req_id}"
+        )
         notify_completion(
             provider="claude",
             output_file=req.output_path,
             reply=reply_for_hook,
             req_id=result.req_id,
-            done_seen=notify_done_seen,
+            done_seen=result.done_seen,
+            status=status,
             caller=req.caller,
             email_req_id=req.email_req_id,
             email_msg_id=req.email_msg_id,
@@ -615,6 +629,10 @@ def _wait_for_response(
         last_pane_check = time.time()
 
         while True:
+            if task.cancel_event and task.cancel_event.is_set():
+                _write_log(f"[INFO] Task cancelled during wait loop: req_id={task.req_id}")
+                break
+
             if deadline is not None:
                 remaining = deadline - time.time()
                 if remaining <= 0:
@@ -639,6 +657,7 @@ def _wait_for_response(
                         anchor_seen=anchor_seen,
                         fallback_scan=fallback_scan,
                         anchor_ms=anchor_ms,
+                        status=COMPLETION_STATUS_FAILED,
                     )
                 last_pane_check = time.time()
 
@@ -686,5 +705,8 @@ def _wait_for_response(
             anchor_seen=anchor_seen,
             anchor_ms=anchor_ms,
             fallback_scan=fallback_scan,
+            status=COMPLETION_STATUS_COMPLETED if done_seen else (
+                COMPLETION_STATUS_CANCELLED if task.cancelled else COMPLETION_STATUS_INCOMPLETE
+            ),
         )
         return result