@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-hermes-memory/tests/store/sqlite-memory-store.test.ts

@@ -179,6 +179,89 @@ describe('sqlite-memory-store', () => {
       assert.deepStrictEqual(getMemories(dbManager, { project: 'spoofed-project' }), []);
     });
 
+    it('reports a degraded result (not a swallowed success) on FTS5 index errors', () => {
+      // A genuine FTS5 search-index error must not look like a successful
+      // zero-row sync: the result carries degraded + reason so the caller can
+      // surface /memory-sync-markdown repair guidance.
+      const failingDb = {
+        prepare: (sql: string) => ({
+          get: () => undefined,
+          all: () => [],
+          run: () => {
+            throw new Error('fts5: table memory_fts is corrupted');
+          },
+        }),
+      } as never;
+      const stubDbManager = {
+        getDb: () => failingDb,
+        withCorruptionRecovery: <T>(operation: () => T): T => operation(),
+      } as unknown as DatabaseManager;
+
+      const result = reconcileMarkdownMemoryScope(
+        stubDbManager,
+        ['degraded reconcile test entry'],
+        'memory',
+        null,
+      );
+      assert.equal(result.degraded, true);
+      assert.match(result.degradedReason ?? '', /fts5/);
+      assert.equal(result.inserted, 0);
+    });
+
+    it('propagates degraded from failure scopes (first reason wins)', () => {
+      // When multiple failure scopes are degraded, the aggregate result must
+      // be degraded with the first reason (not the last) so the user sees the
+      // original failure, not a later duplicate.
+      let callCount = 0;
+      const failingDb = {
+        prepare: (sql: string) => ({
+          get: () => undefined,
+          all: () => [],
+          run: () => {
+            callCount++;
+            throw new Error(`fts5: error #${callCount}`);
+          },
+        }),
+      } as never;
+      const stubDbManager = {
+        getDb: () => failingDb,
+        withCorruptionRecovery: <T>(operation: () => T): T => operation(),
+      } as unknown as DatabaseManager;
+
+      const result = reconcileMarkdownFailureScopes(
+        stubDbManager,
+        [
+          'failure entry one — Project: project-a <!-- created=2026-01-01 -->',
+          'failure entry two — Project: project-b <!-- created=2026-01-01 -->',
+        ],
+      );
+      assert.equal(result.degraded, true);
+      assert.match(result.degradedReason ?? '', /fts5: error #1/);
+    });
+
+    it('still propagates corruption errors instead of degrading (recovery must run)', () => {
+      // Corruption signals are NOT FTS5 errors: they must escape so
+      // DatabaseManager quarantines + rebuilds, never a degraded zero-result.
+      const failingDb = {
+        prepare: () => ({
+          get: () => undefined,
+          all: () => [],
+          run: () => {
+            throw new Error('database disk image is malformed');
+          },
+        }),
+      } as never;
+      const stubDbManager = {
+        getDb: () => failingDb,
+        withCorruptionRecovery: <T>(operation: () => T): T => operation(),
+      } as unknown as DatabaseManager;
+
+      assert.throws(
+        () => reconcileMarkdownMemoryScope(stubDbManager, ['corruption test entry'], 'memory', null),
+        /malformed/,
+      );
+    });
+
     it('prunes only absent rows in the exact target and project scope', () => {
       addMemory(dbManager, 'kept global memory', 'memory', null);
       addMemory(dbManager, 'orphaned global memory', 'memory', null);
@@ -333,6 +416,18 @@ describe('sqlite-memory-store', () => {
       addMemory(dbManager, 'timezone: AEST', 'user');
     });
 
+    it('degrades an all-stop-word query to the LIKE fallback instead of []', () => {
+      // "the" is a stop word and "and"/"or" connectors, so FTS5 normalization
+      // leaves nothing to match. The query must fall through to the scoped
+      // literal fallback (which still searches the raw terms) rather than
+      // hard-return an empty result set.
+      addMemory(dbManager, 'the build passes after restart');
+
+      const results = searchMemories(dbManager, 'the and or');
+      assert.ok(results.length > 0, 'all-stop-word query must reach the LIKE fallback, not []');
+      assert.ok(results.some(r => r.content.includes('the')));
+    });
+
     it('should find memories by keyword', () => {
       const results = searchMemories(dbManager, 'pnpm');
       assert.ok(results.length > 0);
@@ -344,6 +439,36 @@ describe('sqlite-memory-store', () => {
       assert.ok(results.length > 0);
       assert.ok(results.some(r => r.content.includes('Prisma')));
     });
+
+    it('returns only project-attributed memories for target "project"', () => {
+      const results = searchMemories(dbManager, 'Prisma', { target: 'project' });
+
+      assert.ok(results.length > 0);
+      assert.ok(results.every((r) => r.project === 'project-a'));
+      assert.ok(results.every((r) => r.target === 'memory'));
+    });
+
+    it('keeps target "memory" matching both global and project-attributed memories', () => {
+      const global = searchMemories(dbManager, 'pnpm', { target: 'memory' });
+      const project = searchMemories(dbManager, 'Prisma', { target: 'memory' });
+
+      assert.ok(global.some((r) => r.project === null));
+      assert.ok(project.length > 0);
+      assert.ok(project.every((r) => r.project === 'project-a'));
+    });
+
+    it('combines target "project" with an explicit project filter', () => {
+      addMemory(dbManager, 'uses Bun with PostgreSQL', 'memory', 'project-b');
+
+      const named = searchMemories(dbManager, 'PostgreSQL', { target: 'project', project: 'project-b' });
+      const anyProject = searchMemories(dbManager, 'PostgreSQL', { target: 'project' });
+      const globalOnly = searchMemories(dbManager, 'PostgreSQL', { target: 'project', project: null });
+
+      assert.ok(named.length > 0);
+      assert.ok(named.every((r) => r.project === 'project-b'));
+      assert.ok(anyProject.some((r) => r.project === 'project-a'));
+      assert.strictEqual(globalOnly.length, 0);
+    });
     it('finds pure CJK substrings with the trigram tokenizer', () => {
       addMemory(dbManager, '设备清单包含 NAS 和备份策略');
 
@@ -370,6 +495,17 @@ describe('sqlite-memory-store', () => {
       assert.ok(results.some((result) => result.content.includes('设备清单')));
     });
 
+    it('applies target "project" in the CJK literal fallback path', () => {
+      addMemory(dbManager, '项目约定使用 pnpm', 'memory', 'project-a');
+      addMemory(dbManager, '项目全局笔记');
+
+      const results = searchMemories(dbManager, '项目', { target: 'project' });
+
+      assert.ok(results.length > 0);
+      assert.ok(results.every((r) => r.project === 'project-a'));
+      assert.ok(results.every((r) => r.target === 'memory'));
+    });
+
 
     it('should match multi-word queries without requiring an exact phrase', () => {
       const results = searchMemories(dbManager, 'gpu issue');
@@ -456,6 +592,45 @@ describe('sqlite-memory-store', () => {
       const results = searchMemories(dbManager, 'AND OR NOT');
       assert.strictEqual(results.length, 0);
     });
+
+    it('ranks a dense old match above a fresher, more diluted one (BM25 before recency)', () => {
+      addMemory(dbManager, 'deploy target is the staging cluster');
+      addMemory(
+        dbManager,
+        'unrelated retrospective notes that mention deploy once among a great many other words about hiring, budgets, roadmaps, vendor calls, office moves and quarterly planning for the staging of a conference'
+      );
+      const db = dbManager.getDb();
+      db.prepare("UPDATE memories SET last_referenced = '2025-01-01' WHERE content LIKE 'deploy target%'").run();
+      db.prepare("UPDATE memories SET last_referenced = '2026-08-30' WHERE content LIKE 'unrelated retrospective%'").run();
+
+      const results = searchMemories(dbManager, 'deploy staging');
+
+      // Both rows match; recency ordering would put the long fresh note first.
+      assert.strictEqual(results.length, 2);
+      assert.ok(results[0].content.startsWith('deploy target is the staging cluster'));
+    });
+
+    it('still broadens a two-term natural-language query through the OR fallback', () => {
+      // Neither "dark" nor "chocolate" co-occur, so the implicit-AND query
+      // misses and only the OR fallback can recover this row. The existing
+      // fallback test uses three terms; this pins the two-term case.
+      addMemory(dbManager, 'user prefers dark mode UI theme', 'user');
+
+      const results = searchMemories(dbManager, 'dark chocolate', { target: 'user' });
+
+      assert.ok(results.some((r) => r.content.includes('dark mode')));
+    });
+
+    it('recovers a natural-language query whose raw FTS5 form fails to parse', () => {
+      // "DO NOT USE FIND /" passes through as raw FTS5 syntax and throws;
+      // runSearch must catch that and let the natural-language retry run.
+      addMemory(dbManager, 'Never search whole filesystem from root. Do not run find /.', 'user');
+
+      assert.doesNotThrow(() => searchMemories(dbManager, 'DO NOT USE FIND /', { target: 'user' }));
+      const results = searchMemories(dbManager, 'DO NOT USE FIND /', { target: 'user' });
+
+      assert.ok(results.some((r) => r.content.includes('find /')));
+    });
   });
 
   describe('getMemories', () => {

package/dist/extensions/pi-hermes-memory/tests/store/sqlite-native.test.ts

@@ -127,12 +127,12 @@ describe("sqlite-native loader", () => {
   it("formats actionable ABI recovery text", () => {
     const message = formatBetterSqlite3AbiError({
       originalError: new Error("NODE_MODULE_VERSION 115"),
-      packageRoot: "/Users/me/.pi/agent/npm/node_modules/better-sqlite3",
+      packageRoot: "/Users/me/.selesai/agent/npm/node_modules/better-sqlite3",
       rebuildAttempted: true,
       rebuildDetail: "exit 1",
     });
     assert.match(message, /NODE_MODULE_VERSION/);
-    assert.match(message, /\/Users\/me\/\.pi\/agent\/npm\/node_modules\/better-sqlite3/);
+    assert.match(message, /\/Users\/me\/\.selesai\/agent\/npm\/node_modules\/better-sqlite3/);
     assert.match(message, /npm rebuild better-sqlite3/);
     assert.match(message, /Homebrew/);
   });

package/dist/extensions/pi-hermes-memory/tests/tools/memory-search-tool.test.ts

@@ -66,6 +66,28 @@ describe('registerMemorySearchTool', () => {
     dbManager.close();
   });
 
+  it('accepts target "project" as a filter and shows the schema value', async () => {
+    const dbManager = makeDbManager();
+    addMemory(dbManager, 'project deployment convention', 'memory', 'project-a');
+    addMemory(dbManager, 'global deployment convention');
+    addMemory(dbManager, 'project failure deployment lesson', 'failure', 'project-a');
+
+    let captured: any;
+    registerMemorySearchTool({ registerTool: (def: any) => { captured = def; } } as any, dbManager);
+
+    assert.ok(captured.parameters.properties.target.enum.includes('project'));
+
+    const result = await captured.execute('tc-1', { query: 'deployment', target: 'project' });
+    const text = result.content[0].text;
+
+    assert.strictEqual(result.details.success, true);
+    assert.strictEqual(result.details.count, 1);
+    assert.match(text, /scope=project:project-a \[target=project\]/);
+    assert.doesNotMatch(text, /scope=global/);
+
+    dbManager.close();
+  });
+
   it('keeps copied results reversible when a project name contains brackets', async () => {
     const dbManager = makeDbManager();
     addMemory(dbManager, 'literal project entry', 'memory', 'foo] bar');

package/dist/extensions/pi-hermes-memory/tests/tools/memory-tool.test.ts

@@ -9,7 +9,7 @@ import path from "node:path";
 import { registerMemoryTool } from "../../src/tools/memory-tool.js";
 import { MemoryStore } from "../../src/store/memory-store.js";
 import { DatabaseManager } from "../../src/store/db.js";
-import { getMemories, syncMemoryEntry } from "../../src/store/sqlite-memory-store.js";
+import { getMemories, searchMemories, syncMemoryEntry } from "../../src/store/sqlite-memory-store.js";
 import { ENTRY_DELIMITER, MEMORY_FILE } from "../../src/constants.js";
 import { Value } from "typebox/value";
 
@@ -147,6 +147,42 @@ describe("registerMemoryTool", () => {
     assert.strictEqual(results[0].content, 'Entry one');
   });
 
+  it("lands over-cap policy-only adds in searchable SQLite", async () => {
+    let capturedResult: any;
+    const mockPi = {
+      registerTool: (def: any) => {
+        if (!capturedResult || def.name === "memory_add") capturedResult = def;
+      },
+    } as unknown as ExtensionAPI;
+    const store = new MemoryStore({
+      memoryMode: "policy-only",
+      memoryCharLimit: 40,
+      userCharLimit: 5000,
+      projectCharLimit: 5000,
+      nudgeInterval: 10,
+      reviewEnabled: false,
+      flushOnCompact: false,
+      flushOnShutdown: false,
+      flushMinTurns: 6,
+      autoConsolidate: false,
+      correctionDetection: false,
+      failureInjectionEnabled: true,
+      failureInjectionMaxAgeDays: 7,
+      failureInjectionMaxEntries: 5,
+      nudgeToolCalls: 15,
+      consolidationTimeoutMs: 60000,
+      memoryDir: tmpDir,
+    });
+    await store.loadFromDisk();
+    registerMemoryTool(mockPi, store, null, dbManager);
+    const first = await capturedResult.execute("tc-1", { action: "add", target: "memory", content: "alpha entry" }, undefined as any, undefined as any, undefined as any);
+    assert.strictEqual(first.details.success, true);
+    const second = await capturedResult.execute("tc-2", { action: "add", target: "memory", content: "beta entry past the tiny cap" }, undefined as any, undefined as any, undefined as any);
+    assert.strictEqual(second.details.success, true);
+    const results = searchMemories(dbManager, "beta entry past the tiny cap", { target: "memory" });
+    assert.ok(results.some((r) => r.content.includes("beta entry past the tiny cap")));
+  });
+
   it("reports the matching target when replace is sent to the wrong target", async () => {
     let removeTool: any;
     const mockPi = {

package/dist/extensions/pi-intercom/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ## [Unreleased]
 
+## [0.13.0] - 2026-09-02
+
+### Highlights
+- You can now give the current session a friendly alias from pi-intercom.
+- Aliases show up right away in the session list, messages, replies, overlays, and incoming-message displays.
+- Windows broker startup is more reliable with non-ASCII profile paths and stricter Windows Script Host setups.
+
+### Added
+- Added `/alias <name>` plus the interactive `/alias` and `/alias menu` forms for naming the current session. Thanks to [@yceachan](https://github.com/yceachan) for issue #122.
+
+### Fixed
+- Fixed hidden Windows broker startup when the user profile path contains non-ASCII characters or Windows Script Host cannot infer the VBScript engine. Thanks to [@maelo1028](https://github.com/maelo1028) for issue #121 and [@Agustin-Prieto](https://github.com/Agustin-Prieto) for issue #123.
+
 ## [0.12.1] - 2026-08-29
 
 ### Highlights

package/dist/extensions/pi-intercom/README.md

@@ -58,6 +58,20 @@ The session list only shows intercom-connected sessions, not every open Selesai
 
 If a session is unnamed, pi-intercom exposes a collision-resistant runtime-only fallback alias like `subagent-chat-1a2b3c4d-5e6f-7a8b` so other connected sessions can target it. That alias is not persisted as the Selesai session title or treated as a reconnect identity, so `selesai --resume` can keep showing the transcript snippet without allowing a different unnamed process to inherit queued mail.
 
+### Name your current session
+
+Use `/alias <name>` as a pi-intercom-friendly way to name the current session:
+
+```text
+/alias api-worker
+```
+
+The alias is Selesai's session name, so it is persisted in the session and immediately
+published to pi-intercom peers. Session lists, send/reply results, overlays, and
+incoming message headers use it when available. In an interactive UI, `/alias`
+or `/alias menu` opens an input for the current session's alias; it does not
+rename other sessions. Use `/alias <name>` in non-UI modes.
+
 ## Quick Start
 
 ### From the Keyboard
@@ -135,11 +149,11 @@ The most natural use of pi-intercom is splitting a task between two sessions —
 
 ### Setup
 
-Open two terminals and start pi in each. Name them so they can find each other:
+Open two terminals and start Selesai in each. Name them so they can find each other:
 
 ```
 # Terminal 1                    # Terminal 2
-/name planner                   /name worker
+/alias planner                 /alias worker
 ```
 
 Verify they see each other from either session:

package/dist/extensions/pi-intercom/broker/spawn.test.ts

@@ -1,7 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import path from "node:path";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import {
@@ -12,6 +12,7 @@ import {
   getWindowsBrokerCommandLine,
   getWindowsHiddenLauncherPath,
   isBrokerHealthOkMessage,
+  writeWindowsHiddenLauncher,
 } from "./spawn.ts";
 
 test("getTsxCliPath resolves tsx cli via module resolution", () => {
@@ -80,6 +81,21 @@ test("getWindowsHiddenLauncherScript runs the broker command without showing a c
   assert.match(script, /, 0, False/);
 });
 
+test("writeWindowsHiddenLauncher writes a UTF-16LE script with a BOM", () => {
+  const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-用户-"));
+  const launcherPath = path.join(intercomDir, "broker-launch.vbs");
+  const commandLine = '"C:/Users/用户/node.exe" "C:/repo/用户/broker.ts"';
+
+  try {
+    writeWindowsHiddenLauncher(commandLine, launcherPath);
+    const contents = readFileSync(launcherPath);
+    assert.deepEqual([...contents.subarray(0, 2)], [0xff, 0xfe]);
+    assert.equal(contents.toString("utf16le"), `\uFEFF${getWindowsHiddenLauncherScript(commandLine)}`);
+  } finally {
+    rmSync(intercomDir, { recursive: true, force: true });
+  }
+});
+
 test("getBrokerLaunchSpec uses wscript launcher on Windows without writing files", () => {
   const intercomDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-"));
 
@@ -94,7 +110,7 @@ test("getBrokerLaunchSpec uses wscript launcher on Windows without writing files
       "C:/Program Files/nodejs/node.exe",
     );
     assert.equal(spec.command, "wscript.exe");
-    assert.deepEqual(spec.args, [path.join(intercomDir, "broker-launch.vbs")]);
+    assert.deepEqual(spec.args, ["//E:VBScript", path.join(intercomDir, "broker-launch.vbs")]);
     assert.equal(spec.kind, "windows-launcher");
     const expectedTsxPath = getTsxCliPath("C:/repo");
     assert.equal(spec.launcherCommandLine, `"C:/Program Files/nodejs/node.exe" "${expectedTsxPath}" "C:/repo/broker.ts"`);
@@ -131,6 +147,7 @@ test("getBrokerLaunchSpec uses custom broker command on Windows", () => {
   try {
     const spec = getBrokerLaunchSpec("C:/repo/broker.ts", "bun", ["--smol"], "C:/repo", "win32", intercomDir, "C:/Program Files/nodejs/node.exe");
     assert.equal(spec.command, "wscript.exe");
+    assert.deepEqual(spec.args, ["//E:VBScript", path.join(intercomDir, "broker-launch.vbs")]);
     assert.equal(spec.kind, "windows-launcher");
     assert.equal(spec.launcherCommandLine, `"bun" "--smol" "C:/repo/broker.ts"`);
   } finally {

package/dist/extensions/pi-intercom/broker/spawn.ts

@@ -120,13 +120,13 @@ export function isBrokerHealthOkMessage(message: unknown, requestId: string): bo
     && response.version === INTERCOM_PROTOCOL_VERSION;
 }
 
-function writeWindowsHiddenLauncher(
+export function writeWindowsHiddenLauncher(
   commandLine: string,
   launcherPath: string = getWindowsHiddenLauncherPath(),
 ): string {
   ensureIntercomRuntimeDir(dirname(launcherPath));
-  writeFileSync(launcherPath, getWindowsHiddenLauncherScript(commandLine), {
-    encoding: "utf-8",
+  writeFileSync(launcherPath, `\uFEFF${getWindowsHiddenLauncherScript(commandLine)}`, {
+    encoding: "utf16le",
     mode: INTERCOM_RUNTIME_FILE_MODE,
   });
   restrictIntercomRuntimeFile(launcherPath);
@@ -147,7 +147,7 @@ export function getBrokerLaunchSpec(
     return {
       kind: "windows-launcher",
       command: "wscript.exe",
-      args: [launcherPath],
+      args: ["//E:VBScript", launcherPath],
       launcherPath,
       launcherCommandLine: getWindowsBrokerCommandLine(brokerPath, extensionDir, nodePath, brokerCommand, brokerArgs),
       captureStartupStderr: false,

package/dist/extensions/pi-intercom/index.ts

@@ -761,7 +761,7 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
     if (!liveContext) return;
     if (!liveContext.hasUI) {
       // Command handlers return void and print mode supplies a no-op UI. Keep
-      // alias guidance visible without injecting a synthetic Pi message.
+      // alias guidance visible without injecting a synthetic Selesai message.
       console.error(message);
       return;
     }

package/dist/extensions/pi-intercom/intercom.integration.test.ts

@@ -183,11 +183,13 @@ function createExtensionHarness(sessionName: string | (() => string) = "child-wo
   const lifecycleHandlers = new Map<string, Array<(event: unknown, ctx: unknown) => unknown>>();
   const commands = new Map<string, (args: string, ctx: unknown) => unknown>();
   const tools: CapturedTool[] = [];
+  let currentSessionName = typeof sessionName === "function" ? sessionName() : sessionName;
   let activeToolNames = [...(options.activeTools ?? [])];
   const entries: Array<{ type: string; data: unknown }> = [];
   const sentMessages: Array<{ message: { customType?: string; content?: string; details?: unknown }; options?: { triggerTurn?: boolean; deliverAs?: string }; activeTools: string[] }> = [];
   const pi = {
-    getSessionName: () => typeof sessionName === "function" ? sessionName() : sessionName,
+    getSessionName: () => typeof sessionName === "function" ? sessionName() : currentSessionName,
+    setSessionName: (name: string) => { currentSessionName = name; },
     events: {
       on: (channel: string, handler: (payload: unknown) => void) => {
         events.on(channel, handler);
@@ -1330,7 +1332,7 @@ test("intercom-id inserts a stable handoff snippet into the editor", { concurren
     piIntercomExtension(harness.pi as never);
     await harness.emitLifecycle("session_start");
     await harness.commands.get("intercom-id")!("", harness.ctx);
-    assert.match(editorText, /Existing note\n\nUse  pi-intercom: intercom\(\{ action: "send", to: "session-child-test", message: "\.\.\." \}\)/);
+    assert.match(editorText, /Existing note\n\nUse pi-intercom: intercom\(\{ action: "send", to: "session-child-test", message: "\.\.\." \}\)/);
     assert.match(notifications.at(-1) ?? "", /Inserted intercom contact target: session-child-test/);
     await harness.emitLifecycle("session_shutdown");
   } finally {
@@ -1338,6 +1340,123 @@ test("intercom-id inserts a stable handoff snippet into the editor", { concurren
   }
 });
 
+test("alias names the current session, opens the local input menu, and appears in intercom displays", { concurrency: false }, async () => {
+  const { planner, orchestrator, cleanup } = await setupClients();
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const inputCalls: Array<[string, string | undefined]> = [];
+  const inputValues = ["menu-worker", "no-arg-worker"];
+  const harness = createExtensionHarness("alias-worker", {
+    hasUI: true,
+    ui: {
+      input: async (title: string, placeholder?: string) => {
+        inputCalls.push([title, placeholder]);
+        return inputValues.shift();
+      },
+      notify: () => undefined,
+    },
+  });
+
+  try {
+    // Disable the background name poll for this test so the broker update
+    // proves that /alias synchronizes presence directly.
+    await withChildOrchestratorEnv({ namePollMs: "60000" }, async () => {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const initial = await waitForSessionByName(planner, "alias-worker");
+      const aliasCommand = harness.commands.get("alias")!;
+
+      await aliasCommand("direct-worker", harness.ctx);
+      const direct = await waitForSessionByName(planner, "direct-worker");
+      assert.equal(direct.id, initial.id);
+      assert.equal(harness.pi.getSessionName(), "direct-worker");
+      assert.equal(inputCalls.length, 0);
+
+      await aliasCommand("menu", harness.ctx);
+      await waitForSessionByName(planner, "menu-worker");
+      await aliasCommand("", harness.ctx);
+      const current = await waitForSessionByName(planner, "no-arg-worker");
+      assert.equal(current.id, initial.id);
+      assert.deepEqual(inputCalls, [
+        ["Set session alias", "Current alias: direct-worker"],
+        ["Set session alias", "Current alias: menu-worker"],
+      ]);
+
+      const intercomTool = harness.tools.find((tool) => tool.name === "intercom")!;
+      const listed = await intercomTool.execute("alias-list", { action: "list" }, new AbortController().signal, undefined, harness.ctx);
+      assert.match(listed.content[0]?.text ?? "", /no-arg-worker/);
+
+      orchestrator.updatePresence({ name: "alias-orchestrator" });
+      await waitForSessionByName(planner, "alias-orchestrator");
+      const outgoing = once(orchestrator, "message") as Promise<[SessionInfo, Message]>;
+      const sendResult = await intercomTool.execute("alias-send", {
+        action: "send",
+        to: "alias-orchestrator",
+        message: "Alias display check.",
+      }, new AbortController().signal, undefined, harness.ctx);
+      assert.equal(sendResult.content[0]?.text, "Message sent to alias-orchestrator");
+      assert.equal((await outgoing)[1].content.text, "Alias display check.");
+
+      const askId = "alias-reply-ask";
+      assert.equal((await orchestrator.send(initial.id, {
+        messageId: askId,
+        text: "Reply using the alias.",
+        expectsReply: true,
+      })).delivered, true);
+      await new Promise((resolve) => setTimeout(resolve, 25));
+      const replyReceived = waitForReply(orchestrator, askId);
+      const replyResult = await intercomTool.execute("alias-reply", {
+        action: "reply",
+        replyTo: askId,
+        message: "Alias reply display check.",
+      }, new AbortController().signal, undefined, harness.ctx);
+      assert.equal(replyResult.content[0]?.text, "Reply sent to alias-orchestrator");
+      assert.equal((await replyReceived).message.content.text, "Alias reply display check.");
+    });
+  } finally {
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
+test("alias reports no-UI usage and current alias without hanging", { concurrency: false }, async () => {
+  const { planner, cleanup } = await setupClients();
+  const { default: piIntercomExtension } = await import("./index.ts");
+  const output: string[] = [];
+  const previousConsoleError = console.error;
+  console.error = (...args: unknown[]) => {
+    output.push(args.map((value) => String(value)).join(" "));
+  };
+  const harness = createExtensionHarness("no-ui-worker");
+
+  try {
+    await withChildOrchestratorEnv({ namePollMs: "60000" }, async () => {
+      piIntercomExtension(harness.pi as never);
+      await harness.emitLifecycle("session_start");
+      const initial = await waitForSessionByName(planner, "no-ui-worker");
+      const aliasCommand = harness.commands.get("alias")!;
+
+      await aliasCommand("no-ui-renamed", harness.ctx);
+      const renamed = await waitForSessionByName(planner, "no-ui-renamed");
+      assert.equal(renamed.id, initial.id);
+      assert.equal(harness.pi.getSessionName(), "no-ui-renamed");
+      assert.deepEqual(output, ["Session alias set: no-ui-renamed"]);
+
+      output.length = 0;
+      await aliasCommand("", harness.ctx);
+      assert.deepEqual(output, ["Session alias: no-ui-renamed"]);
+
+      output.length = 0;
+      await aliasCommand("menu", harness.ctx);
+      assert.deepEqual(output, ["The alias menu requires an interactive UI; use /alias <name>."]);
+      assert.equal(harness.pi.getSessionName(), "no-ui-renamed");
+    });
+  } finally {
+    console.error = previousConsoleError;
+    await harness.emitLifecycle("session_shutdown");
+    await cleanup();
+  }
+});
+
 test("intercom tool shows unique ID prefixes when names collide", { concurrency: false }, async () => {
   const { cleanup } = await setupClients();
   const { default: piIntercomExtension } = await import("./index.ts");

package/dist/extensions/pi-intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-intercom",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "license": "MIT",
   "type": "module",
   "main": "index.ts",

package/dist/extensions/pi-intercom/project-agent.test.ts

@@ -90,7 +90,7 @@ test("openProjectPane opens a Herdr pane and runs pi in the project", async () =
     assert.equal(launched.paneId, "pane-1");
     assert.equal(launched.herdrVersion, "herdr 0.7.5");
     assert.deepEqual(calls[1], ["pane", "split", "--current", "--direction", "right", "--cwd", launched.projectRoot]);
-    assert.deepEqual(calls[2], ["pane", "run", "pane-1", "'pi'"]);
+    assert.deepEqual(calls[2], ["pane", "run", "pane-1", "selesai"]);
   } finally {
     rmSync(root, { recursive: true, force: true });
   }

package/dist/extensions/pi-intercom/project-agent.ts

@@ -171,11 +171,6 @@ function extractPaneId(value: unknown): string | undefined {
   return undefined;
 }
 
-function shellQuote(value: string): string {
-  if (process.platform === "win32") return `"${value.replaceAll('"', '\\"')}"`;
-  return `'${value.replaceAll("'", "'\\''")}'`;
-}
-
 function resolveProjectRoot(cwd: string): string {
   const resolved = resolve(cwd);
   const stat = statSync(resolved);
@@ -242,7 +237,7 @@ export async function openProjectPane(input: {
   const paneId = extractPaneId(split.data);
   if (!paneId) throw new Error("Herdr project pane error (PANE_GONE): pane split returned no pane id.");
 
-  const command = shellQuote(process.env.SELESAI_INTERCOM_BINARY?.trim() || process.env.SELESAI_BIN?.trim() || "selesai");
+  const command = process.env.SELESAI_INTERCOM_BINARY?.trim() || process.env.SELESAI_BIN?.trim() || "selesai";
   const started = await client.run(["pane", "run", paneId, command], { timeoutMs: 15_000, signal: input.signal });
   if (started.ok === false) {
     await client.run(["pane", "close", paneId], { timeoutMs: 5_000 });