kward 0.76.0 → 0.77.0

data/doc/getting-started.md

@@ -34,6 +34,8 @@ kward doctor
 
 This checks your config, auth, writable directories, and workspace. Run `kward help` to see all available commands and examples.
 
+Interactive startup also performs a cached RubyGems version check by default. It does not contact RubyGems on every start; disable it with `KWARD_DISABLE_UPDATE_CHECK=1` or the `updates.check` configuration setting. See [Configuration](configuration.md#Update_checks).
+
 If you are working from a checkout instead:
 
 ```bash
@@ -128,5 +130,7 @@ Inside interactive Kward:
 ## Next steps
 
 - Read [Usage](usage.md) for day-to-day workflows.
+- Read [Interactive composer](composer.md) for completion, history, file mentions, keyboard shortcuts, busy input, and images.
 - Read [Configuration](configuration.md) when you want to change providers, models, memory, or web search.
+- Read [Security and trust](security.md) before using Kward with sensitive data, untrusted repositories, or third-party extensions.
 - Read [Extensibility](extensibility.md) when you want reusable prompts, skills, or project rules.

data/doc/git.md

@@ -44,7 +44,7 @@ Use `Shift+Enter` to insert a newline if you need a multi-line commit message.
 
 Highlight a file in the `/git` overlay and press `Enter`.
 
-Kward opens a read-only diff viewer in the composer area. It shows classic Git diff output with added and removed lines colorized when terminal color is enabled.
+Kward opens a read-only diff viewer in the composer area. Added and removed lines are colorized when terminal color is enabled. The viewer supports unified and side-by-side layouts; its default `auto` mode uses side-by-side output at 120 columns or wider and unified output in narrower terminals. Choose a fixed layout with `/settings` → Interface → Diff view. See [Configuration](configuration.md#Editor_settings) for the JSON setting.
 
 Useful keys in the diff viewer:
 
@@ -61,7 +61,7 @@ Useful keys in the diff viewer:
 
 After you close the viewer, Kward returns to the Git overlay with the file list refreshed.
 
-The diff viewer is read-only. It is meant for checking what changed, not editing. If you spot something you want to fix, close the viewer, return to chat, and ask Kward to make the change or open the file with the built-in editor using `$path/to/file` (see [Configuration](configuration.md) for editor modes and settings).
+The diff viewer is read-only. It is meant for checking what changed, not editing. If you spot something you want to fix, close the viewer, return to chat, and ask Kward to make the change or open the file with the built-in editor using `$path/to/file`. See [Integrated Editor](editor.md) for editor workflows and keybindings.
 
 ## Example workflow
 

data/doc/lifecycle-hooks.md

@@ -302,18 +302,6 @@ MCP events are emitted in addition to generic `tool_call_*` events for tools pro
 | `shell_command_before` | `command`, `timeout_seconds`, `cwd` | `command`, `timeout_seconds` |
 | `shell_command_after` | shell metadata plus `content` | none |
 
-### Worker events
-
-| Event | Payload highlights | Supported modifications |
-| --- | --- | --- |
-| `worker_job_create` | `worker_id`, `role`, `title`, `status`, `session_path` | none |
-| `worker_job_start_before` | worker metadata | none |
-| `worker_job_start_after` | worker metadata | none |
-| `worker_job_ready_for_review` | worker metadata | none |
-| `worker_job_failed` | worker metadata plus `error` | none |
-
-Worker hooks are observe-and-warn hooks for background worker automation and audit trails. They do not control worker scheduling.
-
 ### Git events
 
 | Event | Payload highlights | Supported modifications |
@@ -337,9 +325,9 @@ Worker hooks are observe-and-warn hooks for background worker automation and aud
 
 `file_change_before` fires before `write_file` or `edit_file` mutates the workspace and can deny or ask for approval. `file_change_after` fires only after successful `write_file` or `edit_file` results.
 
-### MCP events
+### Matching MCP tools
 
-MCP tools are surfaced through generic tool events with:
+In addition to the dedicated MCP events above, MCP tools are surfaced through generic tool events with:
 
 - `source: "mcp"`
 - `server_name`

data/doc/pan.md

@@ -0,0 +1,167 @@
+# Pan mode
+
+Pan mode is Kward's browser interface for a workspace. It gives you a mobile-friendly transcript, prompt composer, live tool activity, and access to recent sessions while Kward continues running on your development machine.
+
+Use it when you want to work from another browser or device on a trusted network without running the full terminal UI there.
+
+## Before you start
+
+Pan is a small local HTTP server, not a hosted service. The machine running Kward performs model requests, reads and edits workspace files, runs tools, and stores sessions.
+
+Pan requires HTTP Basic Auth. Add credentials to `~/.kward/config.json`:
+
+```json
+{
+  "pan_mode": {
+    "host": "0.0.0.0",
+    "port": 8765,
+    "username": "kward",
+    "password": "choose-a-long-private-password"
+  }
+}
+```
+
+The defaults are:
+
+- `host`: `0.0.0.0`, which listens on all network interfaces.
+- `port`: `8765`.
+
+Kward refuses to start Pan unless both `username` and `password` are configured. The password is stored as plaintext in your config file, so do not reuse an important password or share the file.
+
+For access from the same machine only, bind to loopback instead:
+
+```json
+{
+  "pan_mode": {
+    "host": "127.0.0.1",
+    "port": 8765,
+    "username": "kward",
+    "password": "choose-a-long-private-password"
+  }
+}
+```
+
+## Start Pan
+
+Run Pan from the project it should control:
+
+```bash
+cd ~/code/my-project
+kward pan
+```
+
+Or select the workspace explicitly:
+
+```bash
+kward --working-directory ~/code/my-project pan
+```
+
+Kward prints the listening URL, workspace, and initial session path. With the default LAN binding, it detects and prints the machine's routed LAN address when available. Open port `8765` at that address, for example:
+
+```text
+http://192.168.1.25:8765/
+```
+
+Your browser asks for the configured Basic Auth username and password.
+
+Press `Ctrl+C` in the server terminal to stop Pan. Closing a browser tab does not stop the server or an active turn.
+
+## A normal workflow
+
+1. Start Pan in the workspace you want to use.
+2. Open the printed address in a browser and sign in.
+3. Enter a concrete request in the composer:
+
+   ```text
+   Review the current changes, inspect the affected files, and run the focused tests.
+   ```
+
+4. Watch reasoning, tool calls, tool output, retries, and the answer stream into the transcript.
+5. Continue in the same session, or use the session sidebar to switch work.
+
+Press Return to send. Use Shift+Return for a new line. The composer grows with multiline input up to its display limit.
+
+Prompts are accepted while another turn is running. Pan puts them into a single queue and executes them sequentially. The status below the composer shows whether Kward is working and how many prompts remain queued.
+
+## Work with sessions
+
+Pan saves conversations through the same workspace-scoped session store as the interactive CLI. The session sidebar shows up to 50 recent sessions with their title, modified time, and message count.
+
+From the sidebar you can:
+
+- select a session to resume it,
+- create a new session,
+- rename the active session,
+- delete the active session.
+
+On smaller screens, use the menu button to open the session drawer. Selecting a session closes the drawer and loads its transcript.
+
+A few details matter:
+
+- Pan starts with a new session when the server launches.
+- Creating or resuming a session rebuilds the active conversation and agent around it.
+- You cannot create, resume, rename, or delete sessions while a turn is active or prompts are queued. Wait for the queue to finish.
+- Deleting the active session creates and activates a replacement session first.
+- Pan asks for confirmation before deletion. The interface does not provide an undo action.
+- Sessions remain available to the terminal CLI through `/session` because both frontends use the same session files.
+
+See [Sessions](session-management.md) for storage, exports, forks, compaction, and other session operations that remain CLI-oriented.
+
+## Tools and live output
+
+Pan creates the normal Kward agent tool registry for the selected workspace. Depending on configuration, the model can use file, shell, web, code-search, skill, and MCP tools just as it can in a normal agent turn.
+
+The transcript displays:
+
+- user prompts,
+- streamed reasoning and assistant text,
+- tool names and arguments,
+- tool results,
+- retries and errors,
+- restored compaction summaries and prior session content.
+
+Assistant and reasoning entries use a built-in, dependency-free Markdown renderer. It supports headings, paragraphs, fenced code blocks, blockquotes, ordered and unordered lists (including task lists), inline code, emphasis, strikethrough, and HTTP(S) or `mailto:` links. Message content remains text-based; unsupported Markdown stays readable as plain text.
+
+Structured clarification questions are disabled in Pan because it does not have the interactive question picker. Ask the model to state uncertainties in the transcript when a task needs your decision.
+
+Pan does not reproduce terminal-only interfaces such as `/git`, `/files`, `/shell`, the integrated editor, settings pickers, tabs, or clipboard commands. Use natural-language requests for agent work and return to the CLI for those local UI workflows.
+
+## Hooks and plugins
+
+Pan runs configured command hooks and trusted plugin lifecycle hooks. Hook events and messages can appear in the browser's live event stream.
+
+Pan does not provide a dedicated approval interface for hook `ask` decisions. An approval request without a bridge fails closed, so use deterministic `deny` or non-blocking `warn` policies for Pan-facing hooks.
+
+Other plugin UI features, such as custom terminal commands, footers, or interactive canvas commands, are designed for the CLI or RPC clients and do not become controls in the Pan page.
+
+See [Lifecycle hooks](lifecycle-hooks.md#Frontend_support) and [Plugins](plugins.md) for the supported extension surfaces.
+
+## Network and security
+
+Pan exposes powerful agent tools through ordinary HTTP. Basic Auth protects every page and endpoint, but Pan does not provide TLS.
+
+Use these precautions:
+
+- Run it only on a network and machine you trust.
+- Prefer `127.0.0.1` when remote access is unnecessary.
+- Do not expose the port directly to the public internet.
+- Do not put Pan behind a public tunnel unless you provide a properly secured TLS/authentication boundary and understand the risk.
+- Use a unique password and protect `config.json`.
+- Remember that anyone with the credentials can submit prompts that cause file reads, edits, shell commands, web requests, or MCP calls with your account's permissions.
+- Stop the server when you are finished.
+
+Multiple authenticated browser tabs connect to the same Pan process, active session, prompt queue, and workspace. They are not isolated users. A session change or prompt submitted in one connected browser is visible to the others.
+
+Read [Security and trust](security.md) before using Pan with sensitive data or an unfamiliar repository.
+
+## Notes and limitations
+
+- Pan serves one configured workspace per process.
+- Turns run one at a time; queued prompts cannot be reordered or cancelled from the page.
+- Session changes are blocked until all active and queued work finishes.
+- There is no model or reasoning picker in the page; Pan uses the configured client defaults when it creates a conversation.
+- There is no dedicated tool-approval UI or structured-question UI.
+- The browser reconnects its event stream after a connection interruption, but events emitted while disconnected are not replayed through that stream. Reloading restores the persisted transcript.
+- Request bodies are limited to 64 KB.
+- Pan displays image entries from restored transcripts as text placeholders rather than rendering attached image data.
+- The server is intentionally small and does not replace the richer CLI or the integration-oriented [RPC protocol](rpc.md).

data/doc/rpc.md

@@ -67,7 +67,6 @@ Detailed capability fields include:
 - `composer`: composer-only UI features. Interactive session diff totals are explicitly unsupported over RPC (`composer.sessionDiff.supported: false`) because RPC clients already receive per-tool diff results and no live composer status payload is exposed. Clipboard copy is also unsupported over RPC (`composer.copy.supported: false`) because UI clients own clipboard access.
 - `security`: trusted-local behavior with optional per-turn tool approval. By default there is no workspace mutation guard or tool approval and shell/file mutation can run. File-tool workspace guardrails are reported under `capabilities.events.tools.workspaceGuardrails` and `runtime/state.workspaceGuardrailsEnabled`.
 - `export`: supported transcript export formats. Currently `markdown` and `html`; default is `markdown`.
-- `workers`: experimental agent worker pipeline. Reports `supported: false` by default; set to `supported: true` with `methods: ["workers/list", "workers/show"]` when Kward is launched with `--experimental-workers`.
 - `starterPack`: explicitly unsupported (`supported: false`, reason `cliOnlyInstallCommand`). Use `kward init` from the shell.
 - `shell`: explicitly unsupported (`supported: false`, reason `interactiveTuiOnly`) because `/shell` is the local embedded TUI shell.
 - `logging`: local redacted telemetry logging support, the log directory, enabled categories, `methods: ["logging/stats", "logging/tokenCsv"]`, `usageCsv` sub-capability with bucket support, JSONL format, rotation (10 MB, manual retention), config key `logging`, env prefix `KWARD_LOGGING`, and redacted-metadata-only content.
@@ -784,27 +783,6 @@ Completes the login using the submitted code.
 
 Returns login status for a login ID.
 
-## Worker methods (experimental)
-
-Worker methods are available only when Kward is launched with `--experimental-workers`. The `workers` capability reports `supported: false` by default and `supported: true` with `methods: ["workers/list", "workers/show"]` when the flag is active.
-
-### `workers/list`
-
-Params:
-
-- `sessionId`: active RPC session ID.
-
-Returns the list of agent workers for the session.
-
-### `workers/show`
-
-Params:
-
-- `sessionId`: active RPC session ID.
-- `workerId`: worker ID.
-
-Returns details for a specific worker.
-
 ## Security and privacy notes
 
 - RPC is intended for a trusted local UI and can read/write files, run shell commands, update secrets, and use OAuth.

data/doc/security.md

@@ -0,0 +1,180 @@
+# Security and trust
+
+Kward can read code, edit files, run commands, call model and search providers, and load local extensions. That makes it useful, but it also means you should treat it like a developer tool running with your account—not like a sandbox.
+
+This guide explains the trust boundaries and gives you a safe way to start work in an unfamiliar repository.
+
+## The short version
+
+- Kward and anything it launches run with your operating-system permissions.
+- File tools stay inside the active workspace by default, but shell commands are not sandboxed.
+- Existing files must be read before Kward's file tools can edit or overwrite them.
+- Plugins, MCP servers, command hooks, and HTTP hooks should be configured only from sources and endpoints you trust.
+- Project skills and workspace hooks are disabled until you opt in or trust them.
+- Prompts, selected file contents, tool results, and conversation history may be sent to the active model provider as needed to answer a request.
+- Web searches, fetched URLs, MCP calls, and HTTP hooks can send additional data to their respective services.
+
+If a task involves secrets, production credentials, customer data, or an untrusted repository, narrow the workspace and tools before asking Kward to act.
+
+## A safe first run in an unfamiliar repository
+
+Start with project-provided extensions disabled, which is the default:
+
+```bash
+cd ~/code/unfamiliar-project
+kward doctor
+kward
+```
+
+Then use a read-first workflow:
+
+```text
+Inspect the project structure and its AGENTS.md. Do not edit files or run project scripts yet. Tell me what instructions, hooks, skills, plugins, generated files, and risky setup commands I should review first.
+```
+
+Before enabling or running anything:
+
+1. Read the workspace `AGENTS.md` and any referenced instructions.
+2. Inspect `.kward/hooks.json`, `.kward/skills/`, and `.agents/skills/` yourself.
+3. Review setup scripts, package hooks, build files, and shell commands before allowing them to run.
+4. Keep project skills disabled unless you trust their instructions.
+5. Trust workspace hooks only after reviewing the full file with `kward hooks doctor` and `kward hooks trust`.
+6. Do not add repository-provided Ruby files to `~/.kward/plugins` unless you are willing to run them as your user.
+7. Ask Kward to explain proposed edits and commands before applying them when the impact is unclear.
+
+For especially sensitive work, use a disposable checkout, container, virtual machine, or restricted operating-system account. Kward's own guardrails do not replace operating-system isolation.
+
+## Workspace access is a guardrail, not a sandbox
+
+Kward's built-in file tools normally resolve paths inside the active workspace. They reject paths outside that boundary, and existing files must be read in the current conversation before `write_file` or `edit_file` can change them.
+
+These protections reduce accidental edits. They do not contain the whole process:
+
+- `run_shell_command`, `!command`, `/shell`, and `/pty` run with your user permissions.
+- A shell command can access files, environment variables, processes, and networks available to your account.
+- Plugins, command hooks, and MCP servers are local processes with the same general operating-system access.
+- Read-before-edit applies to Kward's file tools, not to arbitrary shell commands or extension code.
+
+You can disable the file boundary with `tools.workspace_guardrails: false`, but doing so broadens file-tool access and is rarely needed. See [Workspace tools](workspace-tools.md) for exact limits and [Configuration](configuration.md#Tool_workspace_guardrails) for the setting.
+
+## Tool approvals and policy hooks
+
+The interactive CLI does not ask for blanket approval before every tool call. Built-in guardrails and configured lifecycle hooks still apply, but ordinary file and shell tools can run during a turn.
+
+RPC clients can request per-turn approval with `approvalMode: "ask"`. Kward then emits `tool/approvalRequested` before each tool executes and waits for the client to answer. The default RPC approval mode is `none`.
+
+Lifecycle hooks can add deterministic policy around tools, shell commands, files, Git actions, model requests, and other events. A hook can allow, deny, modify supported data, warn, or ask for approval. An `ask` decision fails closed when the frontend has no approval bridge.
+
+Pan mode does not provide a dedicated hook-approval UI. Use `deny` or `warn` for Pan-facing policies instead of depending on interactive approval.
+
+See [Lifecycle hooks](lifecycle-hooks.md) for policy examples and [RPC protocol](rpc.md#Tool_approval_bridge) for the approval contract.
+
+## Know what you are trusting
+
+### Workspace instructions
+
+A repository-level `AGENTS.md` is guidance for the model, not executable code. Kward tells the model to read it for repository tasks. Instructions can still influence what the model proposes or which tools it calls, so review unfamiliar guidance just as you would review a contributor script.
+
+### Project skills
+
+Project skills under `.kward/skills/` and `.agents/skills/` are skipped by default. Enable them only after reviewing their `SKILL.md` instructions and supporting files:
+
+```text
+/settings → Tools & Search → Trust project skills
+```
+
+This setting trusts project skills generally; it is not a per-repository digest. A skill's `allowed-tools` metadata does not grant permissions or constrain tools in Kward.
+
+### Workspace hooks
+
+Project hooks in `.kward/hooks.json` run only after `/hooks trust`. Trust is tied to the file digest, so a change invalidates it and requires another review. Command hooks execute local commands; HTTP hooks send event data to their configured endpoint.
+
+### Plugins
+
+Ruby plugins in `~/.kward/plugins/*.rb` run inside the Kward process with your permissions. They can read files and environment variables, write files, run commands, and make network requests. Kward intentionally does not load plugins from a workspace directory.
+
+### MCP servers
+
+Configured MCP servers are local child processes. Their tools can expose application state such as browser pages, console messages, network traffic, or screenshots. Kward currently supports local stdio servers, but local transport does not make an untrusted server safe.
+
+Only add commands you trust to `mcpServers`, and review any environment variables supplied to them. See [MCP servers](mcp.md).
+
+## What leaves your machine
+
+### Model providers
+
+To answer a turn, Kward sends the assembled conversation context to the active model provider. Depending on the task, that context can include:
+
+- your prompts and prior conversation,
+- system instructions, personas, skills, memory, and plugin context,
+- file content read into the conversation,
+- shell and tool results,
+- images you attach,
+- summaries produced during compaction.
+
+Provider retention and training policies are controlled by the provider and your account or organization. Do not give Kward content you are not permitted to send to that provider.
+
+### Web tools
+
+Search queries go to the selected search provider. `fetch_content` and `fetch_raw` request the URL you provide or the model selects. Disable web tools when external lookup is inappropriate:
+
+```json
+{
+  "web_search": {
+    "enabled": false
+  }
+}
+```
+
+See [Web search](web-search.md#Network_behavior) for provider order and request behavior.
+
+### Hooks and MCP
+
+HTTP hook payloads can include prompts, commands, file paths, tool arguments, and selected event results. Avoid forwarding raw events to third parties. Git and file after-events may include command output or changed content.
+
+MCP tool arguments and results pass between Kward and the configured server. What the MCP server stores or forwards is determined by that server.
+
+## Local data and permissions
+
+Kward keeps user data under `~/.kward` by default, or mostly beside `KWARD_CONFIG_PATH` when that override is set.
+
+| Data | Typical location | Notes |
+| --- | --- | --- |
+| Main config and OpenRouter key | `~/.kward/config.json` | Do not commit or share it. |
+| OAuth credentials | `~/.kward/auth.json`, `anthropic_auth.json`, `github_auth.json` | Written with mode `0600` when possible. |
+| Sessions and tool results | `~/.kward/sessions/` | Conversation, file/tool output, and compaction history; files use mode `0600`. |
+| Prompt history | `~/.kward/history/` | Workspace-scoped submitted prompts; files use mode `0600`. |
+| Memory | `~/.kward/memory/` | Off by default; directory `0700` and files `0600`. |
+| Telemetry logs | `~/.kward/logs/` | Off by default; redacted metadata, not intentional prompt or file-content logging. |
+| Plugins | `~/.kward/plugins/` | Trusted Ruby code, not private data storage. |
+| Hook audit log and trust records | `~/.kward/logs/`, `~/.kward/trusted_workspace_hooks.json` | Audit records use redacted metadata rather than raw event values. |
+
+Private file modes help on normal Unix-like systems but do not protect data from your own account, privileged users, backups, malware, or a compromised machine. Session exports are written to the path you choose and should be protected separately.
+
+Use these commands to inspect or remove stored credentials and context:
+
+```bash
+kward auth status
+kward auth logout
+```
+
+```text
+/session
+/memory list
+/memory forget <id>
+```
+
+See [Authentication](authentication.md), [Sessions](session-management.md), [Memory](memory.md), and [Configuration](configuration.md#Logging_and_stats) for retention and management details.
+
+## Practical habits
+
+- Keep secrets out of prompts, screenshots, shell output, plugin context, and hook messages.
+- Prefer temporary environment variables to storing short-lived API keys in config.
+- Disable web search for private work that should not trigger external requests.
+- Keep memory off unless cross-session recall is useful and appropriate.
+- Review diffs and `git status` before committing agent changes.
+- Treat generated commands as suggestions you are responsible for running.
+- Use `kward sysprompt` to inspect instructions assembled for a new conversation.
+- Run `kward doctor` and `kward hooks doctor` when configuration or trust behavior is unclear.
+
+Security here is layered: Kward supplies guardrails and explicit trust controls, while real isolation and least privilege come from the environment in which you run it.

data/doc/usage.md

@@ -78,7 +78,7 @@ For several commands, enter the embedded Kward shell:
 /shell
 ```
 
-`/shell` opens `ekwsh`, a Kward-native command mode. Kward keeps the tab bar, composer editing, and transcript rendering while each command runs through your configured shell. Built-ins such as `cd`, `pwd`, `export`, `unset`, `alias`, `clear`, `pty`, and `exit` maintain shell-mode state between commands. Plain Tab completes built-in command names, configured aliases, executables from `$PATH`, and file paths from the shell's current directory; `cd` completion suggests directories only. `ekwsh` preserves safe ANSI SGR color/style output while stripping terminal-control sequences that could corrupt the TUI, and sets conservative color-friendly environment defaults such as `CLICOLOR=1`, `COLORTERM=truecolor`, and `TERM=xterm-256color` when needed. Use `pty git log` or `/pty git log` when you intentionally want to hand the terminal to an interactive tool such as `less` or `vim`. You can set global shell env vars and aliases in `~/.kward/ekwsh.yml`; see [Configuration](configuration.md).
+`/shell` opens `ekwsh`, a Kward-native command mode that keeps the tab bar and transcript visible. It preserves state such as the current directory, environment variables, and aliases between commands. Use `pty git log` or `/pty git log` when you intentionally want to hand the terminal to an interactive tool such as `less` or `vim`. See [Embedded shell](shell.md) for built-ins, completion, configuration, ANSI handling, PTY passthrough, and limitations.
 
 ## Shell commands
 
@@ -113,7 +113,7 @@ kward --skip-config edit ~/.kward/config.json
 
 ## Interactive slash commands
 
-Slash commands run local actions in the current session. Most do not send a prompt to the model; exceptions like `/git` and `/workers` orchestrate local flows that may then trigger model work.
+Slash commands run local actions in the current session. Most do not send a prompt to the model; exceptions like `/git` orchestrate local flows that may then trigger model work.
 
 | Command | Use it when you want to... |
 | --- | --- |
@@ -125,7 +125,7 @@ Slash commands run local actions in the current session. Most do not send a prom
 | `/files` | browse project files in a nested tree and open them in the editor. |
 | `/shell` | run workspace commands in the embedded Kward shell. |
 | `/pty <command>` | hand the terminal to an interactive command such as `git log`/`less` or `vim`. |
-| `/settings` | configure prompt overlays. |
+| `/settings` | configure models, accounts, memory, interface, tools, context, personalization, and logging. |
 | `/status` | see session, model, and context status. |
 | `/new` | start a fresh session in the current tab. |
 | `/tab 2` | switch to tab 2. |
@@ -140,6 +140,7 @@ Slash commands run local actions in the current session. Most do not send a prom
 | `/session name <name>` | name or clear the current session. |
 | `/rename <name>` | rename the current session. |
 | `/clone` | copy the current session into a new branch. |
+| `/fork` | fork from an earlier prompt into a new session. |
 | `/rewind` | revisit an earlier prompt and try a different direction. |
 | `/tree` | inspect and navigate the full technical session tree. |
 | `/copy last` | copy the latest assistant answer. |
@@ -147,39 +148,21 @@ Slash commands run local actions in the current session. Most do not send a prom
 | `/export notes.md` | write the transcript to a Markdown file. |
 | `/compact [instructions]` | summarize older context so a long chat can continue. |
 | `/memory ...` | manage opt-in memory. |
+| `/skill <name>` | activate a configured skill explicitly for the current session. |
+| `/stats [range]` | summarize enabled local telemetry. |
+| `/hooks ...` | inspect, diagnose, trust, or untrust lifecycle hooks. |
+| `/scratchpad [text|markdown|ruby]` | open an unsaved editor buffer. |
 | `/redraw` | fix terminal drawing after resize or glitches. |
 | `/reload` | reload installed plugins. |
-| `/workers` | open the experimental worker pipeline (`new`, `do <task>`, or `list`). |
-| `/queue` | manage the experimental tab-backed worker queue (`add`, `list`, `open <id>`, `run`, `suspend <id>`, or `resume <id>`). |
 | `/exit` | leave Kward. |
+| `/quit` | alias for `/exit`. |
 
-Prompt templates and plugins can add more slash commands.
-
-### Experimental tab-backed worker queue
-
-Start Kward with `--experimental-workers` to try the tab-backed worker queue. The queue is an MVP for turning an existing tab/session into implementation work that can be reviewed later.
-
-Typical flow:
-
-```text
-/plan Add retry handling to webhook delivery
-/queue add
-/queue run
-/queue open <id>
-```
-
-`/queue add` stores the current tab session as a queued worker job. `/queue run` drains queued jobs one at a time. Each job continues its saved session as an implementation worker, starts only from a clean git workspace, commits any resulting changes, and then becomes `ready_for_review`. Use `/queue open <id>` to inspect the worker session, test the feature yourself, and continue the same session if a follow-up fix is needed.
-
-Current MVP limitations:
-
-- The queue is manual: run it with `/queue run` when you want it to work.
-- Jobs run sequentially and stop when one becomes `blocked` or `failed`.
-- A job will not start if the workspace is dirty; clean, commit, or stash your changes first.
-- `/queue suspend <id>` and `/queue resume <id>` provide explicit stash-based parking primitives, but automatic foreground-tool-triggered yielding is not wired yet.
-- The queue is experimental and stores metadata locally in Kward's config directory.
+Prompt templates, configured skills, and plugins can add more slash commands. Their commands appear in the interactive slash-command picker alongside built-ins.
 
 ## Prompt history
 
+The [Interactive composer](composer.md) guide covers multiline editing, slash and file completion, reasoning shortcuts, busy input, cancellation, attachments, and terminal compatibility.
+
 In interactive mode, Kward keeps prompt history per workspace under `~/.kward/history/`. Press Up/Down to recall previous prompts across restarts.
 
 Press `Ctrl-R` to search history. Type a fuzzy query in the composer, use Up/Down to choose a result from the overlay, then press Enter to place it back in the composer for editing or resubmission. Press Esc or Ctrl-C to cancel the search and restore the draft.
@@ -260,7 +243,7 @@ Important guardrails:
 
 ## Images
 
-If the active model supports images, Kward can attach image paths, Markdown image links, `file://` URLs, or image data URLs pasted into the composer. Supported formats are GIF, JPEG, PNG, and WebP, up to 20 MB per image.
+If the active model supports images, Kward can attach image paths, Markdown image links, `file://` URLs, or image data URLs pasted into the composer. Supported formats are GIF, JPEG, PNG, and WebP, up to 20 MB per image. See [Interactive composer](composer.md#Attach_images) for attachment badges, removal, and terminal previews.
 
 Use this for tasks such as:
 
@@ -270,13 +253,13 @@ This screenshot shows the broken layout. Find the likely CSS issue.
 
 ## Pan mode
 
-Pan mode starts a simple LAN web UI:
+Pan mode starts a mobile-friendly LAN web UI:
 
 ```bash
 kward --working-directory ~/code/project pan
 ```
 
-Use it only on trusted networks. It exposes the same file, shell, and web tools through a browser UI and requires credentials configured in `config.json`. See [Configuration](configuration.md).
+Use it only on trusted networks. It exposes file, shell, web, and configured extension tools through a browser UI and requires credentials configured in `config.json`. Pan saves conversations to the normal workspace session store; its session drawer can create, resume, rename, and delete sessions. Session changes are disabled while turns are active or queued. See [Pan mode](pan.md) for setup, browser workflows, security, and limitations.
 
 ## RPC backend
 

data/lib/kward/ansi.rb

@@ -262,8 +262,8 @@ module Kward
     end
 
     def inline_links(text, enabled: enabled?)
-      text.split(/(\[[^\]\n]+\]\([^)\s\n]+\))/).map do |part|
-        if (match = part.match(/\A\[([^\]\n]+)\]\(([^)\s\n]+)\)\z/))
+      text.split(/(\[[^\n\]]+\]\([^)\s]+\))/).map do |part|
+        if (match = part.match(/\A\[([^\n\]]+)\]\(([^)\s]+)\)\z/))
           "#{colorize(match[1], :cyan, enabled: enabled)} (#{colorize(match[2], :dim, enabled: enabled)})"
         else
           inline_emphasis(part, enabled: enabled)

data/lib/kward/cancellation.rb

@@ -2,9 +2,9 @@ require "thread"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Cooperative cancellation token shared by model calls, tools, and workers.
+  # Cooperative cancellation token shared by model calls, tools, and background operations.
   class Cancellation
-    # Cooperative cancellation token shared by model calls, tools, and workers.
+    # Cooperative cancellation token shared by model calls, tools, and background operations.
     class CancelledError < StandardError; end
 
     def initialize

data/lib/kward/cli/commands.rb

@@ -156,7 +156,7 @@ module Kward
           },
           "pan" => {
             usage: "kward pan",
-            description: "Start Pan mode, a minimal LAN web UI with a prompt textarea and transcript.",
+            description: "Start Pan mode, a mobile-friendly LAN web UI with persistent sessions.",
             examples: ["kward pan", "kward --working-directory ~/code/project pan"]
           },
           "rpc" => {
@@ -220,8 +220,6 @@ module Kward
             @prompt_delimited = true
             remaining.concat(arguments[(index + 1)..] || [])
             break
-          when "--experimental-workers"
-            @experimental_workers = true
           when "--skip-config"
             @skip_config = true
           when "--filter"

data/lib/kward/cli/interactive_turn.rb

@@ -7,7 +7,6 @@ module Kward
       private
 
       def run_interactive_turn(agent, input, display_input: nil)
-        stop_live_worker_view if respond_to?(:stop_live_worker_view, true)
         prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
         print_user_transcript(input, display_input: display_input) if prompt_interface?
         return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
@@ -235,22 +234,6 @@ module Kward
         ["/exit", "/quit", "/new"].include?(input.to_s.strip)
       end
 
-      def handle_busy_worker_input(input, agent, queued_inputs)
-        return false unless agent
-
-        command = input.to_s.strip
-        return false unless command == "/workers" || command.start_with?("/workers ")
-
-        _handled, replacement_agent = handle_local_slash_command(command, agent, @session_store)
-        @busy_replacement_agent = replacement_agent if replacement_agent?(replacement_agent)
-        restore_busy_input_prompt
-        true
-      rescue StandardError => e
-        runtime_output("Error: #{e.message}")
-        restore_busy_input_prompt
-        true
-      end
-
       def replacement_agent?(object)
         object.respond_to?(:conversation) && object.respond_to?(:ask)
       end