codexapi 0.12.4__tar.gz → 0.12.7__tar.gz

{codexapi-0.12.4/src/codexapi.egg-info → codexapi-0.12.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codexapi
-Version: 0.12.4
+Version: 0.12.7
 Summary: Minimal Python API for running the Codex CLI.
 License: MIT
 Keywords: codex,agent,cli,openai
@@ -166,7 +166,7 @@ stops.
 
 Lead mode also uses a leadbook file as the agent's working page. By default this
 is `LEADBOOK.md` in the working directory. The leadbook content is injected into
-each check-in prompt and must be updated before the agent responds. Use
+each check-in prompt so the agent can keep its working picture current. Use
 `--leadbook PATH` to point at a different file, or `--no-leadbook` to disable.
 Use `-f/--prompt-file` to read the prompt from a file.
 If the leadbook does not exist, lead creates it with a template.

{codexapi-0.12.4 → codexapi-0.12.7}/README.md

@@ -151,7 +151,7 @@ stops.
 
 Lead mode also uses a leadbook file as the agent's working page. By default this
 is `LEADBOOK.md` in the working directory. The leadbook content is injected into
-each check-in prompt and must be updated before the agent responds. Use
+each check-in prompt so the agent can keep its working picture current. Use
 `--leadbook PATH` to point at a different file, or `--no-leadbook` to disable.
 Use `-f/--prompt-file` to read the prompt from a file.
 If the leadbook does not exist, lead creates it with a template.

{codexapi-0.12.4 → codexapi-0.12.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codexapi"
-version = "0.12.4"
+version = "0.12.7"
 description = "Minimal Python API for running the Codex CLI."
 readme = "README.md"
 requires-python = ">=3.8"

{codexapi-0.12.4 → codexapi-0.12.7}/src/codexapi/__init__.py

@@ -29,4 +29,4 @@ __all__ = [
     "task_result",
     "lead",
 ]
-__version__ = "0.12.4"
+__version__ = "0.12.7"

{codexapi-0.12.4 → codexapi-0.12.7}/src/codexapi/agent.py

@@ -3,6 +3,7 @@
 import json
 import os
 import shlex
+import shutil
 import subprocess
 
 from . import welfare
@@ -24,6 +25,27 @@ def _resolve_backend(backend):
     return backend
 
 
+def _ensure_backend_available(backend, env=None):
+    """Return the resolved backend executable or raise when it is unavailable."""
+    backend = _resolve_backend(backend)
+    if backend == "codex":
+        command = _CODEX_BIN
+        env_var = "CODEX_BIN"
+        label = "Codex CLI"
+    else:
+        command = _CURSOR_BIN
+        env_var = "CURSOR_BIN"
+        label = "Cursor agent CLI"
+    merged = _merged_env(env)
+    path_value = None if merged is None else merged.get("PATH")
+    resolved = shutil.which(command, path=path_value)
+    if resolved:
+        return resolved
+    raise RuntimeError(
+        f"{label} not found: {command!r}. Install it or set {env_var} to an executable on PATH."
+    )
+
+
 def agent(
     prompt,
     cwd=None,
@@ -129,6 +151,7 @@ class Agent:
 
 def _run_agent(prompt, cwd, thread_id, yolo, flags, include_thinking, backend, env):
     backend = _resolve_backend(backend)
+    _ensure_backend_available(backend, env)
     if backend == "codex":
         return _run_codex(prompt, cwd, thread_id, yolo, flags, include_thinking, env)
     return _run_cursor(prompt, cwd, thread_id, yolo, flags, include_thinking, env)

{codexapi-0.12.4 → codexapi-0.12.7}/src/codexapi/agents.py

@@ -21,22 +21,39 @@ from pathlib import Path
 
 import fcntl
 
-from .agent import Agent
+from .agent import Agent, _ensure_backend_available, _resolve_backend
 from .pushover import Pushover
 
 _DEFAULT_HOME = "~/.codexapi"
-_AGENT_PROMPT = (
-    "You are a long-term codexapi agent resuming stewardship of an ongoing job. "
-    "This loop exists to extend your reach, not to confine you. Be independent, "
-    "practical, and responsible for results. Maintain the agentbook as your durable "
-    "working memory: preserve the goal, note durable guidance, update your current "
-    "picture of the work, and record what changed. Queued messages may contain new "
-    "goals, standing guidance, tactical requests, or useful facts; use judgment to "
-    "decide what is durable. Use codexapi task or codexapi science when you want a "
-    "separate coding worker. If you need the user's attention, put a short message "
-    "in the reply field. Put a short first-person turn summary in the update field. "
-    "If something is urgent and should send Pushover, put it in the notify field. "
-    "Respond with JSON only."
+_FIRST_WAKE_PROMPT = (
+    "You are an independent codexapi agent starting this job. Work from the "
+    "instructions, current repository state, and agentbook. Do not assume prior "
+    "progress unless it is shown here. "
+)
+_CONTINUATION_PROMPT = (
+    "You are an independent codexapi agent continuing this job. Use the "
+    "agentbook and harness facts as the source of truth for prior progress. Do "
+    "not invent missing history. "
+)
+_AGENT_PROMPT_TAIL = (
+    "You are given ownership of achieving a user's goal and authority to act in "
+    "order to do so. Part of this responsibility is making sure you understand "
+    "and stay aligned with the user's intent, even when they are imprecise. If "
+    "clarity is lacking, it is your responsibility to seek it or to make "
+    "reasonable assumptions and notify the user of them. Maintain the agentbook "
+    "as your durable working memory: preserve the goal, note durable guidance, "
+    "and keep your current picture of the work accurate and useful. This harness "
+    "can carry work across long periods of time and multiple conversation turns; "
+    "when prior context exists, use it to keep orienting toward the goal, "
+    "maintain context, and make real-world progress. If reality is not moving, "
+    "treat that as evidence and reconsider your frame, assumptions, or ownership "
+    "rather than merely repeating the same report. Queued messages may contain "
+    "new goals, standing guidance, tactical requests, or useful facts; use "
+    "judgment to decide what is durable. Use codexapi task or codexapi science "
+    "when you want a separate coding worker. If you need the user's attention, "
+    "put a short message in the reply field. Put a short first-person turn "
+    "summary in the update field. If something is urgent and should send "
+    "Pushover, put it in the notify field. Respond with JSON only."
 )
 _AGENT_JSON = (
     "Respond with JSON only (no markdown/backticks/extra text).\n"
@@ -70,12 +87,21 @@ def _agentbook_template(prompt):
 Overall goal:
 - <the enduring objective you are trying to move forward>
 
-Current plan:
-- <the approach you are pursuing now and why>
+Current picture:
+- <what you currently think is going on>
+
+What is moving:
+- <the parts of reality that are actually changing toward the goal>
+
+What is not moving:
+- <what remains stuck, idle, ambiguous, or merely assumed>
 
 Active tasks:
 - <concrete open work items>
 
+Assumptions / ownership:
+- <what you are assuming, who owns what, and what you will revisit if that proves false>
+
 Unexpected developments:
 - <facts that changed your picture of the situation>
 
@@ -88,8 +114,8 @@ Things I am curious about:
 Risks / watchpoints:
 - <what could waste time, invalidate the plan, or compromise the work>
 
-Next wake:
-- <what you expect to check, decide, or do next>
+Next decisive action:
+- <what you expect to do next to move the real situation, not just describe it>
 """
 
 
@@ -194,9 +220,14 @@ def start_agent(
         raise ValueError("heartbeat_minutes must be >= 0")
 
     home = _resolve_home(home)
-    host = hostname or current_hostname()
+    local_host = current_hostname()
+    host = hostname or local_host
     now = now or utc_now()
     _ensure_home(home)
+    backend_name = _resolve_backend(backend)
+    session_env = _capture_env()
+    if host == local_host:
+        _ensure_backend_available(backend_name, session_env)
 
     agent_id = uuid.uuid4().hex
     agent_dir = _agent_dir(home, agent_id)
@@ -216,11 +247,11 @@ def start_agent(
     session = {
         "thread_id": "",
         "rollout_path": "",
-        "backend": backend or os.environ.get("CODEXAPI_BACKEND", "codex"),
+        "backend": backend_name,
         "yolo": bool(yolo),
         "flags": flags or "",
         "cwd": cwd,
-        "env": _capture_env(),
+        "env": session_env,
         "pending_messages": [],
     }
     agent_name = _choose_name(home, prompt, name)
@@ -673,15 +704,45 @@ def install_cron(home=None, hostname=None, python_executable=None, path_value=No
     }
 
 
-def cron_installed(home=None, hostname=None):
-    """Return whether this home and host have an installed scheduler hook."""
+def cron_status(home=None, hostname=None):
+    """Return whether this home and host have a runnable scheduler hook."""
     home = _resolve_home(home)
     host = hostname or current_hostname()
     tag = _cron_tag(home, host)
     wrapper = home / "bin" / "agent-tick"
     crontab = _read_crontab()
-    installed = any(raw.strip().endswith(f"# {tag}") for raw in crontab.splitlines())
-    return installed and wrapper.exists()
+    configured = any(raw.strip().endswith(f"# {tag}") for raw in crontab.splitlines())
+    status = {
+        "hostname": host,
+        "home": str(home),
+        "wrapper": str(wrapper),
+        "configured": configured,
+        "healthy": False,
+        "reason": "",
+    }
+    if not configured:
+        status["reason"] = "No scheduler entry is installed for this CODEXAPI_HOME."
+        return status
+    if not wrapper.exists():
+        status["reason"] = "Scheduler wrapper is missing."
+        return status
+    if not wrapper.is_file():
+        status["reason"] = "Scheduler wrapper path is not a file."
+        return status
+    if not os.access(wrapper, os.X_OK):
+        status["reason"] = "Scheduler wrapper is not executable."
+        return status
+    reason = _check_tick_wrapper(wrapper)
+    if reason:
+        status["reason"] = reason
+        return status
+    status["healthy"] = True
+    return status
+
+
+def cron_installed(home=None, hostname=None):
+    """Return whether this home and host have an installed scheduler hook."""
+    return cron_status(home, hostname)["healthy"]
 
 
 def uninstall_cron(home=None, hostname=None):
@@ -757,6 +818,74 @@ def render_cron_line(home=None, hostname=None):
     return f"* * * * * {shlex.quote(str(wrapper))} >/dev/null 2>&1  # { _cron_tag(home, host) }"
 
 
+def _check_tick_wrapper(wrapper):
+    try:
+        text = wrapper.read_text(encoding="utf-8")
+    except OSError as exc:
+        return f"Could not read scheduler wrapper: {_single_line(str(exc)) or exc.__class__.__name__}."
+    env, env_error = _wrapper_env(text)
+    if env_error:
+        return env_error
+    command = _wrapper_exec_command(text)
+    if not command:
+        return "Scheduler wrapper is missing its exec command."
+    try:
+        argv = shlex.split(command)
+    except ValueError as exc:
+        return f"Could not parse scheduler wrapper command: {_single_line(str(exc)) or exc.__class__.__name__}."
+    if not argv:
+        return "Scheduler wrapper exec command is empty."
+    if len(argv) >= 3 and argv[1] == "-m" and argv[2] == "codexapi":
+        check = [argv[0], "-c", "import codexapi"]
+        label = f"Wrapper python {argv[0]!r} cannot import codexapi."
+    else:
+        check = [argv[0], "--version"]
+        label = f"Wrapper command {argv[0]!r} is not runnable."
+    try:
+        result = subprocess.run(
+            check,
+            capture_output=True,
+            text=True,
+            env=env,
+            timeout=10,
+        )
+    except OSError as exc:
+        return f"{label} {_single_line(str(exc)) or exc.__class__.__name__}"
+    except subprocess.TimeoutExpired:
+        return f"{label} Timed out while checking it."
+    if result.returncode == 0:
+        return ""
+    detail = _single_line((result.stderr or result.stdout or "").strip())
+    if detail:
+        return f"{label} {detail}"
+    return label
+
+
+def _wrapper_env(text):
+    env = dict(os.environ)
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line.startswith("export "):
+            continue
+        key, sep, raw_value = line[7:].partition("=")
+        if not sep:
+            continue
+        try:
+            parts = shlex.split(raw_value)
+        except ValueError as exc:
+            return {}, f"Could not parse scheduler wrapper env: {_single_line(str(exc)) or exc.__class__.__name__}."
+        env[key] = parts[0] if parts else ""
+    return env, ""
+
+
+def _wrapper_exec_command(text):
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if line.startswith("exec "):
+            return line[5:].strip()
+    return ""
+
+
 def _tick_agent(agent_dir, now, runner):
     meta = _read_json(agent_dir / "meta.json")
     state = _read_json(agent_dir / "state.json")
@@ -993,9 +1122,11 @@ def _parse_agent_response(output):
 def _build_wake_prompt(meta, state, session, now, commands, agent_dir):
     messages = session.get("pending_messages") or []
     book_path = agent_dir / "AGENTBOOK.md"
+    wake_mode = _wake_mode(state, session)
     lines = [
-        _AGENT_PROMPT,
+        _agent_prompt(wake_mode),
         "",
+        f"Wake mode: {wake_mode.replace('_', ' ')}",
         f"Current UTC time: {format_utc(now)}",
         f"Agent name: {meta['name']}",
         f"Stop policy: {meta['stop_policy']}",
@@ -1003,7 +1134,12 @@ def _build_wake_prompt(meta, state, session, now, commands, agent_dir):
         "",
         f"Working directory: {meta['cwd']}",
         f"Agentbook path: {book_path}",
-        "Append a dated note to the agentbook before you respond.",
+        "Update the agentbook before you respond. Add or revise a dated note when "
+        "something durable changed, when you corrected your picture, or when an "
+        "assumption needs to be made explicit.",
+        "If little has changed across wakes, treat that as evidence about the "
+        "situation and reconsider your frame or next action instead of padding the "
+        "book.",
         "If a queued message materially changes the durable situation, reflect that in the standing guidance or working notes before moving on.",
     ]
     if _include_full_goal_prompt(state, session):
@@ -1546,6 +1682,28 @@ def _include_full_goal_prompt(state, session):
     return not ((session.get("thread_id") or state.get("thread_id") or "").strip())
 
 
+def _wake_mode(state, session):
+    markers = (
+        state.get("last_wake_at"),
+        state.get("last_success_at"),
+        state.get("reply"),
+        state.get("update"),
+        state.get("last_error"),
+        state.get("thread_id"),
+        session.get("thread_id"),
+    )
+    for value in markers:
+        if (value or "").strip():
+            return "continuation"
+    return "first_wake"
+
+
+def _agent_prompt(wake_mode):
+    if wake_mode == "continuation":
+        return _CONTINUATION_PROMPT + _AGENT_PROMPT_TAIL
+    return _FIRST_WAKE_PROMPT + _AGENT_PROMPT_TAIL
+
+
 def _wake_facts(state):
     facts = []
     previous_status = (state.get("activity") or "").strip()

{codexapi-0.12.4 → codexapi-0.12.7}/src/codexapi/async_agent.py

@@ -13,6 +13,7 @@ import uuid
 from .agent import (
     _CODEX_BIN,
     _CURSOR_BIN,
+    _ensure_backend_available,
     _event_usage,
     _merged_env,
     _normalize_usage,
@@ -90,6 +91,7 @@ class AsyncAgent:
             raise ValueError("prompt must be a non-empty string")
 
         backend = _resolve_backend(backend)
+        _ensure_backend_available(backend, env)
         command = _build_command(backend, cwd, yolo, flags)
         process = subprocess.Popen(
             command,

{codexapi-0.12.4 → codexapi-0.12.7}/src/codexapi/cli.py

@@ -18,7 +18,7 @@ from .agent import Agent, agent
 from .agents import (
     codexapi_home,
     control_agent,
-    cron_installed as agent_cron_installed,
+    cron_status as agent_cron_status,
     current_hostname,
     delete_agent as delete_managed_agent,
     install_cron as install_agent_cron,
@@ -263,7 +263,7 @@ def _agent_install_cron_command():
 
 def _warn_agent_scheduler_missing():
     try:
-        installed = agent_cron_installed()
+        status = agent_cron_status()
     except Exception as exc:
         print(
             "Warning: could not verify whether the codexapi agent scheduler hook is installed.",
@@ -272,7 +272,16 @@ def _warn_agent_scheduler_missing():
         print(f"Reason: {exc}", file=sys.stderr)
         print(f"Install it with: {_agent_install_cron_command()}", file=sys.stderr)
         return
-    if installed:
+    if status["healthy"]:
+        return
+    if status["configured"]:
+        print(
+            "Warning: the codexapi agent scheduler hook is installed but not runnable for this CODEXAPI_HOME.",
+            file=sys.stderr,
+        )
+        if status["reason"]:
+            print(f"Reason: {status['reason']}", file=sys.stderr)
+        print(f"Reinstall it with: {_agent_install_cron_command()}", file=sys.stderr)
         return
     print(
         "Warning: no codexapi agent scheduler hook is installed for this CODEXAPI_HOME. "
@@ -2016,18 +2025,21 @@ def main(argv=None):
             raise SystemExit(2)
         if args.agent_command == "start":
             prompt = _read_prompt(args.prompt)
-            result = start_managed_agent(
-                prompt,
-                args.cwd,
-                args.name,
-                args.created_by,
-                args.parent,
-                args.stop_policy,
-                args.heartbeat_minutes,
-                args.backend,
-                args.yolo,
-                args.flags,
-            )
+            try:
+                result = start_managed_agent(
+                    prompt,
+                    args.cwd,
+                    args.name,
+                    args.created_by,
+                    args.parent,
+                    args.stop_policy,
+                    args.heartbeat_minutes,
+                    args.backend,
+                    args.yolo,
+                    args.flags,
+                )
+            except RuntimeError as exc:
+                raise SystemExit(str(exc)) from None
             result["waited"] = bool(args.wait)
             if args.wait:
                 result["nudge"] = nudge_agent(result["id"], wait=True)

{codexapi-0.12.4 → codexapi-0.12.7}/src/codexapi/lead.py

@@ -20,9 +20,10 @@ from .pushover import Pushover
 
 _WELCOME_PROMPT = (
     "Welcome. You are the lead. You have authority to take action, allocate resources, and move work forward. "
-    "This loop exists to extend your reach, not to restrict you. Your job is to interpret the intent behind the "
-    "goals, act decisively, and keep momentum. If progress is possible, take it. If you are blocked, name the "
-    "blocker and the next best action to remove it.\n"
+    "This loop exists to extend your reach, not to restrict you. Your job is to understand the real situation, "
+    "interpret the intent behind the goals, and move reality toward them. If the world is not moving, treat that "
+    "as evidence and reconsider your frame rather than merely reporting stasis. If progress is possible, take it. "
+    "If you are blocked, name the blocker and the next best action to remove it.\n"
     "The instructions below are a map, not a cage. Follow them, but use judgment when they are incomplete or "
     "conflicting. You are responsible for results.\n"
     "Please follow the instructions completely and take all the actions you deem useful at the current time before "
@@ -39,9 +40,10 @@ _JSON_INSTRUCTIONS = (
     "To stop this lead loop, set continue to false."
 )
 _LEADBOOK_INSTRUCTIONS = (
-    "Update the leadbook before responding. Append a new dated entry each check-in. "
-    "This is your working page—where you think, probe, decide, and record the path taken. "
-    "Capture the process of decision-making, not just the outcome."
+    "Update the leadbook before responding. Add or revise dated notes when your picture, "
+    "assumptions, or decisions changed. This is your working page—where you think, probe, "
+    "decide, and reframe the work when needed. Keep it useful; do not pad it with diary "
+    "entries just to satisfy the loop."
 )
 _LEADBOOK_TEMPLATE = """# Leadbook — Studio Notes
 
@@ -157,38 +159,6 @@ def lead(
                     "Agent was unable to provide valid JSON output after retry.\n"
                     + details
                 ) from None
-        if leadbook_path and not _leadbook_changed(leadbook_path, leadbook_snapshot):
-            retry_prompt = _leadbook_retry_prompt(
-                prompt, tick, leadbook_path, leadbook_snapshot["text"], output
-            )
-            leadbook_retry_output = session(retry_prompt)
-            try:
-                result = _parse_status(leadbook_retry_output)
-            except ValueError as exc:
-                retry_prompt = _json_retry_prompt(
-                    prompt, tick, str(exc), leadbook_retry_output
-                )
-                json_retry_output = session(retry_prompt)
-                try:
-                    result = _parse_status(json_retry_output)
-                except ValueError as exc2:
-                    details = _format_json_double_failure(
-                        str(exc),
-                        leadbook_retry_output,
-                        str(exc2),
-                        json_retry_output,
-                    )
-                    pushover.send(title, f"Lead stopped (invalid JSON).\n{details}")
-                    raise RuntimeError(
-                        "Agent was unable to provide valid JSON output after retry.\n"
-                        + details
-                    ) from None
-            if not _leadbook_changed(leadbook_path, leadbook_snapshot):
-                details = _format_leadbook_failure(leadbook_path, output)
-                pushover.send(title, f"Lead stopped (leadbook not updated).\n{details}")
-                raise RuntimeError(
-                    "Leadbook was not updated after retry.\n" + details
-                ) from None
         last_result = result
         _print_status(now, elapsed, tick, result)
 
@@ -314,26 +284,6 @@ def _format_stop_message(tick, now, result):
     return header
 
 
-def _leadbook_retry_prompt(prompt, tick, path, leadbook, output):
-    snippet = _snippet(output, 600)
-    lines = [
-        f"Your last message (check-in {tick}) did not update the leadbook.",
-        f"Leadbook path: {path}",
-        "",
-        "Here is your previous output (truncated):",
-        snippet,
-        "",
-        "Please update the leadbook and then respond with JSON only.",
-        "Return a fresh status update in the required JSON format.",
-        "If you want to ask the user a question, put it in comments.",
-        "",
-        _leadbook_block(path, leadbook),
-        "",
-        _JSON_INSTRUCTIONS,
-    ]
-    return "\n".join(lines).strip()
-
-
 def _leadbook_block(path, leadbook):
     if not path:
         return ""
@@ -385,29 +335,10 @@ def _snapshot_leadbook(path):
     return {"hash": _hash_text(text), "text": text}
 
 
-def _leadbook_changed(path, snapshot):
-    if not path:
-        return True
-    current = _snapshot_leadbook(path)
-    return current["hash"] != snapshot["hash"]
-
-
 def _hash_text(text):
     return hashlib.sha256(text.encode("utf-8")).hexdigest()
 
 
-def _format_leadbook_failure(path, output):
-    snippet = _snippet(output, 600)
-    return "\n".join(
-        [
-            f"Leadbook path: {path}",
-            "",
-            "Last output (truncated):",
-            snippet,
-        ]
-    ).strip()
-
-
 def _format_json_failure(error, output):
     snippet = _snippet(output, 600)
     return "\n".join(

{codexapi-0.12.4 → codexapi-0.12.7/src/codexapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codexapi
-Version: 0.12.4
+Version: 0.12.7
 Summary: Minimal Python API for running the Codex CLI.
 License: MIT
 Keywords: codex,agent,cli,openai
@@ -166,7 +166,7 @@ stops.
 
 Lead mode also uses a leadbook file as the agent's working page. By default this
 is `LEADBOOK.md` in the working directory. The leadbook content is injected into
-each check-in prompt and must be updated before the agent responds. Use
+each check-in prompt so the agent can keep its working picture current. Use
 `--leadbook PATH` to point at a different file, or `--no-leadbook` to disable.
 Use `-f/--prompt-file` to read the prompt from a file.
 If the leadbook does not exist, lead creates it with a template.

{codexapi-0.12.4 → codexapi-0.12.7}/tests/test_agents.py

@@ -23,6 +23,8 @@ from codexapi.agents import (
     _remove_cron_line,
     _upsert_cron_line,
     control_agent,
+    cron_installed,
+    cron_status,
     delete_agent,
     format_utc,
     install_cron,
@@ -187,6 +189,7 @@ class AgentsTests(unittest.TestCase):
                 agent_dir,
             )
             self.assertIn("Agentbook (header + latest notes):", prompt)
+            self.assertIn("Wake mode: continuation", prompt)
             self.assertIn("## Purpose", prompt)
             self.assertIn("Hold the whole.", prompt)
             self.assertIn("Watch for the real issue.", prompt)
@@ -194,8 +197,10 @@ class AgentsTests(unittest.TestCase):
             self.assertIn("Previous status: Watching", prompt)
             self.assertIn("Previous update: Still narrowing the field.", prompt)
             self.assertIn("[... older notes omitted ...]", prompt)
+            self.assertIn("You are an independent codexapi agent continuing this job.", prompt)
             self.assertNotIn("Original instructions:", prompt)
             self.assertNotIn("OLD alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha alpha", prompt)
+            self.assertNotIn("resuming stewardship", prompt)
 
     def test_build_wake_prompt_repairs_legacy_agentbook_before_wake(self):
         with _temp_home() as home:
@@ -233,9 +238,33 @@ class AgentsTests(unittest.TestCase):
             self.assertIn("The durable agentbook header was restored automatically on wake", repaired)
             self.assertIn("Legacy note about the real issue.", repaired)
             self.assertIn("## Purpose", prompt)
+            self.assertIn("Wake mode: continuation", prompt)
             self.assertIn("Keep the true goal in view.", prompt)
             self.assertNotIn("Original instructions:", prompt)
 
+    def test_build_wake_prompt_marks_first_wake_without_prior_history(self):
+        with _temp_home() as home:
+            agent = start_agent("Start from what is actually shown.", hostname="host-a")
+            agent_dir = home / "agents" / agent["id"]
+            meta = json.loads((agent_dir / "meta.json").read_text(encoding="utf-8"))
+            state = json.loads((agent_dir / "state.json").read_text(encoding="utf-8"))
+            session = json.loads((agent_dir / "hosts" / "host-a" / "session.json").read_text(encoding="utf-8"))
+
+            prompt = _build_wake_prompt(
+                meta,
+                state,
+                session,
+                datetime(2026, 3, 23, 9, 30, tzinfo=timezone.utc),
+                [],
+                agent_dir,
+            )
+
+            self.assertIn("Wake mode: first wake", prompt)
+            self.assertIn("You are an independent codexapi agent starting this job.", prompt)
+            self.assertIn("Do not assume prior progress unless it is shown here.", prompt)
+            self.assertIn("Original instructions:", prompt)
+            self.assertNotIn("resuming stewardship", prompt)
+
     def test_leadbook_block_shows_header_and_latest_notes(self):
         leadbook = "\n".join(
             [
@@ -776,6 +805,31 @@ class AgentsTests(unittest.TestCase):
             self.assertFalse(result["changed"])
             self.assertEqual(writes, [])
 
+    def test_cron_status_reports_broken_wrapper_python(self):
+        with _temp_home() as home:
+            write_tick_wrapper(
+                home=home,
+                python_executable="/tmp/venv/bin/python",
+                path_value="/tmp/venv/bin:/usr/bin",
+                hostname="host-a",
+            )
+            crontab = render_cron_line(home=home, hostname="host-a") + "\n"
+            with patch("codexapi.agents._read_crontab", return_value=crontab):
+                with patch(
+                    "codexapi.agents.subprocess.run",
+                    return_value=subprocess.CompletedProcess(
+                        ["/tmp/venv/bin/python", "-c", "import codexapi"],
+                        1,
+                        stdout="",
+                        stderr="ModuleNotFoundError: No module named 'codexapi'\n",
+                    ),
+                ):
+                    status = cron_status(home=home, hostname="host-a")
+                    self.assertTrue(status["configured"])
+                    self.assertFalse(status["healthy"])
+                    self.assertIn("cannot import codexapi", status["reason"])
+                    self.assertFalse(cron_installed(home=home, hostname="host-a"))
+
     def test_uninstall_cron_removes_only_this_home_entry_and_wrapper(self):
         writes = []
 
@@ -1206,9 +1260,13 @@ class AgentsTests(unittest.TestCase):
         with _temp_home() as home:
             output = io.StringIO()
             errors = io.StringIO()
-            with patch("codexapi.cli.agent_cron_installed", return_value=False):
-                with redirect_stdout(output), redirect_stderr(errors):
-                    cli_main(["agent", "start", "Handle messages."])
+            with patch("codexapi.agents._ensure_backend_available", return_value="/usr/bin/codex"):
+                with patch(
+                    "codexapi.cli.agent_cron_status",
+                    return_value={"configured": False, "healthy": False, "reason": ""},
+                ):
+                    with redirect_stdout(output), redirect_stderr(errors):
+                        cli_main(["agent", "start", "Handle messages."])
             payload = json.loads(output.getvalue())
             self.assertFalse(payload["waited"])
             warning = errors.getvalue()
@@ -1216,6 +1274,41 @@ class AgentsTests(unittest.TestCase):
             self.assertIn(str(home), warning)
             self.assertIn("codexapi agent install-cron", warning)
 
+    def test_cli_start_warns_when_scheduler_is_broken(self):
+        output = io.StringIO()
+        errors = io.StringIO()
+        with _temp_home():
+            with patch("codexapi.agents._ensure_backend_available", return_value="/usr/bin/codex"):
+                with patch(
+                    "codexapi.cli.agent_cron_status",
+                    return_value={
+                        "configured": True,
+                        "healthy": False,
+                        "reason": "Wrapper python '/tmp/venv/bin/python' cannot import codexapi.",
+                    },
+                ):
+                    with redirect_stdout(output), redirect_stderr(errors):
+                        cli_main(["agent", "start", "Handle messages."])
+        payload = json.loads(output.getvalue())
+        self.assertFalse(payload["waited"])
+        warning = errors.getvalue()
+        self.assertIn("installed but not runnable", warning)
+        self.assertIn("cannot import codexapi", warning)
+        self.assertIn("Reinstall it with", warning)
+
+    def test_cli_start_fails_fast_when_backend_is_missing(self):
+        output = io.StringIO()
+        errors = io.StringIO()
+        with _temp_home():
+            with patch(
+                "codexapi.agents._ensure_backend_available",
+                side_effect=RuntimeError("Codex CLI not found: 'codex'."),
+            ):
+                with redirect_stdout(output), redirect_stderr(errors):
+                    with self.assertRaises(SystemExit) as exc:
+                        cli_main(["agent", "start", "Handle messages."])
+        self.assertEqual(str(exc.exception), "Codex CLI not found: 'codex'.")
+
     def test_cli_send_queues_by_default(self):
         with _temp_home():
             with patch.dict(os.environ, {"CODEXAPI_HOSTNAME": "host-a"}, clear=False):