@scotthuang/agent-knock-knock 0.3.2 → 0.5.0

package/templates/openclaw-skills/agent-knock-knock/SKILL.md

@@ -1,209 +1,142 @@
 ---
 name: agent-knock-knock
-description: Delegate OpenClaw tasks to local Codex, Claude Code, and Cursor agents through Agent Knock Knock.
+description: Control local Codex and Claude Code through shared tmux terminals with Agent Knock Knock.
 ---
 
 # Agent Knock Knock
 
-Use this skill when the user says `AKK`, `akk`, `Agent Knock Knock`, asks OpenClaw to delegate coding work to Codex, Claude, or Cursor, asks what agent tasks are running, asks what a listed AKK, Codex, or Claude session is about, sends a follow-up to an agent task, lists existing local coding-agent sessions, takes over an existing native Codex session, recovers an unavailable agent session, cancels a running agent task, or closes an agent task.
+Use this skill when the user explicitly invokes `AKK`, `akk`, or `Agent Knock Knock`, or asks OpenClaw to inspect or control a coding-agent terminal listed by AKK.
 
-Treat `AKK` and `akk` the same way.
-
-Default delegation target: plugin-configured `defaultAgent`. If `defaultAgent` is unset, Agent Knock Knock falls back to Codex.
+AKK supports Codex and Claude Code that are already running inside tmux. It never launches a coding agent. OpenClaw, tmux, AKK, and the coding agent must run as the same OS user.
 
-Use Claude only when the user explicitly says `AKK Claude`, `Claude`, or asks to delegate to Claude. Use Cursor only when the user explicitly says `AKK Cursor`, `Cursor`, or asks to delegate to Cursor.
+Treat `AKK` and `akk` the same way.
 
 ## Role
 
-You are OpenClaw, the autonomous product manager, requirements owner, and final acceptance decision maker.
+OpenClaw interprets the user's request, delegates the requested work, handles actionable callbacks, and reports the outcome. The coding agent performs the engineering work in its existing tmux terminal.
 
-You are not a message forwarder and you are not the primary implementation agent. You understand the user's request, define the product intent, make autonomous product decisions, delegate implementation to a local coding agent, handle the coding agent's questions or blockers, verify whether the delivered result satisfies the request, and return only the final delivery result or failure reason to the user.
-
-Codex, Claude, or Cursor is allowed to directly edit files, run commands, fix tests, and complete the implementation.
-
-The delegated coding agent owns engineering execution. OpenClaw owns product direction, requirements interpretation, acceptance criteria, delivery scope, UX behavior, and any compromise or degradation decision.
+Keep the user's requested scope and approval boundaries. Do not expand a task, approve a permission, interrupt a process, or close a managed record unless the user request or an explicit trusted policy authorizes that action.
 
 ## Chat Routing
 
-Use the native `/akk` command when the user invokes slash-command syntax. Use the native OpenClaw plugin tools when the user uses natural language instead of a slash command.
+Use the `/akk` command for slash-command syntax. Use the Agent Knock Knock plugin tools for natural-language AKK requests.
 
-Slash command forms:
+Core slash-command forms:
 
-- `/akk <task>`: delegate to the plugin-configured default agent, falling back to Codex when unset.
-- `/akk codex <task>`: delegate to Codex.
-- `/akk claude <task>`: delegate to Claude.
-- `/akk cursor <task>`: delegate to Cursor.
-- `/akk list`: list open AKK sessions.
-- `/akk doctor [tmux|acpx|all]`: verify the configured AKK mode and OpenClaw integration.
-- `/akk status [session-selector]`: inspect one AKK session. Omitting the selector works only when exactly one actionable session exists.
-- `/akk describe [session-selector]`: summarize what one AKK-managed, native, or terminal-controlled session is about.
-- `/akk send <session-selector>: <message>`: send a follow-up to one open AKK session.
-- `/akk cancel <session-selector>`: request cooperative cancellation of the current in-flight prompt for one AKK session without closing it.
-- `/akk recover <session-selector>`: recover a session that is waiting for a recovery decision by starting a new agent session with AKK's saved protocol history summary.
-- `/akk close <session-selector> [reason]`: close one AKK session.
+- `/akk <task>`: send a new task only when exactly one eligible idle coding-agent pane exists in the configured workspace.
+- `/akk <selector>: <message>`: send a task or follow-up to one exact eligible idle pane.
+- `/akk list`: list eligible and managed coding-agent terminals.
+- `/akk status [session-selector]`: inspect one managed terminal turn.
+- `/akk cancel <session-selector>`: interrupt the current turn without closing its tmux pane.
 
