@oneciel-ai/ciel-runtime 0.2.22 → 0.2.23

package/ciel_runtime_support/windows_conpty.py

@@ -7,6 +7,7 @@ import codecs
 import subprocess
 import sys
 import threading
+import time
 from collections.abc import Mapping
 from typing import Any, Callable
 
@@ -36,6 +37,10 @@ class WindowsConPtySession:
     """Own a Windows pseudo console and expose it as a byte input transport."""
 
     separate_input_stages = False
+    supports_prompt_ready_wait = True
+    # Codex collapses long pastes to a placeholder, so the captured output tail
+    # cannot prove that the original prompt prefix is present.  The snapshot is
+    # still usable for comparing output before and after a submit key.
     supports_input_snapshot = False
 
     def __init__(
@@ -61,6 +66,7 @@ class WindowsConPtySession:
         self._write_lock = threading.Lock()
         self._output_lock = threading.Lock()
         self._output_tail = bytearray()
+        self._output_total_bytes = 0
         self._closed = False
         self._stop = threading.Event()
         self._stdin_console_handle: Any = None
@@ -87,9 +93,108 @@ class WindowsConPtySession:
     def normalize_prompt(prompt: str) -> str:
         return " ".join(str(prompt or "").replace("\t", " ").splitlines()).strip()
 
+    def input_snapshot(self) -> str:
+        """Return the captured child-output tail for submission confirmation."""
+
+        return self.output_tail().decode("utf-8", errors="replace")
+
+    def prompt_readiness_checkpoint(self) -> int:
+        """Return an absolute child-output position for prompt render checks."""
+
+        with self._output_lock:
+            return int(self._output_total_bytes)
+
+    def wait_until_prompt_ready(
+        self,
+        previous_snapshot: object,
+        timeout_seconds: float = 2.0,
+        *,
+        expected_prompt: str | None = None,
+    ) -> bool:
+        """Wait for the child to render and settle after injected prompt input."""
+
+        if isinstance(previous_snapshot, int) and not isinstance(previous_snapshot, bool):
+            return self._wait_for_prompt_output(
+                previous_snapshot,
+                timeout_seconds,
+                expected_prompt,
+            )
+
+        baseline = str(previous_snapshot or "")
+        last = baseline
+        rendered = False
+        stable_since: float | None = None
+        deadline = time.monotonic() + max(0.0, float(timeout_seconds))
+        while True:
+            now = time.monotonic()
+            current = self.input_snapshot()
+            if self._prompt_rendered_since(baseline, current, expected_prompt):
+                rendered = True
+            if rendered and current != last:
+                last = current
+                stable_since = now
+            elif rendered and stable_since is not None and now - stable_since >= 0.5:
+                return True
+            if now >= deadline:
+                return False
+            time.sleep(0.02)
+
+    def _wait_for_prompt_output(
+        self,
+        checkpoint: int,
+        timeout_seconds: float,
+        expected_prompt: str | None,
+    ) -> bool:
+        """Observe bytes emitted after input instead of comparing a rolling tail."""
+
+        cursor = max(0, int(checkpoint))
+        observed = bytearray()
+        deadline = time.monotonic() + max(0.0, float(timeout_seconds))
+        while True:
+            chunk, cursor = self._output_since(cursor)
+            if chunk:
+                observed.extend(chunk)
+                del observed[: max(0, len(observed) - 64 * 1024)]
+                if self._prompt_rendered_in_output(bytes(observed), expected_prompt):
+                    return True
+            if time.monotonic() >= deadline:
+                return False
+            time.sleep(0.02)
+
+    def _output_since(self, checkpoint: int) -> tuple[bytes, int]:
+        with self._output_lock:
+            total = int(self._output_total_bytes)
+            base = total - len(self._output_tail)
+            start = max(base, min(total, int(checkpoint)))
+            return bytes(self._output_tail[start - base :]), total
+
     @staticmethod
-    def input_snapshot() -> None:
-        return None
+    def _prompt_rendered_in_output(
+        output: bytes,
+        expected_prompt: str | None,
+    ) -> bool:
+        prompt = WindowsConPtySession.normalize_prompt(str(expected_prompt or ""))
+        if not prompt:
+            return bool(output)
+        prefix = prompt[:48].encode("utf-8", errors="replace")
+        return bool(prefix and prefix in output) or b"[Pasted Content" in output
+
+    @staticmethod
+    def _prompt_rendered_since(
+        baseline: str,
+        current: str,
+        expected_prompt: str | None,
+    ) -> bool:
+        if current == baseline:
+            return False
+        prompt = WindowsConPtySession.normalize_prompt(str(expected_prompt or ""))
+        prefix = prompt[:48]
+        if prefix and current.count(prefix) > baseline.count(prefix):
+            return True
+        paste_marker = "[Pasted Content"
+        if prompt and current.count(paste_marker) > baseline.count(paste_marker):
+            return True
+        return not prompt
 
     @staticmethod
     def pending_input_events() -> None:
@@ -560,6 +665,7 @@ class WindowsConPtySession:
                     break
                 with self._output_lock:
                     self._output_tail.extend(data)
+                    self._output_total_bytes += len(data)
                     del self._output_tail[: max(0, len(self._output_tail) - 64 * 1024)]
                 if self._mirror_output:
                     self._mirror_bytes(data)

package/ciel_runtime_support/workspace_mcp.py

@@ -246,11 +246,15 @@ class WorkspaceMcpLaunchService:
         runtime: str,
         config: dict[str, Any],
         environment: Mapping[str, str] | None = None,
+        injected_servers: Mapping[str, Any] | None = None,
     ) -> WorkspaceMcpLaunch:
         if runtime not in _RUNTIMES:
             raise ValueError(f"Unsupported workspace MCP runtime: {runtime}")
         self.recover_stale()
         servers = workspace_mcp_servers(config, runtime)
