create-walle 0.10.1 → 0.10.2

package/template/coding-task-manager/lib/read-pool-op-registry.js

@@ -140,8 +140,10 @@ const READ_POOL_OP_DECLARATIONS = {
     maxInputBytes: 8 * 1024,
     maxOutputBytes: REMOTE_COMMAND_RECEIPT_WIRE_MAX_BYTES + 16 * 1024,
   },
+  // Accepted prompt delivery needs this bounded row read in reserved interactive capacity.
+  // Background scans must not hold delivery behind service admission.
   getAcceptedRootJobText: {
-    class: 'service', expectedMs: 1000, maxRows: 1,
+    class: 'interactive', expectedMs: 1000, maxRows: 1,
     maxInputBytes: 8 * 1024, maxOutputBytes: 16 * 1024, resumable: false,
   },
   hasLegacyRemoteCommandPresence: {
@@ -372,6 +374,13 @@ const READ_POOL_OP_DECLARATIONS = {
   startupTasksScan: {
     class: 'service', expectedMs: 250, maxRows: 200, maxOutputBytes: 512 * 1024,
   },
+  // WP-6 (session-name-agent-title-precedence §§6/8): the one-shot agent-title backfill's read
+  // half — up to 20 candidate rows plus a ≤64 KiB positional tail read per row. Background
+  // maintenance (service class, not user-visible): it is dispatched by the boot job, never by a
+  // keystroke, and 20 rows × a 64 KiB window is the whole budget of one task.
+  backfillAgentTitles: {
+    class: 'service', expectedMs: 5000, maxRows: 20, maxOutputBytes: 2 * 1024 * 1024,
+  },
   drain: { class: 'interactive', expectedMs: 25 },
   // WP-5 (composer-typing-freeze doc §13): the 15s walle-permission-reconcile tick's
   // two plain reads (approval_decisions forwarding rows + non-terminal pty:

package/template/coding-task-manager/lib/recent-catalog-query.js

@@ -110,6 +110,29 @@ function mapAgent(agent, parentRow) {
   };
 }
 
+/**
+ * WP-3 (remote-hub-followups D-10): the machine tag for a recent row — the row's EXECUTION host
+ * (falling back to its current owner) when that id names a REGISTERED machine and is not this host
+ * or its lineage (`machineTags.localIds`). `machineHealth` is deliberately not stamped on recents:
+ * they are history (D-10).
+ *
+ * `machineTags` is main's cheap registry snapshot (`{machines, localIds}`), passed through the
+ * read-pool op input. With NO machines the result is null, so the row gains no key at all and the
+ * response stays byte-identical to the pre-WP-3 projection (AC-3a).
+ */
+function machineFactsForRecentRow(row, options = {}) {
+  const tags = options && options.machineTags;
+  const machines = Array.isArray(tags?.machines) ? tags.machines : null;
+  if (!machines || machines.length === 0) return null;
+  const id = String(row?.execution_host_instance_id || row?.current_owner_instance_id || '').trim();
+  if (!id) return null;
+  const localIds = Array.isArray(tags.localIds) ? tags.localIds : [];
+  if (localIds.includes(id)) return null;
+  const machine = machines.find((candidate) => candidate && String(candidate.instanceId || '') === id);
+  if (!machine) return null;
+  return { machine: id, machineName: String(machine.displayName || '') };
+}
+
 function mapRecentSessionRow(row, options = {}) {
   const hostname = String(options.hostname || '');
   const agentSessions = (Array.isArray(row?.agent_sessions) ? row.agent_sessions : [])
@@ -179,6 +202,8 @@ function mapRecentSessionRow(row, options = {}) {
     parentAgentSessionId: row.parent_agent_session_id || primary?.parentAgentSessionId || '',
     agentNickname: row.agent_nickname || primary?.agentNickname || '',
     agentRole: row.agent_role || primary?.agentRole || '',
+    // WP-3 (D-10): the machine tag, only when this row's execution host is a registered box.
+    ...(machineFactsForRecentRow(row, options) || {}),
   };
   return sessionEmpty.applyRecentSessionEmptyState(session, row);
 }
@@ -228,6 +253,7 @@ function queryRecentCatalogSessions(db, options = {}) {
 module.exports = {
   isProviderChildAgentRow,
   isProviderChildSessionRow,
+  machineFactsForRecentRow,
   mapRecentSessionRow,
   mapRecentSessionRows,
   mapRecentSessionRowsCooperatively,

package/template/coding-task-manager/lib/recent-session-catalog-response.js

@@ -16,6 +16,9 @@ const RECENT_SESSION_FIELDS = Object.freeze([
   'jsonlPath', 'sourcePath', 'desktopCacheOnly', 'provisionalId', 'agentSessionId',
   'agentSessionIds', 'threadSource', 'parentAgentSessionId', 'parentThreadId',
   'agentNickname', 'agentRole',
+  // WP-3 (remote-hub-followups S-13/D-10): the box tag must survive the persisted cold-boot
+  // snapshot, or a warm restart would strip it and a box row would render as local.
+  'machine', 'machineName',
 ]);
 const RECENT_AGENT_FIELDS = Object.freeze([
   'agentSessionId', 'providerResumeId', 'ctmSessionId', 'provider', 'agent',
@@ -83,6 +86,12 @@ function activityMs(session) {
   return Number.isFinite(parsed) ? parsed : 0;
 }
 
+// S-5 (remote-machine-hub-sessions-2026-10-22.html §9): this function OVERWRITES every row's
+// `hostname` with THIS host's hostname. That is display metadata for a local (pre-multi-machine)
+// catalog and it stays that way — but it means a row's `hostname` says NOTHING about where the
+// session lives. Machine labeling MUST therefore use the machine's minted instance id
+// (`machine`/`machineName`, filled by lib/remote-machine-catalog.js) and NEVER a hostname: any
+// hostname-based label would silently claim a box's session is on this host (D-3).
 function buildRecentSessionCatalogResponse(input = {}) {
   const shape = normalizeRecentCatalogShape(input.query);
   const hostname = String(input.hostname || '');

package/template/coding-task-manager/lib/remote-command-context.js

@@ -2,6 +2,7 @@
 
 const crypto = require('crypto');
 const { getResolvedEnvCredentialIdentity } = require('./auth-context');
+const { hasPeerControlScope } = require('./auth-rules');
 const { isVerifiedOwner } = require('./owner-policy');
 
 function isValidIdentity(value) {
@@ -38,6 +39,17 @@ function deriveRemoteCommandNamespace(auth, actualInstanceId) {
     if (!digest || !/^[a-f0-9]{64}$/.test(digest)) return null;
     principalTuple = ['env', digest];
     principalKind = 'env';
+  } else if (auth.source === 'sync-peer-token' && hasPeerControlScope(auth)) {
+    // WP-3b (docs/remote-machine-hub-sessions-2026-10-22.html §6.2/D-7): a relayed root prompt
+    // arrives on the sync peer bearer, which is the only credential carrying the peer-control
+    // scope (lib/auth-rules.js). The peer's own identity is its `X-CTM-Sync-Peer` id
+    // (`peerInstanceId`); when the single-token form names no peer, the token's log hash is the
+    // only distinguishing label. Neither → no principal, no namespace.
+    const peerInstanceId = typeof auth.peerInstanceId === 'string' ? auth.peerInstanceId : '';
+    const tokenHint = typeof auth.tokenHashPrefix === 'string' ? auth.tokenHashPrefix : '';
+    if (!peerInstanceId && !tokenHint) return null;
+    principalTuple = ['peer', peerInstanceId || `token:${tokenHint}`];
+    principalKind = 'peer';
   } else if (auth.source === 'loopback' && auth.isLoopback === true) {
     principalTuple = ['local', 'loopback'];
     principalKind = 'local';

package/template/coding-task-manager/lib/remote-command-runtime.js

@@ -5,7 +5,7 @@ const promptAdmissionTrace = require('./prompt-admission-trace');
 const { AsyncLocalStorage } = require('node:async_hooks');
 const remoteRelayProtocol = require('./remote-relay-protocol');
 const { createRemoteCommandCoordinator, projectIdentity } = require('./remote-command-coordinator');
-const { authorize: authorizeByRule, getHttpAuthRule, getWsAuthRule } = require('./auth-rules');
+const { authorize: authorizeByRule, getHttpAuthRule, getWsAuthRule, hasPeerControlScope } = require('./auth-rules');
 const { deriveRemoteCommandNamespace } = require('./remote-command-context');
 const { getDeviceCredentialProof } = require('./ws-device-credential-proof');
 const instanceIdentityAccess = require('./instance-identity-access');
@@ -335,6 +335,18 @@ function createRemoteCommandRuntime({
           || auth.source !== 'env-scoped-token' || auth.transport !== 'remote') return deny();
       const decision = authorizeByRule(auth, getWsAuthRule('submit-prompt'), { enforceStepUp: true });
       if (!decision.ok) return deny(decision.code, decision.status);
+    } else if (auth.source === 'sync-peer-token' && auth.authenticated === true && hasPeerControlScope(auth)) {
+      // WP-3b (docs/remote-machine-hub-sessions-2026-10-22.html §6.2/D-7, AC-3a): the hub relays a
+      // box-owned session's `submit-prompt` over the sync peer bearer (auth source
+      // `sync-peer-token`, scopes {'sync','peer-control'}; lib/auth-context.js resolveSyncPeerToken).
+      // The peer credential is env-configured (CTM_SYNC_PEER_TOKEN / CTM_SYNC_PEER_TOKENS) with no
+      // revocation store to re-read, so freshness is exactly the shared `guard()` — this socket is
+      // still open, `client.auth` is still this same object, and the instance id is unchanged.
+      // Peer-control rows short-circuit step-up by design (authorize(), lib/auth-rules.js), so this
+      // mirrors the env/loopback branches: authorize with step-up ENFORCED and let the flag decide.
+      if (!guard()) return deny();
+      const decision = authorizeByRule(auth, getWsAuthRule('submit-prompt'), { enforceStepUp: true });
+      if (!decision.ok) return deny(decision.code, decision.status);
     } else if (auth.authenticated === true && auth.source === 'loopback' && auth.isLoopback === true) {
       let isLocal = false;
       try { isLocal = typeof validateLoopbackSocket === 'function' && validateLoopbackSocket(client) === true; }