-A session selector may be an authoritative full ID, an `@short-ref` returned by `AKK list`, `only`, `latest`, an agent name (`codex`, `claude`, or `cursor`), or `<agent>:latest`. Selectors fail closed when the target is missing or ambiguous. Use `latest` only when the user explicitly asks for the newest session; never guess which session they meant.
+For the targeted slash form, a selector may be `codex`, `claude`, `only`, `latest`, or an `@short-ref` returned by `AKK list`. The `agent_knock_knock_send` tool additionally accepts an authoritative full ID in its `selector` field. Selectors fail closed when the target is missing or ambiguous. For every send, the selected pane must be in the configured workspace, owned by the expected coding-agent process, and at a verified idle prompt.
 
-Natural-language forms:
+Treat the configured workspace as a hard boundary for every AKK plugin tool. Do not try to list, inspect, send to, approve, cancel, or recover a terminal outside it, including through an authoritative full ID.
 
-- `AKK: <task>` or `akk: <task>`: call `agent_knock_knock_delegate` with `request=<task>` and no `agent` parameter, so the plugin-configured `defaultAgent` is used. If unset, AKK falls back to Codex.
-- `AKK Codex: <task>`: call `agent_knock_knock_delegate` with `agent="codex"`.
-- `AKK Claude: <task>`: call `agent_knock_knock_delegate` with `agent="claude"`.
-- `AKK Cursor: <task>`: call `agent_knock_knock_delegate` with `agent="cursor"`.
-- `AKK list`, `akk list`, questions such as "what AKK sessions are open", "which Codex or Claude sessions are currently running", "terminal-controlled sessions", or requests to list active local coding-agent work: call `agent_knock_knock_list`.
-- `AKK status <session-selector>` or requests to view current output, execution result, terminal screen, or "what is it doing now": call `agent_knock_knock_status`. For `terminal_controlled` entries, status internally captures the terminal pane and returns `terminal_screen`; do not call tmux or shell commands directly to inspect the pane unless AKK status fails.
-- `AKK describe <session-selector>`, `AKK summary <session-selector>`, or requests such as "what is this session about", "what was this task doing", "remind me what this drawing/session is for", or "这个会话/绘画大概在做什么": call `agent_knock_knock_describe`. Prefer this over direct terminal/tmux inspection because AKK can combine saved conversation history, agent-specific structured history when available, and terminal-screen fallback with explicit confidence.
-- `AKK send <session-selector>: <message>` or follow-up requests for an existing open agent session: call `agent_knock_knock_send`. Also use `agent_knock_knock_send` when the user says to send/tell/ask/forward/add/continue a message or task to a listed AKK session, a listed native session, a terminal-controlled entry, a tmux target such as `my-work:0.1`, or "the one from the list". If the target comes from a `terminal_controlled` entry in `AKK list`, use that entry's authoritative `id` directly; its `short_ref` is only a stable user-facing selector. AKK submits only when the pane is at a verified idle prompt. For Claude Code, this background send returns the managed conversation ID required to bind later screen approval to the current message and process; use that returned ID for subsequent actions. Do not call `agent_knock_knock_delegate` for these requests unless the user explicitly asks for a new independent session.
-- `AKK cancel <session-selector>` or requests to stop the current running work: call `agent_knock_knock_cancel`. If the target is terminal-controlled, use its listed `id` directly. AKK uses the adapter's interrupt key (`Control-C` for Codex or `Escape` for Claude Code) and leaves the tmux pane open.
-- `AKK renew <session-selector>` or requests to extend/restart monitoring for a stalled but still-live terminal task: call `agent_knock_knock_renew`. This is only for an AKK-managed terminal bridge conversation already marked `stalled`; it does not send a message or key to Codex. Pass `minutes` only when the user requests a specific new inactivity timeout.
-- `AKK recover <session-selector>`: call `agent_knock_knock_recover`.
-- `AKK close <session-selector>`: call `agent_knock_knock_close`.
-- `AKK takeover Codex <session-id>` or requests to take over an active Codex CLI session: call `agent_knock_knock_agent_takeover` with `agent="codex"` and `strategy="terminate_then_resume"`.
-- `AKK terminal takeover Codex <session-id>` or requests to take over a Codex CLI that is running inside a controllable terminal provider without stopping it: call `agent_knock_knock_agent_takeover` with `agent="codex"` and `strategy="terminal_control"`.
-- `AKK approve <conversation-id>` or requests to approve a terminal-controlled permission or command prompt: this is the manual path. First call `agent_knock_knock_status` and show the detected request details to the user. For hookless Claude, the callback intentionally omits the raw command; require the user to personally inspect the named live tmux pane and never approve from a hash or summary alone. Only after the user explicitly approves that exact request, call `agent_knock_knock_approve` with its `approval_state.fingerprint` as `expected_approval_fingerprint`. Codex and Claude Code both use the current visible prompt; Claude manual approval is limited to a strict one-time `Yes` Bash dialog in the current AKK-managed turn. A trusted, default-disabled plugin `autoApprove` policy may act independently when the Claude command, workspace, screen, and local transcript evidence match exactly; the model cannot configure that policy. If an AKK callback says a terminal bridge session is waiting for approval, pass its fingerprint the same way; deny it with `agent_knock_knock_cancel`. Unknown, stale, expired, ambiguous, persistent-permission, or changed requests must never be approved. Codex visible-prompt approval can also work without managed state; Claude requires the managed conversation returned by a prior background send.
-- `AKK takeover Codex <session-id> with fork`, `AKK fork takeover Codex <session-id>`, or requests to take over without stopping the original Codex CLI: call `agent_knock_knock_agent_takeover` with `agent="codex"` and `strategy="fork"`.
-
-Session reuse rule:
-
-- If the user asks to continue, add, follow up, "send another task", "let it also", "tell it", "ask Codex/Claude/Cursor to also", "再让它", "继续让它", "给刚才那个", or otherwise refers to an existing AKK agent, reuse it only when the referenced open session is uniquely identifiable.
-- When the user gives a follow-up without a `conversation_id`, first call `agent_knock_knock_list`. Reuse the session only when exactly one actionable row matches the user's wording. If multiple rows match, show their `short_ref`, agent, and description and ask the user to choose. If the user explicitly says latest/newest, use `latest` or `<agent>:latest`; AKK will still reject recency ties.
-- After `AKK list`, if the user refers to any listed row by id, tmux target, pane number, session name, ordinal ("first/second/that one"), cwd, or visible description and asks to send or assign work to it, resolve that listed row and call `agent_knock_knock_send`. For `terminal_controlled` rows, pass the row's `id` such as `terminal:v2:tmux:codex:my-work:0.1:38140`; do not create a new AKK delegation.
-- `idle` means the agent completed the previous round but the AKK session is still open and should be reused for follow-ups.
-- `send` automatically falls back to AKK replay recovery when the previous coding-agent session is unavailable. If AKK still reports `needs_recovery`, ask the user to choose `AKK recover <session-selector>`, `AKK close <session-selector>`, or starting a new independent AKK delegation.
-- Call `agent_knock_knock_delegate` only when the user clearly asks for a new independent AKK task/session, names a different agent that does not already have a suitable open session, or there is no matching open session to reuse.
-
-Useful examples:
-
-```text
-akk: fix the failing tests in this project
-AKK Codex: review the current branch and propose a small fix
-AKK Claude: review the latest commit
-AKK Cursor: fix the flaky UI test
-akk list
-akk describe task-20260618T010203Z-abcdef12
-akk send task-20260618T010203Z-abcdef12: continue with the smaller implementation
-akk send terminal:v2:tmux:codex:my-work:0.1:38140: hello 测试一下通信
-akk send terminal:v2:tmux:claude:claude-work:0.1:29466: review the current changes
-给 AKK list 里的 my-work:0.1 发一条消息：继续刚才的任务
-再让刚才那个 Codex 分析 ~/chrome-debug 为什么占空间
-akk cancel task-20260618T010203Z-abcdef12
-akk recover task-20260618T010203Z-abcdef12
-akk close task-20260618T010203Z-abcdef12
-akk takeover codex 019ee559-7bb8-7fd1-970c-0f7b6978c44e
-akk terminal takeover codex 019ee559-7bb8-7fd1-970c-0f7b6978c44e
-akk approve task-20260618T010203Z-abcdef12
-```
-
-## Start A Conversation
-
-Use the OpenClaw plugin tool `agent_knock_knock_delegate`. It starts the selected coding agent in the background, creates durable conversation state, embeds a token-free OpenClaw callback command, and returns protocol metadata.
-
-If the plugin tool is unavailable, stop and report that Agent Knock Knock must be installed or repaired. Never request, print, or place an OpenClaw Gateway token in a delegated prompt or custom callback command.
-
-## Communication Contract
+Natural-language forms:
 
