@staix/agent-hub 0.21.0 → 0.23.0

package/src/adapters/acp.ts

@@ -12,6 +12,8 @@ import { BasePeer } from "../hub/peers.ts";
 import { peerChildEnv, stopOwnedProcess, trackGroup } from "../hub/child-process.ts";
 import { AcpOwnedGroup } from "./acp-owned-group.ts";
 import type { StartForm } from "./registry-types.ts";
+import type { CapabilityManifest } from "../hub/capabilities.ts";
+import { acpManifest } from "./native-capabilities.ts";
 
 export interface PermissionOption {
   optionId: string;
@@ -121,6 +123,8 @@ export interface AcpOptions {
   watchdogMs?: number;
   /** #542 D4: how long an open tool call keeps a silent turn alive; defaults to 30 minutes, never below the watchdog. */
   toolCeilingMs?: number;
+  /** Activity display coalescing; captured by the host at the next adapter start. */
+  activityBatchMs?: number;
   /** Bound for a journal-less watchdog cancellation to report its prompt; defaults to the 30 s ACP handshake cap. */
   cancelWaitMs?: number;
   /** ACP stdio MCP servers for the session (the hub's task tools). */
@@ -156,8 +160,11 @@ export interface AcpOptions {
 
 const HANDSHAKE_MS = 30_000;
 /** Tool calls whose arguments are remembered until their permission request arrives. */
+/** Sessions whose command list may wait for the bind (see `earlyCommands`). */
+const EARLY_COMMANDS_MAX = 8;
 const TOOL_INPUT_CAP = 64;
-const TOOL_CEILING_MS = 30 * 60_000;
+export const TOOL_CEILING_MS = 30 * 60_000;
+export const ACTIVITY_BATCH_MS = 50;
 
 export interface ManagedAcpLaunch {
   readonly generation: string;
@@ -232,6 +239,17 @@ export class AcpPeer extends BasePeer {
   private modeUnknown = false;
   private kimiAgent = false;
   private qwenAgent = false;
+  /** #445 C1: the agent identity from `initialize`, and the latest `available_commands_update` of the CURRENT session (an update that arrives before the session id is bound waits in `earlyCommands`). */
+  private agentIdentity: { name: unknown; version: unknown } | undefined;
+  private commands: { sessionId: string; update: unknown; at: number } | undefined;
+  private binding = false;
+  /**
+   * Lists that arrive while the session is being bound, by the session they name. `readline` hands every line of one stdout chunk to `onLine` before `start()` resumes
+   * from `await session/new`, so on a loaded machine the reply, the bound session's list and another session's list can all arrive while `binding` is still true. A
+   * single slot let the last of them win; keyed by session, a list for another session can neither replace nor stand in for the bound one. Bounded: an agent that names
+   * more sessions than this only loses the oldest.
+   */
+  private earlyCommands = new Map<string, { sessionId: string; update: unknown; at: number }>();
   private availableModes = new Set<string>();
   private proc: ChildProcessWithoutNullStreams | undefined;
   private ownedGroup: { proc: ChildProcessWithoutNullStreams; proof: AcpOwnedGroup } | undefined;
@@ -284,7 +302,7 @@ export class AcpPeer extends BasePeer {
       if (this.activityPending?.kind !== item.kind || (this.activityPending.text.length + item.text.length > 4096)) this.flushActivity();
       if (this.activityPending) this.activityPending.text += item.text;
       else this.activityPending = { kind: item.kind, text: item.text };
-      this.activityTimer ??= setTimeout(() => this.flushActivity(), 50);
+      this.activityTimer ??= setTimeout(() => this.flushActivity(), this.opts.activityBatchMs ?? ACTIVITY_BATCH_MS);
       this.activityTimer.unref?.();
     } else { this.flushActivity(); this.emitActivity(item.kind, item.text); }
   }
@@ -329,6 +347,7 @@ export class AcpPeer extends BasePeer {
     managedLaunches.delete(this);
     if (this.opts.requireOwnedGroup && this.proc) throw new Error("Configured ACP still has a process; stop it before starting another");
     this.stopping = false;
+    this.binding = true; this.earlyCommands.clear(); // #445 C1: a new process starts a new session (the bind below drops the old list)
     const launchedId = this.id;
     const launchedCwd = this.opts.cwd;
     const [bin, ...args] = this.opts.cmd;
@@ -350,6 +369,7 @@ export class AcpPeer extends BasePeer {
       // The configured peer id and command are labels, not an agent-specific mode contract.
       // Installed Kimi Code CLI's ACP initialize advertises this exact name.
       this.kimiAgent = this.nativePolicy === undefined && init?.agentInfo?.name === "Kimi Code CLI";
+      this.agentIdentity = { name: init?.agentInfo?.name, version: init?.agentInfo?.version };
       const expected = this.opts.expectedAgent, version = init?.agentInfo?.version;
       if (expected && (init?.agentInfo?.name !== expected.name || !(typeof expected.version === "function" ? expected.version(version) : version === expected.version))) throw new Error("native ACP identity is not verified for this production adapter");
       const qwen = qwenNativeIdentity(this.id, this.opts.qwen025, init, this.opts.kind);
@@ -379,6 +399,8 @@ export class AcpPeer extends BasePeer {
         throw new Error("Configured ACP did not provide a valid native session identity");
       }
       this.sessionId = session.sessionId;
+      this.binding = false;
+      this.adoptEarlyCommands(session.sessionId);
       this.onDoing?.("reset");
       const modes: unknown = session.modes?.availableModes;
       this.availableModes = new Set(Array.isArray(modes) ? modes.flatMap((mode) => typeof mode?.id === "string" ? [mode.id] : []) : []);
@@ -459,6 +481,19 @@ export class AcpPeer extends BasePeer {
     this.permissionMode = mode;
   }
 
+  /** The bind replaces the old process's list with the one that arrived for THIS session while it was being bound, if any; lists for other sessions are dropped with the rest. */
+  private adoptEarlyCommands(sessionId: string): void {
+    this.commands = this.earlyCommands.get(sessionId);
+    this.earlyCommands.clear();
+  }
+
+  /** #445 C1: the capabilities of the current session's last command list, on a probed Kimi or Qwen version only. Offline or no list yet is empty. */
+  async capabilityManifest(): Promise<CapabilityManifest> {
+    const held = this.commands;
+    if (this.state === "offline" || !held || held.sessionId !== this.sessionId) return { capabilities: [], observedAt: Date.now() };
+    return acpManifest(this.agentIdentity?.name, this.agentIdentity?.version, held.update, held.at);
+  }
+
   async stop(reason?: string): Promise<void> {
     managedLaunches.delete(this);
     if (this.activityOpen) this.endActivity("stopped", true);
@@ -693,6 +728,17 @@ export class AcpPeer extends BasePeer {
     if (this.state === "busy" && !this.cancelWait) { this.lastSignAt = Date.now(); this.touch(); }
 
     if (msg.method === "session/update") {
+      // #445 C1: the command list is the session's, sent right after `session/new` and again when skills change, whatever the turn state. Only the current session's counts.
+      if (msg.params?.update?.sessionUpdate === "available_commands_update" && typeof msg.params.sessionId === "string") {
+        const held = { sessionId: msg.params.sessionId, update: msg.params.update, at: Date.now() };
+        if (this.binding) {
+          this.earlyCommands.delete(held.sessionId); // the newest list of a session replaces its earlier one, and moves it to the newest end
+          this.earlyCommands.set(held.sessionId, held);
+          while (this.earlyCommands.size > EARLY_COMMANDS_MAX) this.earlyCommands.delete(this.earlyCommands.keys().next().value as string);
+        }
+        else if (held.sessionId === this.sessionId) this.commands = held;
+        return;
+      }
       if (msg.params?.sessionId && msg.params.sessionId !== this.sessionId) return;
       const u = msg.params?.update;
       // Occupancy is the session's, not the turn's: 2.1.1's source text emits usage_update after the prompt

package/src/adapters/claude-channel.ts

@@ -12,7 +12,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { ControlClient, stateDirFor } from "../hub/control-client.ts";
+import { ControlClient, INVOCATION_CONTROL_TIMEOUT_MS, stateDirFor } from "../hub/control-client.ts";
 import { VERSION } from "../version.ts";
 import { IMPLEMENTER_HUB_TOOL_NAMES, IMPLEMENTER_PERMISSION_TOOL, ACTIONABLE_MESSAGE_INSTRUCTION, projectConductorTools, projectToolList, CONDUCTOR_TOOL_NAMES, DEFAULT_ROLES, roleContract, TASK_TOOL_NAMES, TASK_TOOLS, profileTaskTools } from "../hub/hub-tools.ts";
 import { frame, replyParent, sanitize, HUB_MESSAGE_INSTRUCTION, type Envelope } from "../hub/envelope.ts";
@@ -391,7 +391,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
   return list;
 });
 
-async function callTool(req: { params: { name: string; arguments?: Record<string, unknown> } }) {
+async function callTool(req: { params: { name: string; arguments?: Record<string, unknown> } }, signal?: AbortSignal) {
   const { name, arguments: args } = req.params;
   if (unidentified) return { ...text(UNIDENTIFIED), isError: true };
   if (permissionTool && !IMPLEMENTER_HUB_TOOL_NAMES.includes(name)) return { ...text("tool unavailable to this owned implementer child"), isError: true };
@@ -458,14 +458,16 @@ async function callTool(req: { params: { name: string; arguments?: Record<string
   }
   if (TASK_TOOL_NAMES.has(name) || CONDUCTOR_TOOL_NAMES.has(name)) {
     if (!hub) return text(offline());
-    const res = await hub.request({ t: "task", op: name, args: args ?? {} });
+    // #445 C2: a daemon that predates invocations would answer with a generic unknown-operation error; say what is missing instead.
+    if (name === "hub_invoke" && !hub.features.includes("invocation")) return { ...text("error: this hub does not support invocations; restart it with the current agent-hub release (ahub restart)"), isError: true };
+    const res = await hub.request({ t: "task", op: name, args: args ?? {} }, name === "hub_invoke" ? INVOCATION_CONTROL_TIMEOUT_MS : undefined, name === "hub_invoke" ? signal : undefined);
     return { ...text(res.ok ? res.text : `error: ${res.error}`), ...(res.ok ? {} : { isError: true }) };
   }
   return text(`unknown tool ${name}`);
 }
 
 // Inbox results still show fresh counts, without telling a held or refused reader to retry in a loop.
-server.setRequestHandler(CallToolRequestSchema, async (req) => withPendingHint(await callTool(req), req.params.name !== "hub_inbox" && req.params.name !== "hub_source_read"));
+server.setRequestHandler(CallToolRequestSchema, async (req, extra) => withPendingHint(await callTool(req, extra.signal), req.params.name !== "hub_inbox" && req.params.name !== "hub_source_read"));
 
 await server.connect(new StdioServerTransport());
 // The host (Claude Code, Codex, Kimi) talks over stdin; once it is gone nothing can use this server, and a leftover would keep reconnecting.

package/src/adapters/codex-appserver.ts

@@ -6,6 +6,8 @@ import { BasePeer, type FrontendProxyPort } from "../hub/peers.ts";
 import { codexContext, type ContextReading } from "../hub/context-window.ts";
 import { peerChildEnv, stopOwnedProcess, trackGroup } from "../hub/child-process.ts";
 import type { ContextReader } from "./registry-types.ts";
+import type { CapabilityManifest } from "../hub/capabilities.ts";
+import { codexSkillsManifest, NATIVE_PINS } from "./native-capabilities.ts";
 import { ACTION_BUDGET_OPTION, type ActionGateVerdict, type PermissionRequest } from "./acp.ts";
 
 const UNIDENTIFIED_CANCELLATION_NOTICE = "Codex cancelled turn has no verified native id; reattach the native session before further hub delivery";
@@ -775,6 +777,23 @@ export class CodexPeer extends BasePeer {
   }
   revertTurn(nativeTurn: string): Promise<void> { return this.revert(nativeTurn); }
 
+  /**
+   * #445 C1: `skills/list` through the attached connection with a hub id (the answer never reaches the TUI). Only the probed version lists (C0 proved 0.166.0;
+   * the pin is older, so a pinned install lists nothing until a receipt covers it). Offline, unattached or unanswered rejects: the caller shows no list, never a stale one.
+   */
+  capabilityManifest(): Promise<CapabilityManifest> {
+    if (this.version !== NATIVE_PINS.codex.version) return Promise.resolve({ capabilities: [], observedAt: Date.now() });
+    const link = this.link;
+    if (this.state === "offline" || !link || link.up.readyState !== WebSocket.OPEN) return Promise.reject(new Error(`${this.id} has no attached app-server`));
+    const id = this.nextId--;
+    return new Promise<CapabilityManifest>((resolve, reject) => {
+      const timer = setTimeout(() => this.pending.delete(id) && reject(new Error("skills/list got no answer")), 10_000);
+      timer.unref?.();
+      this.pending.set(id, { resolve: (result) => (clearTimeout(timer), resolve(codexSkillsManifest(this.version, result, Date.now()))), reject: (e) => (clearTimeout(timer), reject(e)) });
+      link.up.send(JSON.stringify({ method: "skills/list", id, params: { cwds: [this.opts.cwd], forceReload: false } }));
+    });
+  }
+
   /** account/rateLimits/read through the TUI's connection, with a hub id so the answer never reaches the TUI. */
   private readUsage(): void {
     const link = this.link;

package/src/adapters/jcode.ts

@@ -81,7 +81,7 @@ export const jcodeVersionSupported = (version: unknown): boolean => assessVersio
 class SteerRefused extends Error {}
 /** A native steer that was sent but not acknowledged: it may have gone in, so it is never requeued as if it had not. */
 class SteerUncertain extends Error {}
-const STEER_TIMEOUT_MS = 5000;
+export const STEER_TIMEOUT_MS = 5000;
 
 /**
  * #572 AC1: a second client on the hub's own private server socket queues a soft interrupt into the running session

package/src/adapters/local-worker.ts

@@ -4,7 +4,7 @@ import type { RouteLabelEvent, RouteTurnOutcome } from "../models/route/labels.t
 import type { StaySwitchPolicy } from "../models/route/stage.ts";
 import type { ToolObservation } from "../models/route/signals.ts";
 import { randomUUID } from "node:crypto";
-import { MAX_HOP, renderDigest, replyAudience, replyParent, STANDING_INSTRUCTION, USER, type Envelope, type EnvelopeOpts, type PeerId } from "../hub/envelope.ts";
+import { MAX_HOP, remoteEnvelope, renderDigest, replyAudience, replyParent, STANDING_INSTRUCTION, USER, type Envelope, type EnvelopeOpts, type PeerId } from "../hub/envelope.ts";
 import { CONDUCTOR_TOOL_NAMES, CONDUCTOR_TOOLS, TASK_TOOL_NAMES, TASK_TOOLS, profileTaskTools } from "../hub/hub-tools.ts";
 import { BasePeer } from "../hub/peers.ts";
 import type { PublishResult } from "../hub/bus.ts";
@@ -169,7 +169,7 @@ export class LocalPeer extends BasePeer {
     const progress = { sideEffects: 0, last: "" };
     const requestedPolicy = this.opts.turnPolicy?.(envs);
     const policy = envs.some(env => env.private) ? { ...requestedPolicy, pii: true } : requestedPolicy;
-    const remoteTurn = envs.some(env => env.from.includes("@"));
+    const remoteTurn = envs.some(remoteEnvelope);
     const preserveHistory = !policy?.pii && !remoteTurn;
     const labelTurn = this.beginRouteTurn(turn, !!policy?.pii || envs.some(env => env.private), policy?.task);
     let completed = false;
@@ -244,7 +244,7 @@ export class LocalPeer extends BasePeer {
     const { maxSteps = 30 } = this.opts;
     const turnSignal = this.abort!.signal;
     // Remote text/tool output is never memory evidence, even beside ordinary local work in the same turn.
-    const remoteTurn = envs.some(env => env.from.includes("@"));
+    const remoteTurn = envs.some(remoteEnvelope);
     const capture = policy?.pii || remoteTurn ? undefined : this.opts.capture;
     // Unknown gateway state is never permission to send PII.
     if (policy?.pii && !(await this.opts.omni.onCampus())) {

package/src/adapters/native-capabilities.ts

@@ -0,0 +1,50 @@
+// #445 C1: what the hub can read of a native peer's own skills and commands, and the only versions it was probed on (C0 receipt, 2026-10-30).
+// Vendor identities and listing shapes live here, in the adapter layer, never in the core rules of `src/hub/capabilities.ts` (the #451 registry guard).
+import { buildManifest, type Candidate, type CapabilityManifest, type FlatSchema } from "../hub/capabilities.ts";
+
+const object = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value);
+
+/** The only native versions whose listings were probed (C0 receipt, 2026-10-30). Any other version lists nothing until a new receipt covers it. */
+export const NATIVE_PINS = Object.freeze({
+  kimi: { agent: "Kimi Code CLI", version: "2.3.2" },
+  qwen: { agent: "qwen-code", version: "0.26.1" },
+  codex: { agent: "codex", version: "0.166.0" },
+} as const);
+const STRING_INPUT: FlatSchema = { type: "object", properties: { input: { type: "string" } }, additionalProperties: false };
+const QWEN_SKILL_SOURCES = ["bundled-skill", "skill-dir-command"];
+
+/**
+ * An ACP `available_commands_update` as the capabilities of a probed Kimi or Qwen. Only entries that can be told apart as skills are listed (Qwen by
+ * `_meta.source`, Kimi by its `skill:` prefix): a builtin such as `compact` or `clear` changes session or host state and is never listed. A native
+ * listing carries no schema and no class, so each entry takes the one-string input and declares no class at all (`sideEffect` is absent, not `read`): the
+ * person's share class is then the only one that counts, and with none it is `destructive` and refused (O6). Any other agent or version gives an empty manifest.
+ */
+export function acpManifest(agent: unknown, version: unknown, update: unknown, observedAt: number): CapabilityManifest {
+  const empty: CapabilityManifest = { capabilities: [], observedAt };
+  const kind = agent === NATIVE_PINS.kimi.agent && version === NATIVE_PINS.kimi.version ? "kimi"
+    : agent === NATIVE_PINS.qwen.agent && version === NATIVE_PINS.qwen.version ? "qwen" : undefined;
+  if (!kind || !object(update) || !Array.isArray(update.availableCommands)) return empty;
+  const candidates: Candidate[] = [];
+  for (const command of update.availableCommands) {
+    if (!object(command) || typeof command.name !== "string") continue;
+    const meta = object(command._meta) ? command._meta : {};
+    const skill = kind === "kimi" ? command.name.startsWith("skill:") : typeof meta.source === "string" && QWEN_SKILL_SOURCES.includes(meta.source);
+    if (skill) candidates.push({ kind: "command", name: command.name, description: command.description, inputSchema: STRING_INPUT, source: "acp", invoke: "native" });
+  }
+  return buildManifest(candidates, observedAt);
+}
+
+/** A Codex `skills/list` answer as capabilities, on the probed version only. Only a skill that says `enabled: true` is listed: a flag that is missing or unreadable is not consent. */
+export function codexSkillsManifest(version: unknown, result: unknown, observedAt: number): CapabilityManifest {
+  const candidates: Candidate[] = [];
+  if (version === NATIVE_PINS.codex.version && object(result) && Array.isArray(result.data)) {
+    for (const entry of result.data) {
+      if (!object(entry) || !Array.isArray(entry.skills)) continue;
+      for (const skill of entry.skills) {
+        if (!object(skill) || skill.enabled !== true) continue;
+        candidates.push({ kind: "skill", name: skill.name, description: skill.shortDescription ?? skill.description, inputSchema: STRING_INPUT, source: "codex-skills", invoke: "native" });
+      }
+    }
+  }
+  return buildManifest(candidates, observedAt);
+}

package/src/adapters/registry-types.ts

@@ -1,6 +1,7 @@
 import type { ClaudeImplementerOptions } from "./claude-implementer.ts";
 import type { ReviewerBackend, ReviewerPrintOptions } from "./reviewer-print.ts";
 import type { SettingDef } from "../hub/settings.ts";
+import type { CapabilityManifest } from "../hub/capabilities.ts";
 import type { Addon } from "../hub/tooling.ts";
 import type { RecoveryContinuityBookmark } from "../hub/recovery-continuity.ts";
 import type { RecoveryPeer } from "../cli/upgrade.ts";
@@ -117,16 +118,8 @@ export interface ContextReader {
   read(value: unknown, sessionId: string, measuredAt: number): ContextReading;
 }
 
-export interface CapabilityManifest {
-  capabilities: {
-    id: string;
-    kind: "command" | "skill" | "mcp_tool";
-    name: string;
-    description: string;
-    inputSchema?: unknown;
-    sideEffect: "read" | "write" | "exec" | "external";
-  }[];
-}
+/** #445 C1: the manifest shape lives with its digest, sanitizer and share rules in `src/hub/capabilities.ts`; the `exec` class is gone (arbitrary execution is `destructive`). */
+export type { Capability, CapabilityManifest, SideEffect } from "../hub/capabilities.ts";
 
 export interface NativeFactsInput {
   event: "SessionStart" | "PreInvocation" | "PostInvocation" | "PreToolUse" | "PostToolUse" | "Stop";

package/src/cli/capabilities-output.ts

@@ -0,0 +1,30 @@
+// Human output for `ahub capabilities` (#445 C1). Pure: parsed hub-tool JSON in, spans out, no I/O. `--json` is the caller's branch and prints the same text.
+// A description is another agent's words: the daemon has already sanitized it, and it is shown here as data on its own row, never as part of a command line.
+import { blank, grid, heading, pair, s } from "./sdlc-output.ts";
+import type { Span } from "./console-state.ts";
+
+const list = (value: unknown): any[] => Array.isArray(value) ? value : [];
+const dash = (value: unknown) => value === undefined || value === null || value === "" ? "-" : String(value);
+const STATE_TONE: Record<string, "attention" | "muted" | undefined> = { listed: undefined, "digest-changed": "attention", unshared: "muted" };
+
+/** `ahub capabilities`: per peer, each capability the hub can see, whether you share it, and the class that would apply to a call. */
+export function renderCapabilities(result: unknown, columns?: number): Span[][] {
+  const peers = list((result as { peers?: unknown } | null)?.peers);
+  const out: Span[][] = [...heading(`Capabilities: ${peers.length} peer${peers.length === 1 ? "" : "s"} listing`, columns)];
+  if (!peers.length) {
+    out.push(blank, [s("no peer lists a capability: an agent must be attached, on a version the hub has probed, and offer a skill or command", "muted")]);
+    return out;
+  }
+  for (const peer of peers) {
+    const entries = list(peer.entries);
+    const shared = entries.filter(entry => entry.state === "listed").length;
+    out.push(blank, ...heading(`${dash(peer.peer)}: ${entries.length} found, ${shared} shared, mode ${dash(peer.permission_mode)}`, columns));
+    out.push(...grid(["ID", "STATE", "CLASS", "SOURCE", "DIGEST"], entries.map((entry: any) => [
+      s(dash(entry.id)), s(dash(entry.state), STATE_TONE[String(entry.state)]), s(dash(entry.class), entry.class === "destructive" ? "attention" : undefined), s(`${dash(entry.source)}/${dash(entry.invoke)}`), s(dash(entry.digest)),
+    ]), columns));
+    const stale = entries.filter(entry => entry.state === "digest-changed");
+    for (const entry of stale) out.push(...pair("changed", `${dash(entry.id)} no longer matches its pinned digest and is unlisted until you pin the new one`, columns, 8, "attention"));
+  }
+  out.push(blank, [s("Share an entry by adding its digest under invocation.share.<peer> in .agenthub/config.local.json (this machine only). A class you set can only raise the one the source declared. An entry with no class anywhere counts as destructive and is refused.", "muted")]);
+  return out;
+}

package/src/cli/console-state.ts

@@ -29,6 +29,8 @@ export interface SettingsEdit {
   text: string; value?: SettingValue; reason?: string; lines?: string[]; confirm?: string; undoDigest?: string;
 }
 export interface ConsoleState {
+  /** Launch-captured local presentation only; absent on legacy pure-state callers. */
+  noticeMs?: number; historyLimit?: number;
   /** #689: the structural config form (Settings panel, key c) and the file revisions the hub last reported. */
   configForm?: ConfigForm; configRevisions?: Record<string, string>; configInstances?: string[];
   settingsRows?: SettingRow[]; settingsKnown?: boolean; settingsUndo?: string; settingsProblem?: string;
@@ -637,7 +639,7 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
           if (!peer || !reason) throw new Error("queue discard needs --peer and --reason (it is recorded on every discarded delivery)");
           const count = s.queue.filter(row => row.peer === peer && row.state === state).length;
           const args = ["queue", "discard", "--peer", peer, ...(parsed.includes("--state") ? ["--state", state] : []), "--reason", reason, "--yes"];
-          s.history = [...s.history, input].slice(-100); s.historyIndex = s.history.length;
+          s.history = [...s.history, input].slice(-(s.historyLimit ?? CONSOLE_HISTORY_LIMIT)); s.historyIndex = s.history.length;
           s.confirm = { type: "command", args, prompt: `discard all ${count} ${state} deliver${count === 1 ? "y" : "ies"} of ${peer}; no task or native turn is cancelled, other peers are untouched` };
           return done();
         }
@@ -655,7 +657,7 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
           if (lock.syntax === "planning" && args.length < (lock.prefix[1] === "plan" ? 6 : 5)) throw new Error("backlog row actions require a reason");
           if (lock.prefix[0] === "task" && !["owner", "reviewer"].includes(commandFlag(args, "--role") ?? "owner")) throw new Error("role must be owner or reviewer");
         }
-        s.history = [...s.history, input].slice(-100); s.historyIndex = s.history.length;
+        s.history = [...s.history, input].slice(-(s.historyLimit ?? CONSOLE_HISTORY_LIMIT)); s.historyIndex = s.history.length;
         if (commandNeedsConfirmation(args)) s.confirm = { type: "command", args, ...(lock ? { prompt: lockedCommandPrompt(lock, args), ...(lock.revisionField ? { lock } : {}) } : {}) };
         else effects.push({ type: "command", args });
       } catch (error) { notify(s, String((error as Error).message), now); }
@@ -900,9 +902,10 @@ export function reduceConsole(state: ConsoleState, key: string, now = Date.now()
 export function renderConsole(s: ConsoleState, columns: number, rows = 24, now = Date.now()): string[] {
   return renderConsoleLines(s, columns, rows, now).map(line => paint(line, false));
 }
-const NOTICE_MS = 10_000;
-export function activeNotice(s: Pick<ConsoleState, "notice" | "noticeAt">, now = Date.now()): boolean {
-  return !!s.notice && now - (s.noticeAt ?? now) < NOTICE_MS;
+export const NOTICE_MS = 10_000;
+export const CONSOLE_HISTORY_LIMIT = 100;
+export function activeNotice(s: Pick<ConsoleState, "notice" | "noticeAt" | "noticeMs">, now = Date.now()): boolean {
+  return !!s.notice && now - (s.noticeAt ?? now) < (s.noticeMs ?? NOTICE_MS);
 }
 export const TABLES: Record<number, string[]> = {
   1: ["PEER", "STATE", "LINK", "Q", "!", "WIP", "REVIEW", "PAUSE", "QUOTA", "MODEL", "DOING"],

package/src/cli/console.ts

@@ -1,3 +1,4 @@
+import { consoleOperationalSnapshot } from "../hub/operational-settings.ts";
 import { basename } from "node:path";
 import { fileURLToPath } from "node:url";
 import { StringDecoder } from "node:string_decoder";
@@ -24,6 +25,8 @@ export interface ConsoleTerminal {
   onSignal(listener: () => void): () => void;
   onError?(listener: (error: Error) => void): () => void;
 }
+/** Legacy startup defaults, independently pinned against the H1 rows. */
+export const CONSOLE_POLL_MS = 4000, CONSOLE_PENDING_STREAM_LIMIT = 1000, CONSOLE_ATTENTION_LIMIT = 1000;
 export interface ConsoleOptions {
   client: Pick<ControlClient, "request" | "send" | "close" | "onPush" | "onClose">;
   cwd: string; stateDir: string; panels?: boolean; columns?: number; rows?: number;
@@ -101,6 +104,7 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
   const removers: (() => void)[] = []; const timers: ReturnType<typeof setInterval>[] = [];
   let resolveDone: () => void = () => {}; const done = new Promise<void>(resolve => { resolveDone = resolve; });
   let pendingStream: ConsoleEvent[] = []; let droppedStream = 0;
+  let presentation = consoleOperationalSnapshot(undefined);
   let priorStreamFooterStart: number | undefined;
   let lastExpandedNotice = "";
   const notice = (text: string, tone: Tone = "failure") => notify(state, text, Date.now(), tone);
@@ -123,7 +127,7 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
       terminal.write(paint([...(color ? streamTokens(header ?? "", event.tone, event.kind) : [{ text: header ?? "" }]), ...body.map(text => ({ text: "\n" + text }))], color) + "\n");
     }
     else if (state.mode === "stream") writeStream(event);
-    else { pendingStream.push(event); if (pendingStream.length > 1000) { pendingStream.shift(); droppedStream++; } }
+    else { pendingStream.push(event); if (pendingStream.length > presentation.pendingStreamLimit) { pendingStream.shift(); droppedStream++; } }
   };
   const draw = () => {
     if (!active) return;
@@ -389,7 +393,7 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
     if (!active) return;
     try {
       if (msg.t === "event") {
-        if (state.petEnabled && msg.e.t === "envelope" && !msg.e.dropped && msg.e.env.to?.includes("user")) state.attentionMessages = [...(state.attentionMessages ?? []), { id: msg.e.env.id, peer: msg.e.env.from, important: msg.e.env.priority === "important", since: msg.e.env.ts }].slice(-1000);
+        if (state.petEnabled && msg.e.t === "envelope" && !msg.e.dropped && msg.e.env.to?.includes("user")) state.attentionMessages = [...(state.attentionMessages ?? []), { id: msg.e.env.id, peer: msg.e.env.from, important: msg.e.env.priority === "important", since: msg.e.env.ts }].slice(-presentation.attentionLimit);
         stream({ text: renderTailEvent(msg.e), peer: msg.e.peer ?? msg.e.env?.from, kind: msg.e.env?.kind ?? msg.e.t, tone: eventTone(msg.e) });
       }
       else if (msg.t === "context") stream({ text: `  ${msg.peer}: ${contextLine(msg.reading, at => new Date(at).toLocaleTimeString())}`, peer: msg.peer, kind: "context" });
@@ -454,8 +458,27 @@ export async function runConsole(options: ConsoleOptions): Promise<void> {
     removers.push(terminal.onSignal(() => stop()));
     if (terminal.onError) removers.push(terminal.onError(error => { process.exitCode = 1; stop(`Console error: ${error.message}`); }));
     timers.push(setInterval(() => { try { state = pruneApprovals(state, Date.now()); draw(); } catch (error) { stop(`Console error: ${String((error as Error).message)}`); } }, 1000));
-    timers.push(setInterval(() => void refresh(), Math.max(2000, options.pollMs ?? 4000)));
-    draw(); client.send({ t: "tail" }); void refresh(); await done;
+    const initialPollMs = Math.max(2000, options.pollMs ?? CONSOLE_POLL_MS);
+    const initialPoll = setInterval(() => void refresh(), initialPollMs); timers.push(initialPoll);
+    // Subscribe and render synchronously as before; close, signal and permission handlers stay live during this bounded read.
+    draw(); client.send({ t: "tail" }); void refresh();
+    const startup = client.request({ t: "settings_get" }, 3000).catch(() => undefined);
+    const accepted = await Promise.race([startup, done]);
+    if (!active) return;
+    presentation = consoleOperationalSnapshot(accepted?.ok === false ? undefined : accepted?.rows);
+    state.noticeMs = presentation.noticeMs; state.historyLimit = presentation.historyLimit;
+    // Only this launch's pre-capture presentation buffers can need trimming. Never touch approvals or delivery queues.
+    const omitted = Math.max(0, pendingStream.length - presentation.pendingStreamLimit);
+    if (omitted) { pendingStream.splice(0, omitted); droppedStream += omitted; }
+    state.attentionMessages = state.attentionMessages?.slice(-presentation.attentionLimit);
+    const forgotten = Math.max(0, state.history.length - presentation.historyLimit);
+    if (forgotten) { state.history.splice(0, forgotten); state.historyIndex = Math.max(0, state.historyIndex - forgotten); }
+    const capturedPollMs = Math.max(2000, options.pollMs ?? presentation.pollMs);
+    if (capturedPollMs !== initialPollMs) {
+      clearInterval(initialPoll);
+      timers.push(setInterval(() => void refresh(), capturedPollMs));
+    }
+    draw(); await done;
   } catch (error) { stop(`Console error: ${String((error as Error).message)}`); }
   finally { stop(); }
 }

package/src/cli/help.ts

@@ -11,7 +11,7 @@ const SECTIONS: [string, [usage: string, description: string][]][] = [
     ["ahub projects [--json] [--full] [--color=auto|always|never]", "list registered projects and live status"],
     ["ahub projects remove <id>", "forget a stopped registration (keeps project files)"],
     ["ahub setup [--yes]", "install or update the Claude Code channel plugin from this package, then run doctor"],
-    ["ahub init [--profile dev|research|writing|general|<pack>] [--shadow] [--release-guard] [--dry-run --json]", "preview or write .agenthub/config.json and the AGENTS.md marker block (drops a legacy CLAUDE.md block); a pack is a project file .agenthub/roles/<name>.pack.json"],
+    ["ahub init [--profile dev|research|writing|general|<pack>] [--shadow] [--release-guard] [--dry-run --json]", "preview or write .agenthub/config.json and the AGENTS.md marker block (drops a legacy CLAUDE.md block); a pack is a shipped one (writing-pack, analysis, ops) or a project file .agenthub/roles/<name>.pack.json"],
     ["ahub --live-test [--project <path|id>] <command> [args...]", "user-authorized operational console delegation; ordinary calls retain peer identity; person-authored content refuses"],
     ["ahub help [command]", "this help, or one command's entries; also --help and -h"],
     ["ahub version | --version", "print the installed version"],
@@ -102,6 +102,8 @@ const SECTIONS: [string, [usage: string, description: string][]][] = [
     ["ahub source add <path|url> | list [--json] [--color=auto|always|never]", "list is person only, add the person's or the configured conductor's: register an input as a content-hashed source (src:<16 hex of the SHA-256>) under the hub state dir sources/<id>/ (meta.json, raw, text); a URL is fetched once by this command, https only, at most 5 redirects; up to 16 MiB, never truncated; a path under pii.paths or text matching signals.pii_patterns is private, and private is never downgraded"],
     ["ahub schedule list | run <id> | pause <id> | resume <id> [--json] [--color=auto|always|never]", "list is person only; run, pause and resume are the person's or the configured conductor's: the machine-local schedules (`schedules` in .agenthub/config.local.json); list shows each one's next run, run proposes one now through the same hold, open-task and PII path as the timer and restarts its period, pause stops the timer proposing it without counting a skip, resume starts a fresh period so a pause is never replayed as a run"],
     ["ahub intake \"<text>\" [--source <id>...] | approve <id> | discard <id> [--json] [--color=auto|always|never]", "person only, except approve (person or configured conductor): turn a plain request into a draft backlog card that nothing offers or pulls until you approve it; the configured planner is asked to split it with hub_backlog_split, or the hub model proposes the split (a PII request only on an on-prem model, never to a planner); each --source must be a registered src: id; approve clears the draft on it and its parts, discard cancels them through task cancel"],
+    ["ahub capabilities [--json] [--color=auto|always|never]", "person only, never a conductor or an agent shell: list the skills and commands each attached peer offers (Kimi 2.3.2 and Qwen 0.26.1 sessions, Codex 0.166.0 skills; other versions list nothing), whether you share each one, its digest and the class a call would count as; sharing is invocation.share in .agenthub/config.local.json, this machine only; it only lists and never calls anything"],
+    ["ahub learn list [--all] | accept <id> | reject <id> [--json] [--color=auto|always|never]", "person only, never a conductor or an agent shell: review a recurring-unmet-criterion candidate the hub filed (#514a); accept writes its one review checklist line, added to your current checklist, to .agenthub/config.local.json through the settings writer (this machine only, never a tracked file, ahub settings undo puts it back, applies after a restart) and closes the card; reject only closes it"],
     ["ahub deliverables [--task <id>] [--approved] [--check] [--json] [--color=auto|always|never]", "what each task delivered and a reviewer approved, by id, hash and size (a path only where the PII screen allows); --check measures the files now and marks one changed since review; an agent sees only the tasks hub_task_show shows it"],
     ["ahub task show <id> [--json] [--full] [--color=auto|always|never] | escalate <id>", "full task with history (the person sees PII text, an agent the public view) / hand it to the next peer in escalate_to (person or configured conductor)"],
     ["ahub task role <id> <role|none>", "the person, or an agent on a task it owns: change bounded catalog guidance on an open task; routing and authority are unchanged"],

package/src/cli/identity.ts

@@ -186,9 +186,12 @@ export function cliCommandLabel(command: string, args: readonly string[], catalo
   if (command === "schedule") return ["list", "run", "pause", "resume"].includes(args.find(arg => arg !== "--json") ?? "") ? `schedule ${args.find(arg => arg !== "--json")}` : "schedule";
   // #334: intake names its two subcommands in the audit and a refusal, never the request text (it can carry a secret).
   if (command === "intake") return ["approve", "discard"].includes(args.find(arg => arg !== "--json") ?? "") ? `intake ${args.find(arg => arg !== "--json")}` : "intake";
+  // #514b: the audit and a refusal name the subcommand only, never the card id or any text.
+  if (command === "capabilities") return "capabilities"; // #445 C1: no argument is ever echoed into the audit
+  if (command === "learn") return ["list", "accept", "reject"].includes(args.find(arg => arg !== "--json") ?? "") ? `learn ${args.find(arg => arg !== "--json")}` : "learn";
   if (command === "source") return ["add", "list"].includes(args.find(arg => arg !== "--json") ?? "") ? `source ${args.find(arg => arg !== "--json")}` : "source";
   if (command === "release") return ["new", "list", "show", "plan", "activate", "freeze", "ship", "drop"].includes(args[0] ?? "") ? `release ${args[0]}` : "release";
-  if (!(catalog?.definitionOf(command) ?? definitionOf(command)) && !["upgrade", "restart", "recovery", "recovery-run", "help", "--help", "--version", "version", "completion", "projects", "ui", "manager", "setup", "init", "daemon", "up", "console", "stop", "models", "say", "queue", "tail", "watch", "budget", "board", "task", "review", "remember", "ask", "route", "pause", "resume", "permit", "permission", "settings", "roster", "status", "pet", "logs", "export", "report", "research", "memory", "goal", "bench", "sdlc", "role", "facts", "check-path", "turns", "undo", "kill", "down", "reset", "doctor", "agents", "source", "broker", "schedule", "intake"].includes(command)) return "unknown";
+  if (!(catalog?.definitionOf(command) ?? definitionOf(command)) && !["upgrade", "restart", "recovery", "recovery-run", "help", "--help", "--version", "version", "completion", "projects", "ui", "manager", "setup", "init", "daemon", "up", "console", "stop", "models", "say", "queue", "tail", "watch", "budget", "board", "task", "review", "remember", "ask", "route", "pause", "resume", "permit", "permission", "settings", "roster", "status", "pet", "logs", "export", "report", "research", "memory", "goal", "bench", "sdlc", "role", "facts", "check-path", "turns", "undo", "kill", "down", "reset", "doctor", "agents", "source", "broker", "schedule", "intake", "learn"].includes(command)) return "unknown";
   if (["task", "queue", "budget", "route", "recovery", "models", "projects", "research", "memory", "goal", "bench", "agents", "roster", "settings"].includes(command)) {
     const sub = command === "bench" || command === "memory" || command === "goal" ? args.find((arg) => arg !== "--json") : args[0];
     if (sub && ["propose", "show", "assign", "unassign", "escalate", "cancel", "claim", "label", "list", "add", "resolve", "resume", "set", "execution", "explain", "status", "abort", "dispose", "reattach", "setup", "start", "stop", "remove", "discard", "export", "backfill", "addons", "run", "report", "compare", "search", "graph", "promote", "demote", "forget", "supersede", "dedupe", "decay", "rebuild", "sync", "machine", "import", "suggestions", "confirm", "reject", "new", "link", "state", "done", "take", "trust"].includes(sub)) return `${command} ${sub}`;

package/src/cli/learn-output.ts

@@ -0,0 +1,38 @@
+// Human output for `ahub learn` (#514b). Pure: parsed hub-tool JSON in, spans out, no I/O. `--json` is the caller's branch and prints the same text.
+// Ids, counts, the key parts and the one line the hub itself generates are all it shows: the card's own text is never echoed (a card is data to the parser, not to this printer).
+import { blank, grid, heading, pair, s } from "./sdlc-output.ts";
+import type { Span } from "./console-state.ts";
+
+const list = (value: unknown): any[] => Array.isArray(value) ? value : [];
+const dash = (value: unknown) => value === undefined || value === null || value === "" ? "-" : String(value);
+
+/** `ahub learn list [--all]`: one row per candidate, and what each command would do. */
+export function renderLearnList(result: unknown, columns?: number, all = false): Span[][] {
+  const rows = list(result);
+  const open = rows.filter(row => row.status === "open").length;
+  const out: Span[][] = [...heading(all ? `Review checklist candidates: ${open} open, ${rows.length - open} decided` : `Review checklist candidates: ${open} open`, columns)];
+  if (!rows.length) {
+    out.push(blank, [s(all ? "no candidate has been filed" : "no open candidate; pass --all to include decided ones", "muted")]);
+    return out;
+  }
+  out.push(...grid(["ID", "STATUS", "PROFILE/CLASS", "CRITERION", "TASKS", "LINE TO ADD"], rows.map((row: any) => [
+    s(`#${row.id}`, "taskRef"), s(dash(row.status), row.status === "open" ? "attention" : "muted"), s(`${dash(row.profile)}/${dash(row.class)}`), s(dash(row.criterion)), s(String(list(row.tasks).length)), s(dash(row.line)),
+  ]), columns));
+  if (open) out.push(blank, [s("accept writes the line to .agenthub/config.local.json (ahub settings undo puts it back); reject closes the card. Nothing else changes.", "muted")]);
+  return out;
+}
+
+/** `ahub learn accept|reject <id>`: what was decided, and for accept exactly what was written and where. */
+export function renderLearnChange(op: "accept" | "reject", result: unknown, columns?: number): Span[][] {
+  const r = (result ?? {}) as any;
+  const card = op === "accept" ? r.card : r;
+  const out: Span[][] = [...heading(op === "accept" ? `Candidate #${dash(card?.id)} accepted` : `Candidate #${dash(card?.id)} rejected and closed`, columns)];
+  if (op === "reject") return [...out, ...pair("written", "nothing", columns, 8, "muted")];
+  const a = r.accepted ?? {};
+  if (a.alreadyAccepted) return [...heading(`Candidate #${dash(card?.id)} was already accepted`, columns), ...pair("profile", `${dash(a.profile)}/${dash(a.class)}`, columns, 8), ...pair("criterion", a.criterion, columns, 8), ...pair("written", "nothing: it was accepted before (ahub settings undo still puts back that write if it is the latest)", columns, 8, "muted")];
+  out.push(...pair("profile", `${dash(a.profile)}/${dash(a.class)}`, columns, 8), ...pair("criterion", a.criterion, columns, 8), ...pair("line", a.line, columns, 8),
+    ...pair("file", `${dash(a.file)} (this machine only; the shared config is untouched)`, columns, 8), ...pair("now", a.alreadyPresent ? `the checklist already had this line: nothing was written` : `${dash(a.lines)} lines in the checklist`, columns, 8),
+    ...pair("applies", dash(a.applies), columns, 8, "attention"));
+  if (a.undo) out.push(blank, [s(`put it back with ${a.undo}`, "muted")]);
+  return out;
+}

package/src/cli/main.ts

@@ -26,6 +26,8 @@ import { fetchSourceUrl, MAX_SOURCE_BYTES, publicSourceView, screenRegistration,
 import { renderSourceAdd, renderSourceList } from "./source-output.ts";
 import { renderScheduleChange, renderScheduleList, renderScheduleRun } from "./schedule-output.ts";
 import { renderIntake, renderIntakeChange } from "./intake-output.ts";
+import { renderLearnChange, renderLearnList } from "./learn-output.ts";
+import { renderCapabilities } from "./capabilities-output.ts";
 import { terminalText } from "./console-state.ts";
 import { parseSettingsEditArgs, runSettingsEdit, SETTINGS_EDIT_USAGE } from "./settings-edit.ts";
 import { petView, readPet, renderPet } from "./pet.ts";
@@ -38,7 +40,7 @@ import { verifiedJcodeCommand } from "../adapters/jcode.ts";
 import { configureJcodeMcp, jcodeExtraMcpServers } from "./jcode-mcp.ts";
 import { qwenSessionId } from "../hub/crash.ts";
 import { isPermissionMode } from "../hub/permission-mode.ts";
-import { parseSettingText, settingDef, settingText, type SettingRow } from "../hub/settings.ts";
+import { parseSettingText, settingDef, settingText, undoableDef, type SettingRow } from "../hub/settings.ts";
 import { startModeOf } from "../hub/start-mode.ts";
 import { currentRouting, OVERLAY_FILE, parseOverlay, parseRouting, routingText, type Routing, type RoutingOverlay } from "../hub/routing.ts";
 import { spawn, spawnSync } from "node:child_process";
@@ -1450,6 +1452,30 @@ const commands: Record<string, () => Promise<void> | void> = {
     return showToolText(data => renderScheduleChange(sub as "pause" | "resume", data, present.columns, Date.now()), await taskOp(sub === "pause" ? "schedule_pause" : "schedule_resume", { id }), present);
   },
 
+  capabilities: async () => {
+    // #445 C1: what each attached peer offers and which of it you share. Person only, like `learn`: `capabilities` has no entry in classifyPeerCommand, so an agent shell is refused before this runs and the daemon refuses any caller but the person again. It lists; it never calls anything.
+    const split = splitPresentation(args);
+    const present = outputOptions(split.flags);
+    if (split.operands.length) return fail("usage: ahub capabilities [--json] [--color=auto|always|never]");
+    return showToolText(data => renderCapabilities(data, present.columns), await taskOp("capabilities_list", {}), present);
+  },
+  learn: async () => {
+    // #514b: the person's verdict on a recurring-criterion candidate (#514a). Person only, end to end: `learn` is a `console` command for an agent shell (classifyPeerCommand has no entry for it, so the
+    // identity layer refuses it before this runs), and the daemon refuses any caller but the person again. `accept` writes ONE key (profile_overrides.review_checklist) to the machine-local
+    // config through the settings writer; nothing in a card's text is written.
+    const split = splitPresentation(args);
+    const present = outputOptions(split.flags); // before any request: an invalid --color must refuse before a mutation is sent
+    const usage = "usage: ahub learn list [--all] | accept <id> | reject <id> [--json] [--color=auto|always|never]";
+    const [sub, ...rest] = split.operands;
+    if (sub === "list" && rest.every(arg => arg === "--all")) {
+      const all = rest.includes("--all");
+      return showToolText(data => renderLearnList(data, present.columns, all), await taskOp("learn_list", { ...(all ? { all: true } : {}) }), present);
+    }
+    const [id, ...extra] = rest;
+    if ((sub !== "accept" && sub !== "reject") || !id || extra.length || !/^[1-9]\d*$/.test(id)) return fail(usage);
+    return showToolText(data => renderLearnChange(sub, data, present.columns), await taskOp(sub === "accept" ? "learn_accept" : "learn_reject", { id: Number(id) }), present);
+  },
+
   intake: async () => {
     // #334 (#511a): natural-language intake. Person only, except approve (#933: the configured conductor too, admitted and audited by the daemon).
     // The request is a draft backlog card that nothing offers until `approve`; the hub, not this process, splits it.
@@ -1952,7 +1978,7 @@ const commands: Record<string, () => Promise<void> | void> = {
         return console.log(paint([{ text: result.text }], false));
       }
       if (sub === "undo") {
-        const view = await request({ t: "settings_get" }), undoDef = settingDef(view.undo, settingScope.instances, settingScope.catalog);
+        const view = await request({ t: "settings_get" }), undoDef = undoableDef(view.undo, settingScope.instances, settingScope.catalog);
         // A roster undo of a declared peer needs its confirmation prompt; without readable declarations, refuse rather than skip it.
         if (typeof undoDef === "string" && settingScopeError) fail(`pending undo ${String(view.undo)}: ${undoDef}; the project config could not be read: ${settingScopeError}`);
         const rosterPeer = typeof undoDef !== "string" && undoDef.group === "Roster" ? undoDef.path[1] : undefined;