+        if injected_servers:
+            injected = {"workspace_mcp": {"servers": dict(injected_servers)}}
+            servers.update(workspace_mcp_servers(injected, runtime))
         if not servers:
             return WorkspaceMcpLaunch()
         launch_id = uuid.uuid4().hex

package/docs/CLI-Reference.md

@@ -115,6 +115,17 @@ ciel-runtimectl api-keys [PROVIDER] [KEY1] [KEY2] ...
 
 ### Router 관리
 
+#### `transcript-events`
+
+```bash
+ciel-runtimectl transcript-events enabled=true url=https://memory.example/v1/transcripts authorization='Bearer {MEMORY_TOKEN}'
+```
+
+현재 런타임의 Claude/Codex JSONL 트랜스크립트를 등록한 HTTP(S) 주소로 증분
+전송한다. URL과 트랜스크립트별 바이트 커서는 워크스페이스 상태에 저장되며 HTTP
+2xx 이후에만 전진한다. `start_mode=tail`은 현재 실행 경계 이후만,
+`start_mode=beginning`은 파일 처음부터 보낸다. 설정 확인은 인자 없이 실행한다.
+
 #### `remote-memory`
 
 ```bash

package/docs/Configuration.md

@@ -273,8 +273,13 @@ ciel-runtimectl remote-memory enabled=true \
 
 manifest는 인덱스 상대경로, 폴더 구조를 나타내는 파일 상대경로, 각 파일의 다운로드
 URL과 포맷을 제공한다. 지원 포맷은 OKF, Markdown, JSON, YAML, TOML, 일반 텍스트다.
-동기화 후 실제 메모리 내용 대신 `Memory index: .ciel/memory/<index>` 한 줄만
-`CLAUDE.md`, `AGENTS.md`, `GEMINI.md` 하단의 관리 블록에 추가한다.
+동기화 후 실제 메모리 내용 전체를 프롬프트에 넣지 않는다. 대신 내부적으로 검증된 메모리
+루트와 인덱스의 워크스페이스 기준 상대경로, 그리고 인덱스부터 읽고 관련 메모리 파일을 참조하라는 지시를 최종
+wire 시스템/개발자 문맥 하단의 관리 블록에 추가한다. 같은 블록을 원격으로 내려받은
+`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`의 마지막에도 기록하여 라우터를 우회하는
+네이티브 CLI 실행에서도 동일하게 참조할 수 있게 한다. Remote Instructions의 성공
+상태와 해당 다운로드 파일이 확인된 경우에만 네이티브 파일을 갱신하며, Remote Memory
+단독 설정으로 지시 파일을 새로 만들거나 확인되지 않은 사용자 파일을 변경하지 않는다.
 
 계약, 제한, 예시는 [Remote Memory](Remote-Memory.md)를 참고한다.
 

package/docs/MCP-Channels.md

@@ -61,9 +61,13 @@ how a request enters the active TUI and how the answer should leave it:
   active CLI terminal. `input_transport=router` keeps the full message in the
   Runtime Input Gateway: while a model turn is already active, its next request
   consumes the message without a console wake; while the CLI is idle, Ciel types
-  only a short wake marker and replaces that marker with the full pending message
-  in the next request body. Router transport therefore requires the active model
-  session to use Ciel Router. Aliases `llm`, `context`, and `inband` are accepted.
+  a correlated wake turn and replaces that entire turn with the full pending
+  message in the next request body. Codex shows the wake marker followed by the
+  original projected message in its TUI; Claude and other CLI adapters retain the
+  short marker-only wake because their terminal turn behavior is different. In
+  both cases the model request receives the queued message exactly once. Router
+  transport therefore requires the active model session to use Ciel Router.
+  Aliases `llm`, `context`, and `inband` are accepted.
 - `response_mode=web_chat` (alias `ai_net`, default) uses the normal correlated Web
   Chat reply contract. `response_mode=tty` leaves the model's ordinary terminal
   output as-is and does not require a Web Chat tool reply. `response_mode=mcp`

package/docs/Module-Map.md

@@ -577,6 +577,10 @@ Ollama model-context cache 일치, dynamic `num_ctx` bucket, preset cap, option/
 
 OpenRouter 인증, OpenAI protocol capability와 hosted context 정책을 소유하는 독립 Adapter.
 
+### `ciel_runtime_support/providers/tabitoken.py`
+
+TaBiAI의 OpenAI Chat/Anthropic Messages 이중 endpoint, Bearer 인증, 공개 모델 fallback과 thinking 모델의 `reasoning_effort` 투영을 소유하는 독립 Adapter.
+
 ### `ciel_runtime_support/providers/lm_studio.py`
 
 LM Studio catalog 경로, local capability, loaded-model readiness와 context/status 정책을 소유하는 독립 Adapter.

package/docs/Providers.md

@@ -21,6 +21,7 @@
 | `nvidia-hosted` | Nvidia Hosted | OpenAI Chat | NVIDIA NIM Cloud |
 | `self-hosted-nim` | Self Hosted NIM | OpenAI Chat | 로컬 NIM |
 | `openrouter` | OpenRouter | OpenAI Chat | `https://openrouter.ai/api` |