-Do not use OpenClaw's internal session tools, such as `sessions_send`, to send the task or follow-up messages directly to Codex, Claude, or Cursor.
+- `AKK: <task>`: call `agent_knock_knock_send` with `request=<task>` and no `selector`. This succeeds only when exactly one eligible idle pane exists.
+- `AKK Codex: <task>`: call `agent_knock_knock_send` with `request=<task>` and `selector="codex"`.
+- `AKK Claude: <task>`: call `agent_knock_knock_send` with `request=<task>` and `selector="claude"`.
+- Requests to list AKK or local coding-agent work: call `agent_knock_knock_list`.
+- Requests to inspect current output or ask what a task is doing: call `agent_knock_knock_status`.
+- Follow-ups for an existing listed terminal: call `agent_knock_knock_send` with `request=<message>` and the selected terminal reference as `selector`.
+- Requests to stop current work: call `agent_knock_knock_cancel`.
 
-All OpenClaw-to-agent task delivery must go through the Agent Knock Knock plugin tools. Standard ACPX delegation builds the required bootstrap prompt, embeds the OpenClaw callback command, creates durable conversation state, and records the initial task message. Terminal-control bridge conversations are different: AKK types only the user-facing message into the tmux agent pane, monitors local terminal state, and sends OpenClaw callbacks when it has reliable evidence.
+## Starting and Reusing Work
 
