create-walle 0.10.0 → 0.10.2

package/README.md

@@ -1,44 +1,103 @@
 # create-walle
 
-**Run your agents. Keep your context.** Set up CTM's coding workspace and Wall-E's personal agent and memory in one command. Run coding sessions side by side, delegate focused tasks, review results, and recover the decisions behind them.
+**One workspace for your coding agents. Context that carries forward.**
 
-## What You Get
+Install **CTM** (Coding Task Manager) and **Wall-E** in one command. CTM runs coding agents in real terminals on your machine and gives them a browser workspace for sessions, worktrees, approvals and review. Wall-E is the personal agent alongside it, keeping project knowledge and preferences for later work.
 
-### CTM (Coding Task Manager)
+Different tasks suit different agents, so choose per session instead of committing to one up front.
 
-A web dashboard for running and managing AI coding sessions across multiple providers.
+Start at [walle.sh](https://walle.sh), or follow the [illustrated walkthrough](https://walle.sh/blog/paste-the-link/) for the same workflow with more detail and examples.
 
-- **Sessions & history** — Run Claude Code, Codex, Gemini CLI, OpenCode, Cursor Agent, Wall-E, and shell sessions with persistent scrollback. Session features vary by agent.
-- **Delegated workers** — Delegate focused implementation tasks to Claude or Codex workers, and choose the model and effort for the work.
-- **Prompts & queues** — Save prompts, organize them, and queue work for a deliberate sequence.
-- **Review & approvals** — Review code and documents, with approval workflows where the connected agent supports them. Rich review is supported for Claude, Codex, OpenCode, and Wall-E.
-- **Remote phone & tablet access** — Configure access to the running host from a phone or tablet when you need to check in away from your desk.
-- **Models** — Set a default or choose a model by task and role. Claude and Codex support lead-model switching; Wall-E has its own native model configuration.
+## Quick start
 
-### Wall-E (personal agent and memory)
+```bash
+npx create-walle install ./walle
+```
 
-Wall-E brings searchable memory, connected tools, and reusable workflows to your work. Use its chat or connect compatible coding agents through MCP to look up shared memory and prior session history.
+Install **Node.js 24.22.0 or later** and npm first. The installer manages the supported runtime for CTM and Wall-E; that runtime requires macOS 13.5 or later, or Linux with glibc 2.28 or later and kernel 4.18 or later.
 
-- **Chat** — Threaded conversations with a pinned Home thread. Chat can search memories, recall sessions, run skills, call configured MCP tools, and schedule jobs.
-- **Inbox and approvals** — One inbox for what needs your attention. Actions that leave your machine follow per-capability policies: allowed, asked for approval, or denied.
-- **Jobs** — Scheduled and one-off work (briefings, reflections, Slack inbound) with run history. Nothing runs on a schedule unless you configure it.
-- **Searchable memory** — Knowledge, entities, and timeline, available to the chat and to coding agents through MCP.
-- **Connected sources** — Optional integrations (for example Slack, with auto-replies only to an allowlist you set). They require the relevant accounts and permissions.
-- **Phone** — The same Wall-E views on the CTM phone app.
+The command copies the project, installs dependencies and starts the server. Open **http://localhost:3456** to finish setup in the browser, then authenticate the agents and providers you choose and configure any optional connections or remote device access. The npm installation is the current path on macOS and Linux; the Mac app is still being updated.
 
-## Install
+![CTM's session list with Claude Code and Codex sessions grouped under Running, Needs You and Idle, and two worker sessions nested beneath their lead.](https://walle.sh/blog/paste-the-link/img/fig-1-workspace.png)
 
-Install **Node.js 24.22.0 or later** and npm first. The installer manages the supported runtime for CTM and Wall-E.
+Screenshots show the real application with fictional `acme-ledger` data and scripted agent dialogue.
 
-The managed Node runtime requires macOS 13.5 or later, or supported Linux with glibc 2.28 or later and kernel 4.18 or later.
+## Why CTM and Wall-E
 
-```bash
-npx create-walle install ./walle
+### Choose the agent for the task
+
+Every session has its own agent choice. Run Claude Code, Codex, Gemini CLI, OpenCode, Cursor Agent, Wall-E or a shell side by side and move between them from the same workspace.
+
+The CLI, the model and the connection serving that model are separate decisions: the AI Providers area brings native agent options, direct provider connections and configured routers into one place, using your own accounts and credentials. Agents differ in what they support, so the available model-switching controls depend on the CLI you pick.
+
+### See what each agent needs
+
+Running, Needs You and Idle group the session list by what requires attention, and delegated workers appear beneath the lead session that started them.
+
+The session summary answers the next question — what is this agent trying to finish? — by bringing together the current task, recent progress and how fresh that information is. "Add jitter to webhook retries. Implementation is ready; the duplicate-delivery test still needs review." After a break, that is enough to decide which session to open.
+
+![CTM's session summary for the lead session, showing the current task, recent progress and freshness beside the session list.](https://walle.sh/blog/paste-the-link/img/fig-3-summary.png)
+
+### Coordinate worktrees, changes and workers
+
+Start a session with its own **worktree** and CTM creates the branch and working directory and links them to the session, so an investigation and a test run can proceed in separate checkouts of the same repository.
+
+The worktree panel shows **Ready to merge**, **Behind main** and **Dirty** states, uncommitted changes and branch drift, along with the sessions linked to each checkout. Changed-file and commit indicators connect a conversation to the code it touched, and describe the working tree rather than who wrote each line: sessions that share a checkout share that Git state.
+
+For focused work, delegate to Claude or Codex workers, choose the model and effort, and inspect the result beneath the lead. Tasks that start servers still need separate ports and data directories. See the [delegation walkthrough](https://walle.sh/blog/delegation-guide/) for setup and an example task.
+
+### Let routine permissions move forward
+
+Repeated prompts interrupt work, so CTM applies rules for decisions you have already made, such as allowing a particular test command in the project you are working on.
+
+For requests that need more judgment, an approval flow can check the request against the task with a scoped AI review. Requests held for you stay visible as Needs You, with the reason available to inspect, and the Permissions panel shows the policy behind each decision so you can change or disable a rule. These settings govern CTM's automatic approval; the selected CLI also keeps its own permission controls.
+
+### Reuse the knowledge behind your code
+
+Conversations hold more than the final patch: approaches that failed, constraints that mattered and the reasoning behind a decision. CTM records prompts, answers and tool calls as structured turns you can read and search by phrase, file reference or session link.
+
+With Wall-E connected through MCP, paste the earlier session's URL into a new session and ask the agent to read that session, or let it search Wall-E:
+
+```text
+Search Wall-E for the earlier retry investigation in acme-ledger.
+Find the decision about the 30-second cap and use it when reviewing this diff.
 ```
 
-This copies the project, installs dependencies, and starts the server. Open **http://localhost:3456** to finish setup in the browser, then authenticate the agents and providers you choose and configure any optional integrations or remote device access.
+![A recorded session shown as prompts, answers and tool calls, including the reasoning behind the 30-second retry cap.](https://walle.sh/blog/paste-the-link/img/fig-6-conversation.png)
 
-Use the npm installation on macOS and Linux. The Mac app is being updated for this release.
+The layers do different jobs. Recorded conversations preserve the discussion as it happened; search and selected context retrieval fit the parts that matter into a limited model context; durable memory keeps the facts, entities and preferences worth keeping. Retrieval is not automatic — the agent has to look, and it depends on which history and tools are connected — so check retrieved context against the current branch before relying on it.
+
+### Keep work available without keeping everything running
+
+CTM can park an eligible inactive session to stop its process and free resources while the recorded conversation stays in the workspace, then bring it back when you need it.
+
+A shared MCP gateway lets eligible tool servers reuse one process across sessions; tools needing session-specific state keep separate instances.
+
+### Use more than one machine
+
+Pair another machine running CTM and its sessions join the same list, tagged by machine. Pick the machine when you start a session, open and type into it from the hub's browser, and sign that machine's coding agents in from the Machines page, on desktop or phone.
+
+### Review changes in one place
+
+The Review page moves between rendered HTML or Markdown, source files and diffs, and new files appear before Git tracks them. Comments collect into one message for the session responsible for the change, keeping feedback beside the files that produced it.
+
+For a small correction, open the current file in File or Source view, choose **Edit**, change the text and save: the working file changes and the diff reflects it, while historical revisions and binary files stay read-only.
+
+### A personal agent with context about you
+
+Wall-E keeps its own chat threads, an inbox for what needs your attention, and scheduled or one-off jobs with run history. Schedules run only when you configure them.
+
+Saved preferences and project knowledge carry into later work. Store `Show the failure and test evidence before proposing a rollout`, for example, and a later review brief can start from it instead of restating the point.
+
+Optional connected sources such as Slack need their own accounts and permissions, and Slack auto-replies stay inside the allowlist you configure.
+
+## Try it on one project
+
+This example is fictional and the dialogue is scripted; it illustrates the workflow rather than measuring an agent. A failed webhook delivery in `acme-ledger` needs better retry handling, so Claude Code investigates the retry behaviour in one session while Codex works on tests in a separate worktree.
+
+A scoped test command proceeds under an approval rule, while a request to write outside the test transaction is held as Needs You until you release it.
+
+Days later, a review session needs the reasoning behind the 30-second retry cap recorded during the earlier investigation. With Wall-E connected through MCP, paste that session's URL into the new session, or ask Wall-E to find it, and the agent works from the original reasoning while you read the design document and patch together.
 
 ## Commands
 
@@ -61,26 +120,15 @@ If an older installation asks for its existing Node executable during an update,
 npx create-walle update --installed-node /absolute/path/to/node
 ```
 
-## Setup
-
-On first launch, the browser setup page guides you through:
-
-1. **Browser setup** — finish the local installation in the dashboard
-2. **Providers** — authenticate the coding agents and model providers you use
-3. **Integrations** — optionally connect available sources with their required permissions
-4. **Remote phone and tablet access** — optionally configure access to the running host
-
-## Custom Port
+Run on another port with `CTM_PORT`. Wall-E runs on `CTM_PORT + 1` — 5001 in this example:
 
 ```bash
 CTM_PORT=5000 npx create-walle install ./walle
 ```
 
-Wall-E runs on `CTM_PORT + 1` (e.g., 5001).
-
 ## Hosting and storage
 
-The dashboard and Wall-E memory run on the host where you install them. SQLite is the default storage. Coding providers and optional integrations may contact their own services and require their own accounts or permissions. Use backups and exports to preserve or move local data; do not treat file-sync services as database replication.
+The dashboard and Wall-E memory run on the host where you install them, and SQLite is the default storage. Coding providers and optional integrations may contact their own services and require their own accounts or permissions. Use backups and exports to preserve or move local data; do not treat file-sync services as database replication.
 
 | Component | Default Port | What it does |
 |-----------|-------------|--------------|
@@ -89,13 +137,12 @@ The dashboard and Wall-E memory run on the host where you install them. SQLite i
 
 ## Updates and recovery
 
-Run `npx create-walle update` from your installation directory. Updates verify compatibility, back up existing databases, and check the services before reporting success. The command reports backup and recovery information if attention is needed.
-
-Keep your backups available, and resolve an update error before retrying.
+Run `npx create-walle update` from your installation directory. Updates verify compatibility, back up existing databases and check the services before reporting success, and report backup and recovery information if attention is needed. Keep your backups available, and resolve an update error before retrying.
 
 ## Links
 
 - [Homepage](https://walle.sh)
+- [Walkthrough](https://walle.sh/blog/paste-the-link/)
 
 ## License
 

package/lib/owner-write-safety.js

@@ -0,0 +1,135 @@
+'use strict';
+
+// Shared "no other account can write through this path" predicate for paths CTM and
+// Wall-E did not create themselves (a Codex sessions root, an enrolled provider root,
+// a data directory handed in by an installer, ~/.walle/data).
+//
+// The rule is Debian OpenSSH's `user-group-modes.patch` rule, adapted: world write is
+// never acceptable, and group write is acceptable ONLY when the owning group is the
+// current user's own one-member private group (the user-private-group scheme that
+// `pam_umask(8)` sets up as umask 002 on every Debian/Ubuntu/Fedora login). On a shared
+// group (`staff` on macOS, `users` on many hosts) the check is exactly as strict as
+// before.
+//
+// Accepted gap (same as the Debian patch): a group password held in `/etc/gshadow`
+// (usable through `newgrp`) and accounts that exist only in NSS (LDAP/SSSD) are invisible
+// to the `/etc/group` + `/etc/passwd` parse this module performs, so a gid that cannot be
+// proven from the local files is refused — the check always fails closed.
+
+const fs = require('node:fs');
+const os = require('node:os');
+
+const MAX_DB_BYTES = 1024 * 1024;
+const GROUP_PATH = '/etc/group';
+const PASSWD_PATH = '/etc/passwd';
+
+/** Default reader: one bounded read (≤ MAX_DB_BYTES), the fd always closed. */
+function _readBoundedFile(filePath) {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const stat = fs.fstatSync(fd);
+    if (Number(stat.size) > MAX_DB_BYTES) {
+      throw new Error(`${filePath} is larger than ${MAX_DB_BYTES} bytes`);
+    }
+    return fs.readFileSync(fd, 'utf8');
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// A seam explicitly passed as `null` means "this platform has no such call" (the Windows
+// shape); `undefined` means "use the process default".
+function _seam(deps, name, fallback) {
+  if (deps[name] === null) return null;
+  if (typeof deps[name] === 'function') return deps[name];
+  return typeof fallback === 'function' ? fallback : null;
+}
+
+// Split a local-database file into usable lines: blanks and `#` comments are skipped, and a
+// `+`/`-` NIS compat line makes the whole file unprovable (return null).
+function _usableLines(text) {
+  const lines = [];
+  for (const raw of String(text).split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    if (line.startsWith('+') || line.startsWith('-')) return null;
+    lines.push(line);
+  }
+  return lines;
+}
+
+function _numericField(value) {
+  return /^\d+$/.test(value || '') ? Number(value) : null;
+}
+
+/** D-2: `gid` is the current user's one-member private group. Any doubt ⇒ false. */
+function isUserPrivateGroup(gid, deps = {}) {
+  try {
+    const getuid = _seam(deps, 'getuid', process.getuid);
+    const getgid = _seam(deps, 'getgid', process.getgid);
+    if (typeof getuid !== 'function' || typeof getgid !== 'function') return false;
+    const targetGid = _numericField(String(gid));
+    if (targetGid === null) return false;
+    if (Number(getgid()) !== targetGid) return false;
+    const uid = Number(getuid());
+    const usernameFn = _seam(deps, 'username', () => os.userInfo().username);
+    if (typeof usernameFn !== 'function') return false;
+    const username = String(usernameFn() || '');
+    if (!username) return false;
+    const readFile = _seam(deps, 'readFile', _readBoundedFile);
+    if (typeof readFile !== 'function') return false;
+
+    // (b) /etc/group: exactly one line with this gid, named after the login, members ⊆ {login}.
+    const groupLines = _usableLines(readFile(GROUP_PATH));
+    if (!groupLines) return false;
+    const groupEntries = [];
+    for (const line of groupLines) {
+      const fields = line.split(':');
+      const lineGid = fields.length >= 3 ? _numericField(fields[2]) : null;
+      if (lineGid === null || lineGid !== targetGid) continue;
+      if (fields.length !== 4) return false;
+      groupEntries.push({ name: fields[0], members: fields[3].split(',').map(m => m.trim()).filter(Boolean) });
+    }
+    if (groupEntries.length !== 1) return false;
+    const group = groupEntries[0];
+    if (group.name !== username) return false;
+    if (group.members.length > 1) return false;
+    if (group.members.length === 1 && group.members[0] !== username) return false;
+
+    // (c) /etc/passwd: every account whose primary gid is this gid is this uid, and one exists.
+    const passwdLines = _usableLines(readFile(PASSWD_PATH));
+    if (!passwdLines) return false;
+    let primaryAccounts = 0;
+    for (const line of passwdLines) {
+      const fields = line.split(':');
+      const lineGid = fields.length >= 4 ? _numericField(fields[3]) : null;
+      if (lineGid === null || lineGid !== targetGid) continue;
+      if (fields.length !== 7) return false;
+      primaryAccounts += 1;
+      const lineUid = _numericField(fields[2]);
+      if (lineUid === null || lineUid !== uid) return false;
+    }
+    if (primaryAccounts === 0) return false;
+    return true;
+  } catch {
+    /* expected: any unreadable or unparsable account database fails closed (D-3) */
+    return false;
+  }
+}
+
+/**
+ * True iff no account other than the current user can write through `stat`'s permission bits.
+ * Accepts fs.Stats (Number) and fs.BigIntStats (bigint) alike.
+ * @param {{ mode: number|bigint, gid: number|bigint }} stat
+ * @param {{ readFile?: (p: string) => string, getuid?: () => number, getgid?: () => number,
+ *           username?: () => string }} [deps]  test seams
+ * @returns {boolean}
+ */
+function isWritableOnlyByOwner(stat, deps = {}) {
+  const mode = Number(stat.mode);
+  if ((mode & 0o002) !== 0) return false; // world write is never acceptable
+  if ((mode & 0o020) === 0) return true; // no group write: no file is read
+  return isUserPrivateGroup(Number(stat.gid), deps);
+}
+
+module.exports = { isWritableOnlyByOwner, isUserPrivateGroup, MAX_DB_BYTES, _readBoundedFile };

package/lib/public-runtime.js

@@ -36,6 +36,11 @@ const os = require('node:os');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
 
+// The ONE "no other account can write through this path" predicate, shared with CTM and Wall-E. It
+// is a relative SIBLING require on purpose: the mirror is byte-identical, so the same bytes resolve it
+// from `shared/` and from `create-walle/lib/`.
+const { isWritableOnlyByOwner } = require('./owner-write-safety');
+
 const {
   parseReleaseRuntimePolicy,
   releaseRuntimeArchive,
@@ -187,10 +192,13 @@ function publicRuntimeNpmEnv(nodeBin) {
 
 // ── the one cache-directory admission ───────────────────────────────────────────────────────────
 /**
- * Assert that `dir` is a REAL directory (never a link), owned by the current user, and not
- * group/other writable. Ancestors ABOVE the owned cache boundary are deliberately not inspected: a
- * system path or a sticky ancestor is not this installer's ownership requirement, and pretending
- * otherwise would refuse every legitimate `~/.walle` under a shared parent.
+ * Assert that `dir` is a REAL directory (never a link), owned by the current user, and writable only
+ * by its owner (a user-private group counts as the owner: world write is never acceptable, and group
+ * write is acceptable only when the owning group is the user's own one-member private group, the
+ * umask-002 scheme of a Debian/Ubuntu/Fedora login). Ancestors ABOVE the owned cache boundary are
+ * deliberately not inspected: a system path or a sticky ancestor is not this installer's ownership
+ * requirement, and pretending otherwise would refuse every legitimate `~/.walle` under a shared
+ * parent.
  */
 function assertOwnedCacheDirectory(fsOps, dir, phase) {
   let stat;
@@ -202,7 +210,7 @@ function assertOwnedCacheDirectory(fsOps, dir, phase) {
   if (stat.isSymbolicLink() || !stat.isDirectory()) {
     throw refuse(phase, 'public runtime cache directory is not a real directory');
   }
-  if ((Number(stat.mode) & 0o022) !== 0) {
+  if (!isWritableOnlyByOwner(stat)) {
     throw refuse(phase, 'public runtime cache directory is group or other writable');
   }
   if (typeof process.getuid === 'function' && Number(stat.uid) !== process.getuid()) {

package/lib/release-schema.json

@@ -9,7 +9,7 @@
         21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
         31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
         41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
-        51, 52, 53, 54, 55
+        51, 52, 53, 54, 55, 56
       ]
     },
     "walle": {
@@ -24,7 +24,8 @@
         61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
         71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
         81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
-        97, 98, 99
+        97, 98, 99, 100,
+        101
       ]
     }
   }

package/lib/runtime-closure-policy.json

@@ -39,7 +39,9 @@
     "coding-task-manager/bin/seam-replay.js",
     "coding-task-manager/bin/session-access-lint.js",
     "coding-task-manager/bin/session-create-fanout-lint.js",
+    "coding-task-manager/bin/session-host-kill-lint.js",
     "coding-task-manager/bin/session-runtime-evidence-lint.js",
+    "coding-task-manager/bin/startup-pointer-writer-lint.js",
     "coding-task-manager/bin/status-verdict-lint.js",
     "coding-task-manager/bin/term-container-band-lint.js",
     "coding-task-manager/bin/terminal-write-lint.js",
@@ -1785,12 +1787,12 @@
     "coding-task-manager/lib/walle-deps-repair.js": "be85620d08795ea0fe9539820416d5cc50b654519abddab0811907fa3fe93a7f",
     "coding-task-manager/lib/walle-mcp-auto-config.js": "b978e9b15d9dac8179dde0feb5357c14957f7b4e36dab7e6779587bcde8faeff",
     "coding-task-manager/lib/walle-native-health.js": "9fdf7f17eb77837aac4ea16140a6f4e5a97d7a568945da30f29b9a7541c3d967",
-    "coding-task-manager/lib/walle-supervisor.js": "04b924f16c9bd001ed505347202dbec2876b57fc427a32c93d23586530181f83",
+    "coding-task-manager/lib/walle-supervisor.js": "1eb9971a2ede9735e595952404f467f6775ad9f99545137faad86e3c6fb38af9",
     "coding-task-manager/public/js/client-health-worker.js": "07e300113ee749ac7a6adaaa1461502d1562087af395b6c89cf1b885f1f5e00e",
     "coding-task-manager/public/js/image-normalize-worker.js": "37cb0758bddcf10c66060fae52088c1a842409f30e919988e789cfea7d05e2be",
-    "coding-task-manager/public/m/app.js": "483f777f57efd28d7796713c33df48ffba47e5bfb50597b446a37b961f53d585",
-    "coding-task-manager/server.js": "24a9871d0d974aed567a1f15e563fae1dc055484822b24b0f58146bcedb90d34",
-    "scripts/conversation-storage-v2-migration.js": "80c66e41c9fb9b1d756fe21be17f3b07c6a65389712887043a86341fbf6a6879",
+    "coding-task-manager/public/m/app.js": "8e4662e21c409003a2d61de3c044410055176b574d787b34f7ede776b62a7003",
+    "coding-task-manager/server.js": "347578d2cab77abedb122df048f60415d8d392ed4caf4bd32fc92e91a9aa3f9a",
+    "scripts/conversation-storage-v2-migration.js": "f2620ba24893c4d2ec6c594428ddb41dc098da38b4066f1df25fb87abbfaebfa",
     "shared/storage/schema-port.js": "e41cec8c075a6167fba2efd0177d9e20a11c0cd49ae176aaf36d5b9257409e67",
     "shared/storage/schema-sync.js": "7ca080e44e35e8178a0f74317023881f920ae75bde4f7431702ce1f9fa4a1d03",
     "wall-e/adapters/chatgpt.js": "8c0fa31ae65ed5c10776e50a1a26c131bc62cb1aa3d88eb4617e7b83b43789d9",
@@ -1815,7 +1817,7 @@
     "wall-e/channels/telegram-channel.plugin.json": "696d601804c91387824e80263b784f76ce5cad4b8ae81277d4b4030c1710e437",
     "wall-e/coding/action-memory-store.js": "5c7a467e9cb3e08dbfc7b27dec6724f8ea6eedac29d2c40f6c6bda3a4263a0c0",
     "wall-e/coding/hooks/plugin-loader.js": "f1ca5e032e64f68447af9317ad75821a5152ca25fad09ce4ac23e8cd39ac891c",
-    "wall-e/coding/host-capabilities.js": "1f320231fdf9ff078ec873255129168475ab5570b8864676836f678ea2ed70d4",
+    "wall-e/coding/host-capabilities.js": "9dafbc2a76ba5e00911219316be7b5f57ca26db278275606ea7fad61631370bd",
     "wall-e/coding/prompt-capabilities.js": "e230871618f9f43e6c7a3a7f98ebda2e77bb522018c6d4c0b1e29d0b08926708",
     "wall-e/coding/user-hooks.js": "4a0d9b82894f6a23c126b09d8f1feca3aa894b171a9c815e11389b2d96b1e018",
     "wall-e/lib/boot-preflight.js": "4415c7c3dae9add70bebdd29d75ee68d09097c53732438d35c3cd1ae0de5f01e",

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "create-walle",
-  "version": "0.10.0",
-  "description": "CTM + Wall-E — AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini, Aider, OpenCode, and more, plus prompt editor, task queue, remote phone and tablet access, code/doc review, and an agent that learns from Slack, email & calendar.",
+  "version": "0.10.2",
+  "description": "CTM + Wall-E: one workspace for coding agents, worktrees and review, with shared session context and a personal agent.",
+  "homepage": "https://walle.sh",
   "bin": {
     "create-walle": "bin/create-walle.js"
   },
@@ -32,8 +33,13 @@
     "task-manager",
     "wall-e",
     "ai",
-    "digital-twin",
     "claude",
-    "personal-assistant"
+    "personal-assistant",
+    "coding-task-manager",
+    "coding-agents",
+    "codex",
+    "worktrees",
+    "mcp",
+    "memory"
   ]
 }

package/template/bin/deps-doctor.js

@@ -248,7 +248,7 @@ function checkDeps(pkgDir, opts = {}) {
 }
 
 // The package dirs a gate depends on, relative to a checkout root.
-const TREE_SUBS = ['', 'coding-task-manager', 'wall-e', 'shared', 'create-walle'];
+const TREE_SUBS = ['', 'coding-task-manager', 'wall-e', 'shared', 'create-walle', 'ctm-relay'];
 
 // `npm --prefix <owner> install --no-save`: <owner> is the checkout that really
 // holds node_modules (a gate tree borrows it through a symlink). Never

package/template/bin/node-bin.sh

@@ -56,6 +56,17 @@ bootstrap_candidates() {
   for cache_node in "$HOME"/.walle/runtimes/*/*/runtime/bin/node; do
     if [ -e "$cache_node" ]; then printf '%s\n' "$cache_node"; fi
   done
+  # Linux boxes (e.g. DGX Spark) install Node via nvm/fnm, so with a non-interactive ssh session
+  # that never sources the manager there is no `node` on PATH and none of the macOS Wall-E paths
+  # above exist. Any version found here only RUNS the fixed helper; the pin is still enforced by the
+  # candidate ladder below, so a version-globbed bootstrap can never select a mismatched ABI.
+  local manager_node
+  for manager_node in \
+    "$HOME"/.nvm/versions/node/*/bin/node \
+    "$HOME"/.local/share/fnm/node-versions/*/installation/bin/node \
+    "$HOME"/.fnm/node-versions/*/installation/bin/node; do
+    if [ -e "$manager_node" ]; then printf '%s\n' "$manager_node"; fi
+  done
   return 0
 }
 

package/template/coding-task-manager/api-prompts.js

@@ -5,8 +5,11 @@ const os = require('os');
 const { isMainThread } = require('node:worker_threads');
 const { classifySqliteError } = require('./lib/sqlite-driver');
 const { reportRouteError, routeError, tagRouteValidationError } = require('./lib/route-error');
+const { terminalDraftHttpStatus: _terminalDraftStatus } = require('./lib/terminal-draft-http-status');
 // WP-2 (§9): the delivery-completion request projection lives with the image-protocol owners.
 const { buildDraftDeliveryCompletionRequest } = require('./lib/terminal-draft-publication-api');
+const remoteSessionForward = require('./lib/remote-session-forward'); // WP-3 (§6/D-1..D-3): an image-draft request for a MIRROR id is answered by the owning box
+const { overlayQueueDraftStatuses } = require('./lib/queue-draft-status-overlay'); // R-1 (§5): the queue-draft GET overlays durable engine status, never writes
 const db = require('./db-owner-client');
 const queueEngine = require('./queue-engine');
 const harvest = require('./prompt-harvest');
@@ -820,7 +823,10 @@ function handlePromptApi(req, res, url, deps = {}) {
   // --- Images ---
   if (p === '/api/images/upload' && m === 'POST') return handleUploadImage(req, res, url);
   if (/^\/api\/sessions\/[^/]+\/image-drafts(?:\/[^/]+(?:\/content|\/delivery|\/freeze|\/submit|\/retry)?)?$/.test(p)) {
-    return handleTerminalImageDraft(req, res, url);
+    const route = _terminalDraftRoute(url); // WP-3: a MIRROR id is answered by the box; a local id takes the same-tick path
+    if (!route || !remoteSessionForward.isMirrorSessionRequest(req, url, route.sessionId)) return handleTerminalImageDraft(req, res, url);
+    return remoteSessionForward.maybeForwardSessionRequest(req, res, url, route.sessionId)
+      .then((forwarded) => (forwarded ? undefined : handleTerminalImageDraft(req, res, url)));
   }
   if (p === '/api/images/ingest-path' && m === 'POST') return handleIngestImagePath(req, res);
   if (p === '/api/mobile/attachments/upload' && m === 'POST') return handleUploadMobileAttachment(req, res, url);
@@ -1466,26 +1472,6 @@ function _terminalDraftRoute(url) {
   } catch { return null; }
 }
 
-function _terminalDraftStatus(error) {
-  if (!error) return 500;
-  if (error.code === 'CTM_MAIN_DB_REQUEST_FORBIDDEN') return 501;
-  if (error.code === 'CTM_OWNERSHIP_UNAVAILABLE' || error.code === 'CTM_DB_OWNER_UNAVAILABLE' ||
-      error.code === 'CTM_MEDIA_JOURNAL_UNAVAILABLE') return 503;
-  if (error.code === 'CTM_DRAFT_NOT_FOUND' || error.code === 'CTM_DRAFT_SESSION_NOT_FOUND') return 404;
-  if (error.code === 'CTM_SESSION_OWNER_MISMATCH') return 409;
-  if (error.code === 'CTM_DRAFT_REVISION_CONFLICT') return 412;
-  // CTM_IMAGE_IDEMPOTENCY_CONFLICT is the legacy/mobile lanes' equivalent of the draft
-  // lane's idempotency conflict (media-store requestId dedupe) — same 409 semantic
-  // (WP-9 lane-parity: distinguishable from a malformed 400 without inspecting `code`).
-  if (error.code === 'CTM_DRAFT_IDEMPOTENCY_CONFLICT' || error.code === 'CTM_IMAGE_IDEMPOTENCY_CONFLICT' ||
-      error.code === 'CTM_DRAFT_DELIVERY_SUPERSEDED' ||
-      error.code === 'CTM_DRAFT_DELIVERY_STATE') return 409;
-  if (error.code === 'CTM_DRAFT_FROZEN' || error.code === 'CTM_DRAFT_REQUEST_CANCELLED') return 409;
-  if (error.code === 'CTM_DRAFT_IMAGE_INVALID' || error.code === 'CTM_DRAFT_SESSION_REQUIRED' ||
-      error.code === 'CTM_DRAFT_IDENTITY_INVALID' || error.code === 'CTM_DRAFT_DELIVERY_OUTCOME_INVALID') return 400;
-  return 500;
-}
-
 function _imageFailureStatus(error, fallbackStatus = 500) {
   const terminalStatus = _terminalDraftStatus(error);
   if (terminalStatus !== 500 || fallbackStatus === 500) return terminalStatus;
@@ -6891,7 +6877,9 @@ function mergeQueueDraftItemsByStatusTimestamp(existingItems, incomingItems) {
 function handleGetQueueDraft(req, res, sessionId) {
   const key = 'queue_draft_' + sessionId;
   const draft = _getPublishedSetting(key, { items: [], mode: 'manual' });
-  jsonResponse(res, 200, draft);
+  // R-1 (§5): read-only projection. The engine is the authority for an item's
+  // durable status; the stored snapshot is never rewritten on this route.
+  jsonResponse(res, 200, overlayQueueDraftStatuses(draft, queueEngine.getItemStatusMap(sessionId)));
 }
 
 async function handleSaveQueueDraft(req, res, sessionId) {