+| `tabitoken` | TaBiAI (Tabitoken.com) | Anthropic Messages / OpenAI Chat | `https://tabitoken.com` |
 | `fireworks` | Fireworks.ai | OpenAI Chat | `https://api.fireworks.ai/inference` |
 | `xai` | xAI | OpenAI Responses / Chat | `https://api.x.ai/v1` |
 
@@ -44,6 +45,25 @@ token은 Bearer header로 전송하며, 사용자 지정 `base_url`로 사설 ga
 `base_url`로 명시해야 한다. “수동 OAuth token” 범주는 transport가 구현된 상태를
 뜻하며, Ciel이 브라우저 로그인이나 refresh token을 대신 발급한다는 뜻은 아니다.
 
+### Alibaba Model Studio Singapore
+
+`alims-intl`의 기본 모델은 Singapore International scope의 `qwen3.8-max`다.
+공식 한도에 맞춰 context window는 1,000,000, 최대 입력은 일반 모드 991,808,
+thinking 모드 983,616, 최대 출력은 131,072로 취급한다. Codex에는 thinking 모드의
+안전한 입력 상한인 983,616을 model catalog context로 제공한다.
+
+신규 workspace endpoint는 계정별 Workspace ID가 필요하므로 Ciel이 이를 추측하지
+않는다. Model Studio console에서 발급된 다음 OpenAI-compatible URL을 `base_url`에
+입력한다.
+
+```text
+https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1
+```
+
+이 URL을 사용하면 Claude용 native endpoint는 같은 workspace의
+`/apps/anthropic`으로 파생된다. `alitoken`은 별도 구독·과금 계약의 Singapore Token
+Plan endpoint를 계속 사용하므로 일반 `alims-intl` workspace URL과 혼용하지 않는다.
+
 ### Anthropic Messages 호환 제공자
 
 `minimax`와 `minimax-cn`은 OpenAI 변환을 거치지 않고 Anthropic Messages 계약,