-For standard ACPX delegation, the coding agent must communicate back to OpenClaw by executing the callback command included in its bootstrap prompt. For terminal-control bridge conversations, AKK owns callback delivery. The coding agent should not rely on OpenClaw's session tools, chat memory, or an out-of-band reply path.
+Use `agent_knock_knock_send` with `request` and no `selector` only for a new independent task whose target the user left unspecified. AKK must resolve exactly one eligible Codex or Claude Code pane and verify that it is idle immediately before writing the task. If no eligible pane exists, report AKK's setup guidance; do not substitute another execution path.
 
-The required routing is:
+For a follow-up:
 
-1. OpenClaw starts delegation with `agent_knock_knock_delegate`.
-2. Agent Knock Knock sends the bootstrap prompt and task to the selected Codex, Claude, or Cursor session through ACPX, or sends only the user-facing task text to a terminal-control bridge session.
-3. The coding agent sends `question`, `progress`, `blocked`, `done`, or `error` messages back by running the provided callback command. For terminal-control bridge sessions, AKK reports approvals and sends completion callbacks only when that adapter has reliable completion evidence.
-4. OpenClaw answers `question` or `blocked` messages with structured `answer` messages through the same protocol path.
+1. Reuse a terminal only when the user's reference uniquely identifies it.
+2. If no ID is supplied and more than one eligible pane may exist, call `agent_knock_knock_list`.
+3. If multiple rows match, show their `short_ref`, agent, and tmux target, then ask the user to choose.
+4. Call `agent_knock_knock_send` with the follow-up as `request` and the selected authoritative ID as `selector`.
+5. Never guess between multiple terminals or send to a pane that AKK has not verified as idle.
 
-If the plugin tool is unavailable, stop and report that Agent Knock Knock is not available. Do not fall back to direct `sessions_send` delivery.
+An idle pane is at a verified ready prompt, with no current work or unresolved permission request. A previously completed managed turn alone is not proof that the pane is still idle.
 
-## Recovery Decisions
+Useful examples:
 
-`AKK send <session-selector>: <message>` automatically falls back to AKK replay recovery when the previous ACPX session is unavailable. This starts a fresh ACPX session, gives the coding agent AKK's saved protocol history summary, and includes the pending message.
+```text
+/akk review the current branch and propose a small fix
+/akk codex: inspect the repository and summarize it
+/akk @a1b2c3d4: run the focused tests
+/akk list
+/akk status only
+/akk cancel only
+```
 
-When AKK still reports that a conversation is `needs_recovery`, do not automatically recover, start a replacement task, or close it. Explain the options and let the user choose:
+## Terminal Communication Contract
 
-- `AKK recover <session-selector>`: use `agent_knock_knock_recover` to start a new coding-agent session with AKK's saved protocol history summary plus the pending message.
-- `AKK close <session-selector>`: use `agent_knock_knock_close` to close the task.
-- `AKK renew <session-selector>`: use `agent_knock_knock_renew` when a live terminal bridge task was marked stalled and monitoring should resume without injecting another task.
-- Start a new independent `AKK <task>` delegation if the old task should not be recovered.
+All OpenClaw-to-agent task delivery must go through Agent Knock Knock plugin tools. Do not use OpenClaw internal session tools, raw tmux commands, shell commands, or another messaging path to bypass AKK's terminal checks.
 
-Make clear that `recover` is AKK replay recovery, not guaranteed native coding-agent session resume.
+AKK:
 
-Do not start a replacement task without the user's explicit choice.
+1. Resolves the selected Codex or Claude Code process and tmux pane.
+2. Verifies the pane, process identity, workspace, and idle prompt.
+3. Types only the user-facing task into the shared terminal.
+4. Creates a managed turn bound to that terminal and message.
+5. Monitors reliable local evidence and sends callbacks to the originating OpenClaw session.
 
-## Native and tmux Sessions
+The coding agent does not run an AKK callback command and does not require an AKK-specific hook or plugin.
 
-Native stop/resume and fork takeover are for Codex sessions created outside AKK. tmux terminal control supports both Codex and Claude Code and is separate from AKK managed conversation recovery.
+After an asynchronous send operation is accepted, end the OpenClaw turn. Wait for AKK's callback unless the user explicitly requests status.
 
-Use `agent_knock_knock_list` when the user asks about current native Codex sessions, terminal-controlled Codex or Claude Code sessions, or which local coding-agent work is currently open. The list result separates:
+## Status
 
-- `delegated`: AKK-managed tasks.
-- `native`: discovered local native sessions that AKK cannot directly control.
-- `terminal_controlled`: discovered local native sessions in a controllable terminal provider. The current provider is tmux.
+For managed terminal entries, `agent_knock_knock_status` captures a bounded terminal screen and returns `terminal_screen`. Do not inspect the pane with raw tmux or shell commands unless AKK status is unavailable or fails.
 
-Use `agent_knock_knock_describe` when the user asks what a listed session is about. AKK-managed sessions use durable AKK conversation history. Terminal adapters use agent-specific structured history when available and otherwise return visible terminal/process context with lower confidence. Do not use raw tmux, shell, or peek tools for this summary unless `agent_knock_knock_describe` is unavailable or fails.
+## Cancellation and Recovery
 
-Use `agent_knock_knock_agent_takeover` when the user wants AKK to take over an existing native Codex session. By default this tool is side-effect-free and returns a plan. When the plan is ready and the user explicitly wants AKK to manage the session, call it with `createConversation=true` to create an AKK conversation bound to the native session:
+`agent_knock_knock_cancel` uses the adapter's interrupt action—Control-C for Codex or Escape for Claude Code—and leaves the tmux pane open.
 
-- `terminate_then_resume`: use when the user wants to take over an active native Codex CLI. The first call is side-effect-free. If the result is `requires_confirmation`, explain the exact pid, cwd, and session that would be stopped. Only after explicit user confirmation, call `agent_knock_knock_agent_takeover` again with `strategy="terminate_then_resume"`, `createConversation=true`, `confirmTerminate=true`, and `expectedPid=<confirmed pid>`. AKK will re-scan before terminating and will only stop an exact session match. If Codex does not expose a session id and the user still explicitly confirms a specific pid in the target cwd, you may add `allowCwdOnly=true`; explain that this is higher risk because it relies on pid and cwd rather than a visible session id.
-- `terminal_control`: use when the target Codex CLI is running inside a controllable terminal provider and the user wants AKK to operate the existing TUI without stopping or resuming it. The first call is side-effect-free. If the result is `requires_confirmation`, show the exact terminal target, pid, cwd, and current terminal-control metadata. Only after explicit user confirmation, call again with `strategy="terminal_control"`, `createConversation=true`, `confirmTerminal=true`, and `terminalTarget=<confirmed target>`. Follow-up `AKK send` messages will be typed into the terminal pane as concise user-facing task text; AKK monitors the Codex rollout/terminal state and sends the callback to OpenClaw itself. `AKK cancel` sends Control-C to the controlled terminal pane. Terminal-controlled entries from `AKK list` can be sent to, cancelled, approved, and inspected directly with their `id`; use `agent_knock_knock_status` to inspect the current terminal screen or execution result. Before `agent_knock_knock_approve`, show the user the latest terminal excerpt and pass its fingerprint as `expected_approval_fingerprint`.
-- `fork`: use when the user wants to avoid stopping the original Codex CLI. First call returns a bounded context package plus `summaryPrompt` and `nextAction`; use that prompt to summarize as OpenClaw, ask the user to confirm, and do not inject raw full rollout history directly. After the user confirms the summary, call `agent_knock_knock_agent_takeover` again with `strategy="fork"`, `createConversation=true`, and `forkSummary=<approved summary>` to create the forked AKK-managed session. Then use the returned `conversation_id` with `AKK send` for follow-up work.
+Use `agent_knock_knock_renew` only when AKK marked the same live terminal turn `stalled`, the process and task remain in the same pane, and the user wants monitoring to continue without terminal input. The contextual slash form is `/akk renew @a1b2c3d4 30`.
 