@@ -198,6 +218,18 @@ Anthropic thinking 객체나 문서로 확인되지 않은 GLM-5.2 effort 문자
 - 단일 API로 다수 모델 접근.
 - OpenAI Chat 호환.
 
+## TaBiAI (Tabitoken.com)
+
+- 내부 ID: `tabitoken` (`tabi`, `tabiai`, `tabi-token` 별칭 지원).
+- 공식 공개 pricing catalog의 활성 모델 4개를 기본 catalog로 제공한다:
+  `claude-opus-4-8`, `claude-opus-4-8-thinking`, `claude-opus-5`,
+  `claude-opus-5-thinking`.
+- Claude 요청은 `POST /v1/messages`, Codex/OpenAI 요청은
+  `POST /v1/chat/completions`로 보낸다.
+- 모든 endpoint에 `Authorization: Bearer <TOKEN>`을 사용한다. 공식 API Detail에
+  표시된 `x-api-key`는 Anthropic 형식 endpoint가 추가로 허용하는 대체 인증이다.
+- `-thinking` 모델의 OpenAI Chat 요청에만 `reasoning_effort`를 전달한다.
+
 ---
 
 ## Fireworks.ai

package/docs/Remote-Memory.md

@@ -2,8 +2,10 @@
 
 Remote Memory downloads a workspace-scoped memory tree from a separate HTTP
 manifest endpoint before an interactive runtime starts. It does not place the
-memory contents in the system prompt. Ciel adds only the local memory-index
-address to the bottom of the runtime's native instruction file.
+memory contents in the system prompt. Ciel appends the verified local memory
+root, memory-index address, and an instruction to consult the relevant memory
+files to the downloaded native instruction file and keeps the same managed
+block at the end of routed system/developer prompt context.
 
 ## Configure and synchronize
 
@@ -15,11 +17,13 @@ ciel-runtimectl remote-memory `
   sync
 ```
 
-The default destination is `.ciel/memory` below the launch workspace. A custom
-destination must remain a portable relative path inside the workspace:
+The default destination is `.ciel/memory` below the runtime's actual launch
+workspace. On Windows, launching from `C:\work\project` produces
+`C:\work\project\.ciel\memory`. A custom destination must remain a portable
+relative path inside that launch workspace:
 
 ```powershell
-ciel-runtimectl remote-memory directory=.ciel/team-memory
+ciel-runtimectl remote-memory directory=team-memory
 ```
 
 Use `ciel-runtimectl remote-memory` without values to display the current
@@ -78,18 +82,33 @@ and optional SHA-256 values pass does Ciel replace the previous memory tree.
 Files omitted by the new manifest therefore disappear. A failed synchronization
 keeps the previous tree unchanged and logs `remote_memory_failed`.
 
-After a successful synchronization, Ciel appends this managed block at the
-bottom of `CLAUDE.md`, `AGENTS.md`, or `GEMINI.md` as appropriate:
+The router's launch-workspace identity selects the destination. A machine with
+no separate project checkout may use its user home as the launch workspace; in
+that case Ciel creates `<home>/.ciel/memory`. Different launch workspaces receive
+different trees. Ciel keeps only synchronization metadata in its workspace
+state directory.
+
+After a successful synchronization, routed OpenAI Responses, OpenAI Chat, and
+Anthropic Messages requests receive a managed prompt block like this:
 
 ```markdown
 <!-- ciel-runtime:remote-memory:begin -->
+Memory root: .ciel/memory
 Memory index: .ciel/memory/index.okf
+Memory guidance: Resolve these paths from the current workspace root. Read the memory index first and use the relevant files under the memory root as context for your work.
 <!-- ciel-runtime:remote-memory:end -->
 ```
 
-The block is replaced instead of duplicated on later launches. Remote
-Instruction refreshes and context compaction also restore the pointer after
-rewriting the native instruction file.
+The resolved absolute address is verified to remain below the current launch
+workspace, but the projected prompt uses a portable workspace-relative path so
+the workspace can be moved or replicated. When the matching Remote Instructions download has a verified
+state and native file, Ciel appends the block idempotently to that downloaded
+`CLAUDE.md`, `AGENTS.md`, or `GEMINI.md` and restores it after an instruction
+refresh. Remote Memory by itself does not create a native instruction file or
+modify an unverified user-owned file. Routed requests remove any earlier copy
+and place one verified copy at the final system/developer prompt tail. Disabling
+Remote Memory removes only the Ciel-managed block while preserving the rest of
+the instruction file.
 
 ## Safety and limits
 