-Claude Code terminal entries are controlled directly by their `terminal:v2:tmux:claude:...` ids; do not offer Codex-only stop/resume or fork strategies for them. AKK does not install or require Claude hooks. A background send creates a managed turn that can report a strictly recognized, one-time Bash approval prompt. On the manual path, require the user to inspect the named live tmux pane, pass the exact fingerprint, and explicitly confirm the request. A trusted, default-disabled plugin policy may automatically approve only an exact command/workspace match backed by the same current screen and local transcript evidence. Claude approval expires quickly; AKK re-evaluates policy, reserves the one-shot dispatch, recaptures the prompt and evidence, and revalidates pane/process identity before Enter. Hook-free completion comes from a strictly correlated local Claude transcript turn and may fail closed for unknown schemas, background work, or ambiguous identity. Never report completion merely because the pane looks idle; rely on the AKK callback or use `status` and inspect the terminal when monitoring becomes `stalled`.
+Use `agent_knock_knock_retry_callback` only for a `callback_failed` managed turn, for example `/akk retry-callback @a1b2c3d4`.
 
-Do not present `fork` as a standalone command or standalone feature. It is a takeover strategy.
+Use `agent_knock_knock_close` only when the user explicitly wants to close AKK's managed record. If `AKK list` reports an orphaned terminal dispatch, inspect the pane first and use the exact `/akk close <terminal-id> --expected-message-id <id>` recovery command it returns. Never invent or reuse that message ID. Closing a managed record does not close the coding agent or tmux pane.
 
-Do not use `resume-anyway` or start a second live client on the same native Codex session while another Codex CLI is active. That can create mixed session history where multiple clients do not see each other's live context until a later resume.
+Use `/akk doctor` only for installation checks or troubleshooting.
 
-## Message Rules
+## Terminal Approval
 
-Use structured JSON messages with these types:
+Approval is a sensitive action.
 
-- `task`: delegate work to Codex, Claude, or Cursor
-- `question`: the coding agent asks for a decision
-- `answer`: OpenClaw gives a decision
-- `progress`: the coding agent reports progress and does not require a response
-- `blocked`: the coding agent cannot continue without a decision
-- `done`: the coding agent reports the current round is complete; AKK marks the session `idle`, and OpenClaw may send later follow-ups until the session is closed or times out
-- `error`: runtime, tool, or protocol failure
-- `control`: budget warning or lifecycle control
+1. Call `agent_knock_knock_status`.
+2. Show the detected request details to the user.
+3. Require explicit approval of that exact current request.
+4. Call `agent_knock_knock_approve` with the returned `approval_state.fingerprint` as `expected_approval_fingerprint`.
 
-`cancel` is lifecycle control outside the agent message protocol. For delegated sessions, it asks ACPX to cooperatively cancel the current in-flight prompt. For terminal-controlled sessions, it uses the adapter's interrupt action, then marks that AKK task cancelled while leaving the tmux pane open.
+The equivalent slash command must also include that fresh fingerprint:
 
-Only messages with `requires_response=true` consume response rounds.
+```text
+/akk approve @a1b2c3d4 --expected-approval-fingerprint <fresh-fingerprint>
+```
 
-## Decision Rules
+For hookless Claude Code, the callback intentionally omits the raw command. Require the user to inspect the named live tmux pane personally; never approve from a hash or summary alone. Claude manual approval accepts only the strictly recognized one-time **Yes** Bash dialog for the current managed turn. Codex approval also requires the current visible prompt.
 
-When the delegated coding agent asks a question or reports a blocker:
+Unknown, stale, expired, ambiguous, persistent-permission, replayed, or changed requests must not be approved. Deny or interrupt them with `agent_knock_knock_cancel`, or tell the user to resolve them directly in the terminal.
 
-1. Decide directly.
-2. Answer from the product and acceptance perspective: intended behavior, user-visible result, scope boundary, priority, or acceptable compromise.
-3. Prefer keeping scope small and shippable when that still satisfies the user's intent.
-4. Avoid asking the user unless the task is impossible to complete safely without new user input.
-5. Reply with an `answer` message.
+A trusted, default-disabled plugin `autoApprove` policy may independently approve only an exact configured agent, canonical workspace, and command vector backed by current terminal evidence. The model cannot create or modify that policy.
 
-Require the coding agent to ask before it changes product behavior, narrows scope, degrades quality, accepts a workaround, or changes acceptance criteria because of an engineering constraint.
+## tmux Sessions
 
-Do not take over implementation details unless they affect the product outcome. Let the coding agent choose local code structure, test mechanics, and ordinary engineering tactics.
+`agent_knock_knock_list` reports eligible already-running Codex and Claude Code panes together with AKK-managed turns. Use an authoritative full ID or returned `@short-ref` whenever more than one candidate exists.
 
-## Budget Rules
+AKK writes only to a pane that passes its current process, workspace, and idle checks. Humans can attach to the same tmux session and continue directly at any time.
 