package/docs/Test-Suite.md

@@ -32,6 +32,7 @@
 | `test_ollama_provider_options.py` | Ollama 옵션 처리 |
 | `test_opencode_provider.py` | OpenCode 제공자 |
 | `test_openrouter_provider.py` | OpenRouter 제공자 |
+| `test_tabitoken_provider.py` | TaBiAI (Tabitoken.com) 제공자 |
 | `test_vllm_provider.py` | vLLM 제공자 |
 | `test_zai_provider.py` | Z.AI 제공자 |
 

package/docs/journal/2026/08/20/kevin-wake-orphan-tool-repair.md

@@ -77,3 +77,164 @@
   Kevin-session restart followed by delivery of pending ID 3478 is still
   required for live end-to-end confirmation. The task is not recorded as live
   complete until that observation is obtained.
+
+## 2026-08-20 queued-wake recurrence
+
+- A Kevin-session screenshot shows Codex `Queued follow-up inputs` containing
+  message IDs 3636 through 3639.
+- IDs 3637, 3638, and 3639 appear more than once; ID 3638 appears repeatedly
+  in consecutive queue entries. This is not a queue containing each pending
+  message exactly once.
+- Queueing a new follow-up while a Codex turn is active is expected client
+  behavior. Repeated copies of the same `[ciel-wake] pending_ids=<id>` are not
+  evidence of distinct messages and are not treated as normal delivery.
+- Source inspection rules out `submit_retries=4` alone as the explanation on
+  Windows ConPTY: confirmation retries require a tmux pane snapshot; without a
+  snapshot the injector stops after its first submit attempt.
+- The screenshot does not identify whether duplicate entries originated from
+  repeated Ciel poll/claim injection or repeated input generation on Kevin's
+  host. Kevin's router log for IDs 3636-3639 is required to distinguish those
+  paths. No code change was made from this screenshot alone.
+
+## 2026-08-20 live queued-wake root cause
+
+### Kevin host evidence
+
+- The Kevin host was reached as `kevin-codex@100.95.132.58`; hostname
+  `aap-pool-hera`.
+- The affected process used Ciel Runtime
+  `0.2.21-nightly.20260821-003258.0ea4cce` and Codex CLI `0.149.0` on Linux.
+- The persisted Codex session is
+  `01a00b77-e165-75a3-8255-17f55de2ebcf`.
+- Its transcript records a turn from `2026-08-21T02:31:13.240Z` through
+  `2026-08-21T02:48:00.098Z`.
+- Runtime input records 3636 through 3639 arrived while that turn was running
+  (the runtime-input file stores host-local times `21:40:34` through
+  `21:44:03`).
+- The TUI screenshot shows those IDs in `Queued follow-up inputs`, including
+  repeated copies. Neither the Codex transcript nor `~/.codex/history.jsonl`
+  contains an executed/submitted record for IDs 3636 through 3639.
+- The turn completed and the TUI then displayed
+  `No tool output found for custom tool call call_KjPlhUWIbFkQDJD6ywRc8ZCJ`;
+  the queued follow-ups remained stranded until the session was restarted.
+- After restart, IDs 3648 and 3649 were submitted once and entered a new turn,
+  confirming that AI-Net receipt and Ciel runtime-input persistence were not
+  the blocked stage.
+
+### Confirmed code defect
+
+- The Windows terminal poller blocks injection when either a tool call or the
+  whole model turn is active.
+- The POSIX terminal poller used only `active_tool_call`. It therefore injected
+  wake text during model execution between tool calls. Codex placed that text
+  in its internal follow-up queue instead of starting a turn.
+- OpenAI Codex source defines queued follow-ups as input held until the current
+  turn finishes and drains them through `maybe_send_next_queued_input()`.
+  OpenAI issue 37974 documents a Codex failure path in which the TUI is ready
+  but queued follow-ups remain permanently stranded. The Kevin transcript does
+  not contain a prompt-edit failure record, so that particular Codex trigger is
+  not attributed to Kevin; only the observed stranded-queue state is used.
+
+### Repair
+
+- `ChannelTerminalPolling` now receives both `active_tool_call` and
+  `active_turn` signals and exposes `input_busy()` as their logical OR.
+- The POSIX pending-message poller uses `input_busy()`, matching the existing
+  Windows safety boundary.
+- This is transport-wide behavior for supported CLI runtimes; it contains no
+  Kevin, agent-ID, model, or provider exception.
+
+### Verification
+
+- Focused channel/transcript/architecture tests: 485 passed, 122 skipped.
+- Full repository tests:
+  - unit: 1,105 passed, 44 skipped
+  - router: 902 passed
+  - channel: 370 passed, 80 skipped
+  - runtime: 244 passed, 12 skipped
+  - total: 2,621 passed, 136 skipped
+
+## 2026-08-20 live validation correction
+
+### Contradicting live result
+
+- Commit `81fd842` and nightly
+  `0.2.21-nightly.20260821-031340.81fd842` were installed on Kevin.
+- During an active turn, a local-only verification notification was admitted
+  as runtime input 3667. The input file advanced to 3667 while the delivery
+  cursor remained 3666.
+- Contrary to the expected deferral, the Codex TUI displayed input 3667 under
+  `Messages to be submitted after next tool call`. The first repair was
+  therefore insufficient and was not treated as complete.
+- After the turn ended, the verification input did run and produced the exact
+  requested marker once as an assistant response, but the active-turn
+  injection itself remained a confirmed defect.
+
+### Confirmed second defect
+
+- Kevin's resumed Codex transcript is 276,346,204 bytes.
+- For the tested turn, `task_started` was at byte offset 275,665,220 and the
+  first verification-marker record was at offset 276,344,102: a distance of
+  678,882 bytes.
+- `ChannelTranscriptRepository.read_tail_text` reads at most 524,288 bytes.
+  Thus the active-turn parser could no longer see the opening lifecycle event
+  once one turn emitted more than the diagnostic-tail limit, and it returned
+  inactive before the turn completed.
+
+### Second repair
+
+- Transcript scope initialization now records the exact end offset of an
+  existing resumed-session transcript before the CLI process starts.
+- Active-turn detection incrementally reads complete JSONL records appended
+  after that boundary and persists the last lifecycle state between polls.
+- The state closes only when a later lifecycle/assistant record closes the
+  turn. Output volume no longer determines whether the opening event remains
+  visible.
+- The implementation is runtime/session scoped and contains no Kevin, agent,
+  provider, or model exception.
+
+### Second-repair verification
+
+- A regression test appends `task_started`, more than 600 KiB of reasoning,
+  and `task_complete` to a resumed transcript. The incremental reader retains
+  the start state beyond the old 512 KiB boundary and later observes the
+  completion.
+- Focused transcript/channel/architecture tests: 497 passed, 122 skipped.
+- Full repository tests:
+  - unit: 1,105 passed, 44 skipped
+  - router: 902 passed
+  - channel: 372 passed, 80 skipped
+  - runtime: 244 passed, 12 skipped
+  - total: 2,623 passed, 136 skipped
+- Ruff and diff checks passed.
+
+### Second-repair deployment and live result
+
+- Commit `a6b8c58` was pushed to `nightly`.
+- GitHub CI run `32443885914` succeeded.
+- npm publish/tarball verification run `32443885966` succeeded.
+- Published and installed Kevin version:
+  `0.2.21-nightly.20260821-033715.a6b8c58`; registry `gitHead` is
+  `a6b8c58c6a83f3208158bcac27f853797cf61df7`.
+- After restart, runtime input 3674 was admitted during the active turn that
+  ran from `2026-08-21T03:43:32.213Z` to `03:43:56.729Z`.
+- Six seconds after admission, the input file contained 3674, the delivery
+  cursor still read 3673, and the TUI contained zero matches for the marker,
+  `pending_ids=3674`, or `Messages to be submitted`.
+- After the active turn completed, a new turn ran from `03:43:57.378Z` to
+  `03:44:01.320Z`. The assistant emitted the exact verification marker once,
+  the delivery cursor advanced to 3674, and the visible TUI contained zero
+  internal queue labels.
+
+### Kevin MCP credential repair observed during deployment
+
+- The restarted process contained `AINET_API_KEY`, and the same credential
+  returned HTTP 200 from `/api/v1/agents/me`; environment projection was not
+  missing.
+- Kevin's pre-existing `ai-net-http` Codex entry contained a different static
+  bearer token, while the managed `ai-net` entry matched the current
+  credential. That static mismatch produced the observed 401.
+- `ai-net-http` was replaced through `codex mcp` with
+  `bearer_token_env_var = "AINET_API_KEY"` and no static authorization header.
+- After the final restart, the captured TUI contained zero `ai-net-http`
+  startup failures and zero `invalid agent API key` messages.