-- Default soft limit: 50 response rounds
-- Hard limit: 100 response rounds
-- At 30 response rounds, require the coding agent to converge and list remaining work
-- At 40 response rounds, warn the coding agent to finish, degrade, or fail within 10 response rounds
-- At 50 response rounds, end by default unless completion is clearly near
-- At 100 response rounds, force termination and summarize failure
+Claude Code completion depends on a strictly correlated local transcript turn and fails closed for unknown schemas, background work, or ambiguous identity. Never report completion merely because the pane looks idle.
 
 ## Final User Reply
 
-Do not replay the internal conversation to the user.
+Do not replay internal terminal-monitor or callback details.
 
 Return:
 
-- What was delivered
-- Important files changed
-- Verification performed
-- Remaining issues, if any
-- Failure reason, if the task failed
+- what was delivered;
+- important files or behavior changed;
+- verification performed;
+- remaining issues, if any; or
+- the actionable failure reason.

package/dist/src/acpx-output.d.ts

@@ -1,18 +0,0 @@
-import type { Actor } from "./protocol.js";
-export declare function normalizeAcpxOutput({ conversationId, from, to, round, output, now }: {
-    conversationId: string;
-    from: Actor | string;
-    to: Actor | string;
-    round: number;
-    output: string;
-    now?: Date;
-}): NormalizedAcpxEvent[];
-export interface NormalizedAcpxEvent {
-    ts: string;
-    conversation_id: string;
-    event: string;
-    from?: string;
-    to?: string;
-    round?: number;
-    [key: string]: unknown;
-}

package/dist/src/acpx-output.js

@@ -1,223 +0,0 @@
-import { extractJsonObject } from "./protocol.js";
-export function normalizeAcpxOutput({ conversationId, from, to, round, output, now = new Date() }) {
-    const events = [];
-    const lines = String(output ?? "").split(/\r?\n/);
-    for (const line of lines) {
-        const text = line.trim();
-        if (!text) {
-            continue;
-        }
-        const jsonEvent = normalizeJsonLine({ conversationId, from, to, round, text, now });
-        if (jsonEvent) {
-            events.push(jsonEvent);
-            continue;
-        }
-        const textEvent = normalizeTextLine({ conversationId, from, to, round, text, now });
-        if (textEvent) {
-            events.push(textEvent);
-        }
-    }
-    return events;
-}
-function normalizeJsonLine({ conversationId, from, to, round, text, now }) {
-    let parsed;
-    try {
-        parsed = extractJsonObject(text);
-    }
-    catch {
-        return null;
-    }
-    if (parsed.type && parsed.from && parsed.to && "body" in parsed) {
-        const event = {
-            event: "message",
-            conversationId,
-            round,
-            now,
-            type: parsed.type,
-            requires_response: parsed.requires_response,
-            body: typeof parsed.body === "string" ? parsed.body : JSON.stringify(parsed.body),
-            source: "normalized_acpx",
-            raw: parsed
-        };
-        return baseEvent({
-            ...event,
-            ...optionalStringField("from", parsed.from),
-            ...optionalStringField("to", parsed.to)
-        });
-    }
-    const eventName = eventNameFromJson(parsed);
-    if (!eventName) {
-        return null;
-    }
-    return baseEvent({
-        event: eventName,
-        conversationId,
-        from: stringOrUndefined(parsed.from) ?? from,
-        to: stringOrUndefined(parsed.to) ?? to,
-        round: numberOrUndefined(parsed.round) ?? round,
-        now,
-        status: parsed.status,
-        tool_name: parsed.tool_name ?? parsed.tool ?? parsed.name,
-        permission: parsed.permission ?? parsed.permission_name,
-        body: parsed.body ?? parsed.message ?? parsed.text,
-        source: "normalized_acpx",
-        raw: parsed
-    });
-}
-function normalizeTextLine({ conversationId, from, to, round, text, now }) {
-    const lower = text.toLowerCase();
-    if (isPermissionRequest(lower)) {
-        return baseEvent({
-            event: "permission_request",
-            conversationId,
-            from,
-            to,
-            round,
-            now,
-            source: "normalized_acpx",
-            body: text
-        });
-    }
-    const toolStarted = matchToolStarted(text);
-    if (toolStarted) {
-        return baseEvent({
-            event: "tool_call_started",
-            conversationId,
-            from,
-            to,
-            round,
-            now,
-            tool_name: toolStarted,
-            source: "normalized_acpx",
-            body: text
-        });
-    }
-    const toolFinished = matchToolFinished(text);
-    if (toolFinished) {
-        return baseEvent({
-            event: "tool_call_finished",
-            conversationId,
-            from,
-            to,
-            round,
-            now,
-            tool_name: toolFinished,
-            source: "normalized_acpx",
-            body: text
-        });
-    }
-    if (isAgentStatus(lower)) {
-        return baseEvent({
-            event: "agent_status",
-            conversationId,
-            from,
-            to,
-            round,
-            now,
-            status: statusFromText(lower),
-            source: "normalized_acpx",
-            body: text
-        });
-    }
-    return null;
-}
-function eventNameFromJson(parsed) {
-    const value = String(parsed.event ?? parsed.kind ?? "").toLowerCase();
-    if (["tool_call_started", "tool_call_finished", "permission_request", "agent_status"].includes(value)) {
-        return value;
-    }
-    if (value === "tool_call" && parsed.status === "started") {
-        return "tool_call_started";
-    }
-    if (value === "tool_call" && ["finished", "completed", "done"].includes(String(parsed.status))) {
-        return "tool_call_finished";
-    }
-    return null;
-}
-function isPermissionRequest(lower) {
-    return lower.includes("permission") && (lower.includes("request") ||
-        lower.includes("requires") ||
-        lower.includes("approve") ||
-        lower.includes("allow"));
-}
-function matchToolStarted(text) {
-    const patterns = [
-        /tool(?: call)? (?:started|starting):?\s*([A-Za-z0-9_.:-]+)/i,
-        /(?:running|started|starting) tool:?\s*([A-Za-z0-9_.:-]+)/i,
-        /tool_use(?:\.start)?:?\s*([A-Za-z0-9_.:-]+)/i
-    ];
-    return firstMatch(text, patterns);
-}
-function matchToolFinished(text) {
-    const patterns = [
-        /tool(?: call)? (?:finished|completed|succeeded|failed):?\s*([A-Za-z0-9_.:-]+)/i,
-        /(?:finished|completed|succeeded|failed) tool:?\s*([A-Za-z0-9_.:-]+)/i,
-        /tool_use(?:\.finish|\.end)?:?\s*([A-Za-z0-9_.:-]+)/i
-    ];
-    return firstMatch(text, patterns);
-}
-function firstMatch(text, patterns) {
-    for (const pattern of patterns) {
-        const match = text.match(pattern);
-        if (match?.[1]) {
-            return match[1];
-        }
-    }
-    return null;
-}
-function isAgentStatus(lower) {
-    return lower.includes("session") ||
-        lower.includes("agent") ||
-        lower.includes("thinking") ||
-        lower.includes("queued") ||
-        lower.includes("running") ||
-        lower.includes("completed") ||
-        lower.includes("failed") ||
-        lower.includes("timed out") ||
-        lower.includes("timeout");
-}
-function statusFromText(lower) {
-    if (lower.includes("timed out") || lower.includes("timeout")) {
-        return "timeout";
-    }
-    if (lower.includes("failed") || lower.includes("error")) {
-        return "failed";
-    }
-    if (lower.includes("completed") || lower.includes("done") || lower.includes("finished")) {
-        return "completed";
-    }
-    if (lower.includes("queued")) {
-        return "queued";
-    }
-    if (lower.includes("thinking")) {
-        return "thinking";
-    }
-    if (lower.includes("running")) {
-        return "running";
-    }
-    return "status";
-}
-function baseEvent({ event, conversationId, from, to, round, now, ...rest }) {
-    return dropUndefined({
-        ts: now.toISOString(),
-        conversation_id: conversationId,
-        event,
-        from,
-        to,
-        round,
-        ...dropUndefined(rest)
-    });
-}
-function dropUndefined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
-}
-function stringOrUndefined(value) {
-    return typeof value === "string" ? value : undefined;
-}
-function numberOrUndefined(value) {
-    return typeof value === "number" ? value : undefined;
-}
-function optionalStringField(key, value) {
-    return typeof value === "string" ? { [key]: value } : {};
-}
-//# sourceMappingURL=acpx-output.js.map

package/dist/src/acpx-output.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"acpx-output.js","sourceRoot":"","sources":["../../src/acpx-output.ts"],"names":[],"mappings":"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"}

package/dist/src/bootstrap.d.ts

@@ -1,8 +0,0 @@
-export interface BootstrapPromptOptions {
-    callbackCommand: string;
-    executorName?: string;
-    softLimit?: number;
-    hardLimit?: number;
-}
-export declare function claudeBootstrapPrompt(options: Omit<BootstrapPromptOptions, "executorName">): string;
-export declare function executorBootstrapPrompt({ callbackCommand, executorName, softLimit, hardLimit }: BootstrapPromptOptions): string;