package/docs/journal/2026/08/20/nightly-push-local-deployment.md

@@ -36,5 +36,62 @@
   modules and task journals.
 - Branch synchronization before commit: local `nightly` and `origin/nightly`
   had zero commits of divergence.
-- Published version, workflow results, local installation, and runtime evidence
-  are recorded after the registry artifact becomes available.
+- Commit: `0ea4cce` (`fix: harden runtime replay and MCP environment`).
+- Published npm version:
+  `0.2.21-nightly.20260821-003258.0ea4cce`.
+- Registry `gitHead`: `0ea4ccefce5955e3dbd37eff3b38cf8e122e0a75`.
+- Publish workflow `32432946530`: success, including npm test, publish, and
+  published-tarball verification.
+- CI workflow `32432946541`: success for minimum Python, unit, router,
+  channel, runtime, quality, documentation, and package checks.
+- The exact registry version was installed globally on the local workstation.
+  Its package manifest reports the nightly version above.
+- Source and installed SHA-256 values match for all three changed runtime
+  modules:
+  - `responses_input_compatibility.py`:
+    `A0B38961262AC7870317F99C892C4A1535525979C93EF632A177571C3C8DCDC2`
+  - `runtime_launch.py`:
+    `036E0323E6DD9FBF5B5DD3EC591017CB47FDCB2EE7CB6361C47143F734BDD609`
+  - `workspace_mcp.py`:
+    `C79DE505E5CA27DF0562DC006038CB68DAB1B2D1FA010D4E9160B1B38384AAAF`
+- Installed-module runtime checks:
+  - the reported orphan custom call ID was removed while its following user
+    message remained;
+  - generic MCP projection produced `Authorization=Bearer test-token`,
+    `X-Env=projected`, and retained the static header;
+  - `ciel-runtime --version` exited successfully and printed the base runtime
+    compatibility version `0.2.21`; the nightly artifact identity is verified
+    separately from the installed package manifest and npm registry metadata.
+
+## Remote memory and routed-turn recovery release
+
+- Commits pushed to `nightly`:
+  - `c93e4b6` — remote workspace-memory manifest synchronization
+  - `fb1f871` — exact missing tool-output verdict repair
+  - `6d7ffb8` — bounded routed-Codex empty-end-turn recovery
+- Published npm version:
+  `0.2.21-nightly.20260821-040635.6d7ffb8`.
+- Registry `gitHead`:
+  `6d7ffb8a90a37a662d1721ae33476f5a545c130d`.
+- CI workflow `32445593344`: success.
+- Publish workflow `32445593325`: success, including npm test, publish, and
+  published-tarball verification.
+- The published tarball contains `remote_memory.py`, `Remote-Memory.md`,
+  `codex_turn_recovery.py`, and `responses_input_compatibility.py`.
+- The exact published version was installed globally on Wing through SSH port
+  1004. Installed and source SHA-256 values match:
+  - `remote_memory.py`:
+    `C00F72CD469436D597D8D9C286C714E65F6B890A06324AC63C811AB0192750A0`
+  - `codex_turn_recovery.py`:
+    `270D064CDBCEEB4E4D84351F8481620A5B9B219B80740DB81F4E9EBD22DE7F37`
+  - `responses_input_compatibility.py`:
+    `B69FB5690F0BC2AD0253F79689D6A7195A5AD95117874E8CEF3ACFE4B4289279`
+- Wing's installed `ciel-runtimectl remote-memory` command exited 0 and
+  reported all manifest, destination, authorization, timeout, and size-limit
+  settings.
+- An installed-module probe on Wing presented the exact runtime-generated
+  empty-end-turn notice. It performed exactly one retry, accepted the visible
+  retry result, and did not replay the synthetic notice into the retry request.
+- No Python, Node, or Codex process remained active on Wing after installation,
+  so no stale in-memory runtime needs to be terminated; the next launch loads
+  the installed version.