You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maka.apache.org by as...@apache.org on 2026/08/25 01:43:31 UTC
(maka) branch main updated: feat(desktop): preserve WorkHub routing context (#3674)
This is an automated email from the ASF dual-hosted git repository.
Astro-Han pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/maka.git
The following commit(s) were added to refs/heads/main by this push:
new 464b69391 feat(desktop): preserve WorkHub routing context (#3674)
464b69391 is described below
commit 464b69391911d3c70d61063b9d71d384eb4a7da6
Author: ChengBo Zhang <66...@users.noreply.github.com>
AuthorDate: Tue Aug 25 09:43:26 2026 +0800
feat(desktop): preserve WorkHub routing context (#3674)
* feat(desktop): preserve WorkHub routing context
Seed current and previous focus from existing Sessions and support first natural-language corrections without introducing another authority.
Generated-by: Codex
* fix(desktop): preserve WorkHub correction order
Generated-by: Codex
* fix(desktop): preserve WorkHub root ownership
Generated-by: Codex
* fix(desktop): coordinate pending WorkHub ownership
Generated-by: Codex
* fix(desktop): harden WorkHub ownership reconciliation
Generated-by: Codex
* docs: refresh Astryx surface inventory
Generated-by: Codex
* fix(desktop): retry stop after late root admission
A successful Stop for an unconfirmed reserved turn may be a Host no-op. Keep that turn out of the final stopped set so settlement retries Stop after admission.
Generated-by: Codex
* fix(desktop): separate post-admission stop retry
Admission can complete while the pre-admission Stop reply is still in flight. Await that attempt, then issue a distinct Stop against the now-admitted root instead of joining the earlier no-op promise.
Generated-by: Codex
---
.maka-shots/workhub-context-after.png | Bin 0 -> 226633 bytes
.maka-shots/workhub-context-before.png | Bin 0 -> 226498 bytes
apps/desktop/e2e/workhub-reconstruction.spec.ts | 50 +-
.../runtime-host-session-catalog-preload.test.ts | 15 +-
...runtime-host-session-execution-ipc-main.test.ts | 20 +-
.../src/main/__tests__/workhub-controller.test.ts | 1501 +++++++++++++++++++-
.../main/__tests__/workhub-session-port.test.ts | 181 ++-
.../main/__tests__/workhub-surface-flow.test.ts | 21 +-
.../runtime-host-session-execution-ipc-main.ts | 4 +-
apps/desktop/src/preload/bridge-contract.d.ts | 4 +
apps/desktop/src/preload/preload.ts | 23 +-
.../src/preload/runtime-host-session-catalog.ts | 35 +-
apps/desktop/src/renderer/app-shell.tsx | 24 +-
apps/desktop/src/renderer/styles/workhub.css | 9 +
apps/desktop/src/renderer/workhub-controller.ts | 517 ++++++-
apps/desktop/src/renderer/workhub-route-policy.ts | 160 ++-
apps/desktop/src/renderer/workhub-session-port.ts | 91 +-
apps/desktop/src/renderer/workhub-surface.tsx | 62 +-
docs/workhub-domain-language.md | 51 +-
19 files changed, 2638 insertions(+), 130 deletions(-)
diff --git a/.maka-shots/workhub-context-after.png b/.maka-shots/workhub-context-after.png
new file mode 100644
index 000000000..8b82852c0
Binary files /dev/null and b/.maka-shots/workhub-context-after.png differ
diff --git a/.maka-shots/workhub-context-before.png b/.maka-shots/workhub-context-before.png
new file mode 100644
index 000000000..a2903e2e5
Binary files /dev/null and b/.maka-shots/workhub-context-before.png differ
diff --git a/apps/desktop/e2e/workhub-reconstruction.spec.ts b/apps/desktop/e2e/workhub-reconstruction.spec.ts
index d81dec386..e853d7f73 100644
--- a/apps/desktop/e2e/workhub-reconstruction.spec.ts
+++ b/apps/desktop/e2e/workhub-reconstruction.spec.ts
@@ -44,14 +44,16 @@ test('WorkHub rebuilds Session conversation after navigating away and back', asy
}),
).toBeVisible();
- const routedPrompt = `继续${sessionName},补充重复投递测试点。`;
+ const routedPrompt = '继续这个工作,补充重复投递测试点。';
const workHubComposer = page.locator(
'.workhub-surface .maka-composer-editor [contenteditable="true"]',
);
await workHubComposer.fill(routedPrompt);
await workHubComposer.press('Enter');
await expect(page.locator('.workhub-submitted').last()).toBeVisible();
- await page.locator('.workhub-submitted > button').last().click();
+ await page.locator('.workhub-turn', { hasText: routedPrompt })
+ .locator('.workhub-submitted > button')
+ .click();
await expect(page.getByRole('main', { name: 'WorkHub' })).toBeHidden();
await page.getByRole('button', { name: 'WorkHub', exact: true }).click();
@@ -62,3 +64,47 @@ test('WorkHub rebuilds Session conversation after navigating away and back', asy
}),
).toBeVisible();
});
+
+test('WorkHub handles a first natural-language correction', async ({
+ window: page,
+}) => {
+ const composer = page.locator(COMPOSER_INPUT);
+ await composer.fill('检查支付回调重复投递时的幂等性');
+ await composer.press('Enter');
+ await expect(page.getByRole('button', { name: '重新生成' })).toHaveCount(1, {
+ timeout: 20_000,
+ });
+ await page.evaluate(async () => {
+ await window.maka.settings.updateClient({ workHub: { enabled: true } });
+ });
+ await expect(page.getByRole('main', { name: 'WorkHub' })).toBeVisible();
+ await page.evaluate(async () => {
+ await window.maka.sessions.create({ name: '登录稳定性' });
+ });
+ await expect(page.getByText('2 项工作', { exact: true })).toBeVisible();
+
+ const workHubComposer = page.locator(
+ '.workhub-surface .maka-composer-editor [contenteditable="true"]',
+ );
+ await workHubComposer.fill('继续这个工作,补充重复投递测试点。');
+ await workHubComposer.press('Enter');
+ const continuedTurn = page.locator('.workhub-turn', {
+ hasText: '继续这个工作,补充重复投递测试点。',
+ });
+ await expect(
+ continuedTurn.locator('.workhub-submitted-session strong'),
+ ).toHaveText('检查支付回调重复投递时的幂等性');
+
+ await workHubComposer.fill('不是这个,换成登录稳定性,补充刷新令牌失败判定。');
+ await expect(
+ page.locator('.workhub-surface').getByRole('button', { name: '发送' }),
+ ).toBeEnabled();
+ await workHubComposer.press('Enter');
+
+ await expect(page.locator('.workhub-correction-note').last()).toBeVisible();
+ await expect(
+ page.locator('.workhub-turn', {
+ hasText: '不是这个,换成登录稳定性,补充刷新令牌失败判定。',
+ }).locator('.workhub-submitted-session strong'),
+ ).toHaveText('登录稳定性');
+});
diff --git a/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts b/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts
index b90e6bbd8..99441165b 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-session-catalog-preload.test.ts
@@ -20,7 +20,10 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import type { DesktopSessionSummary } from '../../preload/bridge-contract.js';
-import { collectRuntimeHostSessionCatalogs } from '../../preload/runtime-host-session-catalog.js';
+import {
+ collectRuntimeHostSessionCatalogs,
+ collectRuntimeHostSessionCatalogsWithCoverage,
+} from '../../preload/runtime-host-session-catalog.js';
function session(id: string, activityAt: number): DesktopSessionSummary {
return { id, activityAt } as DesktopSessionSummary;
@@ -36,6 +39,16 @@ test('keeps healthy Host catalogs when another Host rejects', async () => {
assert.deepEqual(sessions.map(({ id }) => id), ['newer', 'older']);
});
+test('reports exactly which Host catalogs are complete', async () => {
+ const catalog = await collectRuntimeHostSessionCatalogsWithCoverage([
+ { hostId: 'local', sessions: Promise.resolve([session('local-session', 1)]) },
+ { hostId: 'remote', sessions: Promise.reject(new Error('remote unavailable')) },
+ ]);
+
+ assert.deepEqual(catalog.sessions.map(({ id }) => id), ['local-session']);
+ assert.deepEqual(catalog.completeHostIds, ['local']);
+});
+
test('fails when every Host catalog rejects', async () => {
await assert.rejects(
collectRuntimeHostSessionCatalogs([
diff --git a/apps/desktop/src/main/__tests__/runtime-host-session-execution-ipc-main.test.ts b/apps/desktop/src/main/__tests__/runtime-host-session-execution-ipc-main.test.ts
index a59a82cf6..4514ea326 100644
--- a/apps/desktop/src/main/__tests__/runtime-host-session-execution-ipc-main.test.ts
+++ b/apps/desktop/src/main/__tests__/runtime-host-session-execution-ipc-main.test.ts
@@ -609,7 +609,7 @@ test("queues a mid-turn send as steering when the Host reports the session busy"
assert.deepEqual(submits, [
{
sessionId: "session-1",
- messageId: "id-1",
+ messageId: "turn-1",
content: { text: "also check the tests", inlineReferences: [] },
placement: "current_turn",
},
@@ -629,6 +629,7 @@ test("queues a mid-turn send as steering when the Host reports the session busy"
test("starts the turn from the queued message when the busy race resolves idle", async () => {
const changes: unknown[] = [];
+ const submits: unknown[] = [];
const ipc = ipcHarness();
registerExecutionIpc(
{
@@ -641,10 +642,13 @@ test("starts the turn from the queued message when the busy race resolves idle",
"Session already has an active root Turn",
);
},
- submitMessage: async () => ({
- disposition: "turn_started",
- turnId: "turn-9",
- }),
+ submitMessage: async (input) => {
+ submits.push(input);
+ return {
+ disposition: "turn_started",
+ turnId: "turn-9",
+ };
+ },
}),
observer: unusedObserver(),
attachmentApprovals: createAttachmentApprovalRegistry(),
@@ -671,6 +675,12 @@ test("starts the turn from the queued message when the busy race resolves idle",
inlineReferences: [],
skillInvocation: { loaded: [], failed: [], receipts: [] },
});
+ assert.deepEqual(submits, [{
+ sessionId: "session-1",
+ messageId: "turn-1",
+ content: { text: "also check the tests", inlineReferences: [] },
+ placement: "current_turn",
+ }]);
assert.deepEqual(changes, [
{ reason: "status-change", sessionId: "session-1", turnId: "turn-9" },
]);
diff --git a/apps/desktop/src/main/__tests__/workhub-controller.test.ts b/apps/desktop/src/main/__tests__/workhub-controller.test.ts
index 509c13179..821c69c24 100644
--- a/apps/desktop/src/main/__tests__/workhub-controller.test.ts
+++ b/apps/desktop/src/main/__tests__/workhub-controller.test.ts
@@ -18,16 +18,36 @@
*/
import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
import test from 'node:test';
import {
createWorkHubController,
+ WorkHubSessionSubmitError,
WORKHUB_ROUTING_STRATEGY_ID,
type WorkHubSessionFacts,
type WorkHubSessionPort,
} from '../../renderer/workhub-controller.js';
-test('binds the controller to the immutable WH-R2.3 strategy ID', () => {
- assert.equal(WORKHUB_ROUTING_STRATEGY_ID, 'wh-r2.3-session-core-evidence');
+const appShellUrl = [
+ new URL('../../renderer/app-shell.tsx', import.meta.url),
+ new URL('../../../src/renderer/app-shell.tsx', import.meta.url),
+].find((candidate) => existsSync(candidate));
+
+if (!appShellUrl) throw new Error('Could not locate renderer/app-shell.tsx');
+
+test('binds the controller to the immutable WH-R2.4 strategy ID', () => {
+ assert.equal(WORKHUB_ROUTING_STRATEGY_ID, 'wh-r2.4-session-context-continuity');
+});
+
+test('binds the WorkHub controller to the app runtime rather than project refreshes', () => {
+ const source = readFileSync(appShellUrl, 'utf8');
+
+ assert.match(source, /workHubControllerRef\s*=\s*useRef/u);
+ assert.match(source, /workHubProjectsRef\.current\s*=\s*projects/u);
+ assert.doesNotMatch(
+ source,
+ /useMemo\(\(\)\s*=>\s*createWorkHubController\([\s\S]*?\),\s*\[projects\]\)/u,
+ );
});
function session(
@@ -47,6 +67,7 @@ function session(
}
function port(sessions: WorkHubSessionFacts[]): WorkHubSessionPort {
+ let nextTurnId = 0;
return {
list: async () => sessions,
recentTurns: async () => [],
@@ -54,9 +75,11 @@ function port(sessions: WorkHubSessionFacts[]): WorkHubSessionPort {
create: async () => {
throw new Error('create is not used by this read test');
},
+ reserveTurnId: () => `reserved-turn-${++nextTurnId}`,
submit: async () => {
throw new Error('submit is not used by this read test');
},
+ reconcileSubmission: async () => ({ kind: 'unknown' }),
stop: async () => {},
subscribe: () => () => {},
};
@@ -194,7 +217,7 @@ test('submit sends an explicitly targeted request to that Session', async () =>
assert.deepEqual(result, {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-1',
target: { sessionId: 'payment' },
turnId: 'turn-payment',
@@ -224,7 +247,7 @@ test('submit routes a unique complete Session name without asking', async () =>
assert.deepEqual(result, {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-exact',
target: { sessionId: 'payment' },
turnId: 'turn-exact',
@@ -333,7 +356,7 @@ test('submit asks the user when weak relevance matches more than one Session', a
assert.deepEqual(result, {
kind: 'clarification',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-ambiguous',
text: '继续处理重复问题',
options: [
@@ -478,7 +501,7 @@ test('submit follows an unambiguous reference to the most recent Work', async ()
assert.deepEqual(result, {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-pronoun',
target: { sessionId: 'payment' },
turnId: 'turn-2',
@@ -487,6 +510,280 @@ test('submit follows an unambiguous reference to the most recent Work', async ()
assert.deepEqual(submitted, ['payment', 'payment']);
});
+test('read seeds current and previous focus from pre-existing ordinary Sessions', async () => {
+ const submitted: string[] = [];
+ const sessions = port([
+ session('login', { sessionName: '登录刷新令牌', updatedAt: 20 }),
+ session('payment', { sessionName: '支付回调幂等性', updatedAt: 30 }),
+ session('archived', { archived: true, updatedAt: 40 }),
+ ]);
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: `turn-${submitted.length}` };
+ };
+ const controller = createWorkHubController({ sessions });
+
+ await controller.read();
+ const current = await controller.submit({
+ requestId: 'request-current-seed',
+ text: '继续这个工作',
+ });
+ const previous = await controller.submit({
+ requestId: 'request-previous-seed',
+ text: '回到上一个工作',
+ });
+
+ assert.deepEqual(current.kind === 'submitted' ? current.target : undefined, {
+ sessionId: 'payment',
+ });
+ assert.deepEqual(previous.kind === 'submitted' ? previous.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(submitted, ['payment', 'login']);
+});
+
+test('read prefers the Session active when WorkHub opens over raw recency', async () => {
+ const submitted: string[] = [];
+ const sessions = port([
+ session('login', { sessionName: '登录刷新令牌', updatedAt: 20 }),
+ session('payment', { sessionName: '支付回调幂等性', updatedAt: 30 }),
+ ]);
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: 'turn-login' };
+ };
+ const controller = createWorkHubController({ sessions });
+
+ await controller.read({ focus: { sessionId: 'login' } });
+ const result = await controller.submit({
+ requestId: 'request-active-seed',
+ text: '继续这个工作',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(submitted, ['login']);
+});
+
+test('a stale opening read cannot overwrite a newer WorkHub focus', async () => {
+ const pendingReads: Array<{
+ resolve(value: WorkHubSessionFacts[]): void;
+ promise: Promise<WorkHubSessionFacts[]>;
+ }> = [];
+ const sessions = port([]);
+ sessions.list = () => {
+ let resolve!: (value: WorkHubSessionFacts[]) => void;
+ const promise = new Promise<WorkHubSessionFacts[]>((next) => {
+ resolve = next;
+ });
+ pendingReads.push({ resolve, promise });
+ return promise;
+ };
+ const submitted: string[] = [];
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: 'turn-newer-focus' };
+ };
+ const controller = createWorkHubController({ sessions });
+ const older = controller.read({ focus: { sessionId: 'payment' } });
+ const newer = controller.read({ focus: { sessionId: 'login' } });
+ const facts = [
+ session('login', { updatedAt: 20 }),
+ session('payment', { updatedAt: 30 }),
+ ];
+
+ pendingReads[1]!.resolve(facts);
+ await newer;
+ pendingReads[0]!.resolve([facts[1]!]);
+ await older;
+ sessions.list = async () => facts;
+ const result = await controller.submit({
+ requestId: 'request-after-stale-read',
+ text: '继续这个工作',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(submitted, ['login']);
+});
+
+test('an unavailable opening focus falls back to recent routable Sessions', async () => {
+ const submitted: string[] = [];
+ const sessions = port([
+ session('archived', { archived: true, updatedAt: 40 }),
+ session('login', { updatedAt: 20 }),
+ session('payment', { updatedAt: 30 }),
+ ]);
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: 'turn-fallback' };
+ };
+ const controller = createWorkHubController({ sessions });
+
+ await controller.read({ focus: { sessionId: 'archived' } });
+ const result = await controller.submit({
+ requestId: 'request-fallback-focus',
+ text: '继续这个工作',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'payment',
+ });
+ assert.deepEqual(submitted, ['payment']);
+});
+
+test('focus falls back when the current Session is archived after WorkHub opens', async () => {
+ let catalog = [
+ session('login', { updatedAt: 20 }),
+ session('payment', { updatedAt: 30 }),
+ ];
+ const sessions = port(catalog);
+ sessions.list = async () => catalog;
+ const submitted: string[] = [];
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: 'turn-focus-fallback' };
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read();
+ catalog = catalog.map((entry) => entry.target.sessionId === 'payment'
+ ? { ...entry, archived: true }
+ : entry);
+
+ const result = await controller.submit({
+ requestId: 'request-after-current-archive',
+ text: '继续这个工作',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(submitted, ['login']);
+});
+
+test('resetVisitContext discards focus from a previous WorkHub mount', async () => {
+ let catalog = [
+ session('login', { updatedAt: 20 }),
+ session('payment', { updatedAt: 30 }),
+ ];
+ const sessions = port(catalog);
+ sessions.list = async () => catalog;
+ const submitted: string[] = [];
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: `turn-${submitted.length}` };
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read({ focus: { sessionId: 'login' } });
+ controller.resetVisitContext();
+ catalog = catalog.map((entry) => entry.target.sessionId === 'payment'
+ ? { ...entry, updatedAt: 40 }
+ : entry);
+ await controller.read();
+
+ const result = await controller.submit({
+ requestId: 'request-after-remount',
+ text: '继续这个工作',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'payment',
+ });
+});
+
+test('an in-flight submit cannot restore visit focus after WorkHub unmounts', async () => {
+ const sessions = port([
+ session('login', { updatedAt: 20 }),
+ session('payment', { updatedAt: 30 }),
+ ]);
+ let signalSubmitStarted!: () => void;
+ const submitStarted = new Promise<void>((resolve) => {
+ signalSubmitStarted = resolve;
+ });
+ let finishSubmit!: (value: { turnId: string }) => void;
+ const pendingTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishSubmit = resolve;
+ });
+ sessions.submit = async () => {
+ signalSubmitStarted();
+ return pendingTurn;
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read({ focus: { sessionId: 'login' } });
+ const inFlight = controller.submit({
+ requestId: 'request-before-unmount',
+ text: '继续这个工作',
+ });
+ await submitStarted;
+ controller.resetVisitContext();
+ finishSubmit({ turnId: 'turn-login' });
+ await inFlight;
+
+ const submitted: string[] = [];
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: 'turn-after-remount' };
+ };
+ await controller.read();
+ const result = await controller.submit({
+ requestId: 'request-after-in-flight',
+ text: '继续这个工作',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'payment',
+ });
+ assert.deepEqual(submitted, ['payment']);
+});
+
+test('an old submit resolves against the visit focus captured before an await', async () => {
+ const catalog = [
+ session('login', { updatedAt: 20 }),
+ session('payment', { updatedAt: 30 }),
+ ];
+ const sessions = port(catalog);
+ const controller = createWorkHubController({ sessions });
+ await controller.read({ focus: { sessionId: 'login' } });
+
+ let signalListStarted!: () => void;
+ const listStarted = new Promise<void>((resolve) => {
+ signalListStarted = resolve;
+ });
+ let finishOldList!: (value: WorkHubSessionFacts[]) => void;
+ const oldList = new Promise<WorkHubSessionFacts[]>((resolve) => {
+ finishOldList = resolve;
+ });
+ let blockNextList = true;
+ sessions.list = async () => {
+ if (!blockNextList) return catalog;
+ blockNextList = false;
+ signalListStarted();
+ return oldList;
+ };
+ const submitted: string[] = [];
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: 'turn-' + target.sessionId };
+ };
+
+ const oldSubmission = controller.submit({
+ requestId: 'request-old-visit',
+ text: '继续这个工作',
+ });
+ await listStarted;
+ controller.resetVisitContext();
+ await controller.read({ focus: { sessionId: 'payment' } });
+ finishOldList(catalog);
+
+ const result = await oldSubmission;
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(submitted, ['login']);
+});
+
test('submit routes strong core evidence instead of reusing recent focus', async () => {
const submitted: string[] = [];
const sessions = port([
@@ -517,7 +814,7 @@ test('submit routes strong core evidence instead of reusing recent focus', async
assert.deepEqual(result, {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-topic-shift',
target: { sessionId: 'payment' },
turnId: 'turn-2',
@@ -553,7 +850,7 @@ test('submit routes unique strong core evidence without asking', async () => {
if (result.kind !== 'submitted') return;
assert.deepEqual(result.target, { sessionId: 'login' });
assert.equal(result.evidence, 'core_entity');
- assert.equal(result.strategyId, 'wh-r2.3-session-core-evidence');
+ assert.equal(result.strategyId, 'wh-r2.4-session-context-continuity');
assert.deepEqual(submitted, ['login']);
});
@@ -579,14 +876,14 @@ test('submit ignores shared boilerplate when an executable request names a new t
if (result.kind !== 'submitted') return;
assert.deepEqual(result.target, { sessionId: 'payment-new' });
assert.equal(result.evidence, 'new_session');
- assert.equal(result.strategyId, 'wh-r2.3-session-core-evidence');
+ assert.equal(result.strategyId, 'wh-r2.4-session-context-continuity');
assert.deepEqual(createdNames, ['检查支付回调重复投递']);
});
-test('submit keeps a unique two-character clue behind clarification', async () => {
+test('submit keeps a foreign two-character clue behind clarification', async () => {
const sessions = port([
- session('login', { sessionName: '登录稳定性' }),
- session('payment', { sessionName: '支付稳定性' }),
+ session('login', { sessionName: '登录稳定性', updatedAt: 10 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 20 }),
]);
const controller = createWorkHubController({ sessions });
@@ -596,7 +893,7 @@ test('submit keeps a unique two-character clue behind clarification', async () =
});
assert.equal(result.kind, 'clarification');
- assert.equal(result.strategyId, 'wh-r2.3-session-core-evidence');
+ assert.equal(result.strategyId, 'wh-r2.4-session-context-continuity');
});
test('submit treats explicit user uncertainty as clarification instead of a new Session', async () => {
@@ -793,29 +1090,1177 @@ test('route correction never stops a root Turn that WorkHub only steered into',
assert.deepEqual(stopped, []);
});
-test('latest route correction wins for the same expression family', async () => {
+test('first natural-language correction reroutes and stops the wrong WorkHub-owned Turn', async () => {
+ const submitted: string[] = [];
+ const stopped: Array<[string, string]> = [];
const sessions = port([
- session('login', { sessionName: '登录稳定性' }),
- session('payment', { sessionName: '支付稳定性' }),
+ session('login', {
+ sessionName: '登录稳定性',
+ latestResult: '刷新令牌过期导致重复登录',
+ updatedAt: 20,
+ }),
+ session('payment', {
+ sessionName: '支付稳定性',
+ latestResult: '支付回调重复投递',
+ updatedAt: 30,
+ }),
]);
- sessions.submit = async (_target) => ({ turnId: 'turn' });
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: `turn-${submitted.length}` };
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read();
+ await controller.submit({
+ requestId: 'request-wrong-payment',
+ text: '继续这个工作,补充验收项',
+ });
+
+ const corrected = await controller.submit({
+ requestId: 'request-natural-correction',
+ text: '不是这个,换成登录那个,补充刷新令牌失败判定',
+ });
+
+ assert.equal(corrected.kind, 'submitted');
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.equal(
+ corrected.kind === 'submitted' ? corrected.evidence : undefined,
+ 'route_correction',
+ );
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.correctedFrom : undefined, {
+ sessionId: 'payment',
+ });
+ assert.deepEqual(stopped, [['payment', 'turn-1']]);
+ assert.deepEqual(submitted, ['payment', 'login']);
+});
+
+test('content-level replacement instructions stay inside the focused Session', async () => {
+ const submitted: string[] = [];
+ const stopped: string[] = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ session('database', {
+ sessionName: '数据库迁移',
+ latestResult: 'Postgres schema migration',
+ updatedAt: 10,
+ }),
+ ]);
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: `turn-${submitted.length}` };
+ };
+ sessions.stop = async (target) => {
+ stopped.push(target.sessionId);
+ };
const controller = createWorkHubController({ sessions });
+ await controller.read();
+ await controller.submit({
+ requestId: 'request-before-content-change',
+ text: '继续这个工作',
+ });
+
+ const result = await controller.submit({
+ requestId: 'request-content-change',
+ text: '继续这个工作,Redis 配置不对,改成 Postgres',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'payment',
+ });
+ assert.equal(result.kind === 'submitted' ? result.evidence : undefined, 'recent_focus');
+ assert.deepEqual(stopped, []);
+});
+test('steering the same WorkHub-owned root preserves ownership for a later correction', async () => {
+ const submitted: string[] = [];
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ let paymentSubmissions = 0;
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ if (target.sessionId === 'payment') {
+ paymentSubmissions += 1;
+ return paymentSubmissions === 1
+ ? { turnId: 'turn-payment-root' }
+ : { turnId: 'turn-payment-steering-command', steered: true };
+ }
+ return { turnId: 'turn-login-' + submitted.length };
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read();
await controller.submit({
- requestId: 'correction-login',
- text: '继续白鹭点,列出验收项。',
+ requestId: 'request-owned-root',
+ text: '继续这个工作',
+ });
+ await controller.submit({
+ requestId: 'request-other-owned-root',
+ text: '先检查登录稳定性',
explicitTarget: { sessionId: 'login' },
- correction: { from: { sessionId: 'payment' }, turnId: 'turn' },
});
await controller.submit({
- requestId: 'correction-payment',
- text: '继续白鹭点,列出异常项。',
+ requestId: 'request-steer-owned-root',
+ text: '继续这个工作,补充测试点',
explicitTarget: { sessionId: 'payment' },
- correction: { from: { sessionId: 'login' }, turnId: 'turn' },
});
- const result = await controller.submit({
- requestId: 'correction-latest',
+ const corrected = await controller.submit({
+ requestId: 'request-correct-owned-root',
+ text: '不是这个工作,换成登录稳定性',
+ });
+
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(stopped, [['payment', 'turn-payment-root']]);
+});
+
+test('a late root completion cannot overwrite newer ownership after remount', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ let signalOlderStarted!: () => void;
+ const olderStarted = new Promise<void>((resolve) => {
+ signalOlderStarted = resolve;
+ });
+ let finishOlder!: (value: { turnId: string }) => void;
+ const olderTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishOlder = resolve;
+ });
+ let paymentSubmissions = 0;
+ sessions.submit = async (target) => {
+ if (target.sessionId === 'payment') {
+ paymentSubmissions += 1;
+ if (paymentSubmissions === 1) {
+ signalOlderStarted();
+ return olderTurn;
+ }
+ return { turnId: 'turn-payment-new' };
+ }
+ return { turnId: 'turn-login' };
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ const olderSubmission = controller.submit({
+ requestId: 'request-payment-old',
+ text: '先继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ await olderStarted;
+ controller.resetVisitContext();
+ await controller.submit({
+ requestId: 'request-payment-new',
+ text: '重新继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ finishOlder({ turnId: 'turn-payment-old' });
+ await olderSubmission;
+
+ const corrected = await controller.submit({
+ requestId: 'request-correct-after-late-root',
+ text: '不是这个工作,换成登录稳定性',
+ });
+
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(stopped, [['payment', 'turn-payment-new']]);
+});
+
+test('a correction after remount stops a root whose admission is still pending', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ let signalPaymentStarted!: () => void;
+ const paymentStarted = new Promise<void>((resolve) => {
+ signalPaymentStarted = resolve;
+ });
+ let finishPayment!: (value: { turnId: string }) => void;
+ const paymentTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishPayment = resolve;
+ });
+ let nextReservedTurnId = 0;
+ sessions.reserveTurnId = () => `turn-reserved-${++nextReservedTurnId}`;
+ sessions.submit = async (target, _text, turnId) => {
+ if (target.sessionId === 'payment') {
+ assert.equal(turnId, 'turn-reserved-1');
+ signalPaymentStarted();
+ return paymentTurn;
+ }
+ return { turnId };
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ const pendingSubmission = controller.submit({
+ requestId: 'request-payment-pending',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ await paymentStarted;
+ controller.resetVisitContext();
+ await controller.read({ focus: { sessionId: 'payment' } });
+
+ const corrected = await controller.submit({
+ requestId: 'request-correct-pending-root',
+ text: '不是这个工作,换成登录稳定性',
+ });
+
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(stopped, [['payment', 'turn-reserved-1']]);
+ finishPayment({ turnId: 'turn-payment-host-rebound' });
+ await pendingSubmission;
+ assert.deepEqual(stopped, [
+ ['payment', 'turn-reserved-1'],
+ ['payment', 'turn-payment-host-rebound'],
+ ]);
+});
+
+test('a correction retries Stop when the same reserved root is admitted before Stop settles', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ let signalPaymentStarted!: () => void;
+ const paymentStarted = new Promise<void>((resolve) => {
+ signalPaymentStarted = resolve;
+ });
+ let finishPayment!: (value: { turnId: string }) => void;
+ const paymentTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishPayment = resolve;
+ });
+ sessions.reserveTurnId = () => 'turn-reserved-1';
+ sessions.submit = async (target, _text, turnId) => {
+ if (target.sessionId === 'payment') {
+ assert.equal(turnId, 'turn-reserved-1');
+ signalPaymentStarted();
+ return paymentTurn;
+ }
+ return { turnId };
+ };
+ let signalFirstStopStarted!: () => void;
+ const firstStopStarted = new Promise<void>((resolve) => {
+ signalFirstStopStarted = resolve;
+ });
+ let finishFirstStop!: () => void;
+ const firstStop = new Promise<void>((resolve) => {
+ finishFirstStop = resolve;
+ });
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ if (stopped.length === 1) {
+ signalFirstStopStarted();
+ await firstStop;
+ }
+ };
+ const controller = createWorkHubController({ sessions });
+
+ const pendingSubmission = controller.submit({
+ requestId: 'request-payment-same-id-pending',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ await paymentStarted;
+ controller.resetVisitContext();
+ await controller.read({ focus: { sessionId: 'payment' } });
+
+ const correction = controller.submit({
+ requestId: 'request-correct-same-id-pending-root',
+ text: '不是这个工作,换成登录稳定性',
+ });
+ await firstStopStarted;
+ assert.deepEqual(stopped, [['payment', 'turn-reserved-1']]);
+
+ finishPayment({ turnId: 'turn-reserved-1' });
+ finishFirstStop();
+ await Promise.all([pendingSubmission, correction]);
+
+ assert.deepEqual(stopped, [
+ ['payment', 'turn-reserved-1'],
+ ['payment', 'turn-reserved-1'],
+ ]);
+});
+
+test('a stopped ownership tombstone blocks an older root completion', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ let signalStaleStarted!: () => void;
+ const staleStarted = new Promise<void>((resolve) => {
+ signalStaleStarted = resolve;
+ });
+ let finishStale!: (value: { turnId: string }) => void;
+ const staleTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishStale = resolve;
+ });
+ let paymentSubmissions = 0;
+ sessions.submit = async (target) => {
+ if (target.sessionId !== 'payment') return { turnId: 'turn-login' };
+ paymentSubmissions += 1;
+ if (paymentSubmissions === 1) return { turnId: 'turn-payment-root' };
+ signalStaleStarted();
+ return staleTurn;
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.submit({
+ requestId: 'request-payment-owned',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ const staleSubmission = controller.submit({
+ requestId: 'request-payment-stale',
+ text: '再继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ await staleStarted;
+
+ await controller.submit({
+ requestId: 'request-stop-before-stale-finishes',
+ text: '不是这个工作,换成登录稳定性',
+ });
+ finishStale({ turnId: 'turn-payment-stale' });
+ await staleSubmission;
+ controller.resetVisitContext();
+ await controller.read({ focus: { sessionId: 'payment' } });
+ await controller.submit({
+ requestId: 'request-correct-after-stale-finishes',
+ text: '不是这个工作,换成登录稳定性',
+ });
+
+ assert.deepEqual(stopped, [
+ ['payment', 'turn-payment-root'],
+ ['payment', 'reserved-turn-2'],
+ ['payment', 'turn-payment-stale'],
+ ]);
+});
+
+test('tombstone retention never evicts live ownership for another Session', async () => {
+ const stopped: Array<[string, string]> = [];
+ const fillers = Array.from({ length: 32 }, (_, index) =>
+ session(`filler-${index}`, { sessionName: `填充工作 ${index}` }));
+ const sessions = port([
+ session('long-running', { sessionName: '长期工作', updatedAt: 100 }),
+ session('sink', { sessionName: '收件箱工作', updatedAt: 90 }),
+ ...fillers,
+ ]);
+ sessions.submit = async (target, _text, turnId) => target.sessionId === 'sink'
+ ? { turnId, steered: true }
+ : { turnId };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ const live = await controller.submit({
+ requestId: 'request-live-root',
+ text: '开始长期工作',
+ explicitTarget: { sessionId: 'long-running' },
+ });
+ assert.equal(live.kind, 'submitted');
+
+ for (const [index, filler] of fillers.entries()) {
+ const owned = await controller.submit({
+ requestId: `request-filler-${index}`,
+ text: `开始填充工作 ${index}`,
+ explicitTarget: filler.target,
+ });
+ assert.equal(owned.kind, 'submitted');
+ if (owned.kind !== 'submitted') continue;
+ await controller.submit({
+ requestId: `request-stop-filler-${index}`,
+ text: `填充工作 ${index} 路由错了`,
+ explicitTarget: { sessionId: 'sink' },
+ correction: {
+ from: filler.target,
+ turnId: owned.turnId,
+ },
+ });
+ }
+
+ stopped.length = 0;
+ controller.resetVisitContext();
+ await controller.read({ focus: { sessionId: 'long-running' } });
+ await controller.submit({
+ requestId: 'request-correct-live-root',
+ text: '不是这个工作,换成收件箱工作',
+ });
+
+ assert.equal(stopped.length, 1);
+ assert.equal(stopped[0]?.[0], 'long-running');
+ assert.equal(stopped[0]?.[1], live.kind === 'submitted' ? live.turnId : undefined);
+});
+
+test('correction barrier rejects a new root while Stop is pending', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ let signalStopStarted!: () => void;
+ const stopStarted = new Promise<void>((resolve) => {
+ signalStopStarted = resolve;
+ });
+ let finishFirstStop!: () => void;
+ const firstStop = new Promise<void>((resolve) => {
+ finishFirstStop = resolve;
+ });
+ let stopCalls = 0;
+ sessions.submit = async (_target, _text, turnId) => ({ turnId });
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ stopCalls += 1;
+ if (stopCalls === 1) {
+ signalStopStarted();
+ await firstStop;
+ }
+ };
+ const controller = createWorkHubController({ sessions });
+ const original = await controller.submit({
+ requestId: 'request-original-payment',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ assert.equal(original.kind, 'submitted');
+
+ const correction = controller.submit({
+ requestId: 'request-correct-original-payment',
+ text: '不是这个工作,换成登录稳定性',
+ });
+ await stopStarted;
+ await assert.rejects(controller.submit({
+ requestId: 'request-overlapping-payment',
+ text: '重新处理支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ }), /still reconciling/u);
+ finishFirstStop();
+ await correction;
+
+ const newer = await controller.submit({
+ requestId: 'request-newer-payment',
+ text: '重新处理支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ assert.equal(newer.kind, 'submitted');
+
+ controller.resetVisitContext();
+ await controller.read({ focus: { sessionId: 'payment' } });
+ await controller.submit({
+ requestId: 'request-correct-newer-payment',
+ text: '不是这个工作,换成登录稳定性',
+ });
+
+ assert.deepEqual(stopped, [
+ ['payment', original.kind === 'submitted' ? original.turnId : ''],
+ ['payment', newer.kind === 'submitted' ? newer.turnId : ''],
+ ]);
+});
+
+test('a partially failed correction records only successful Stops and keeps failures reachable', async () => {
+ const stopAttempts: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ let finishPending!: (value: { turnId: string }) => void;
+ const pendingTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishPending = resolve;
+ });
+ let paymentSubmissions = 0;
+ sessions.reserveTurnId = (() => {
+ let next = 0;
+ return () => `reserved-${++next}`;
+ })();
+ sessions.submit = async (target, _text, turnId) => {
+ if (target.sessionId !== 'payment') return { turnId };
+ paymentSubmissions += 1;
+ return paymentSubmissions === 1 ? { turnId: 'payment-root' } : pendingTurn;
+ };
+ let failPaymentRoot = true;
+ sessions.stop = async (target, turnId) => {
+ stopAttempts.push([target.sessionId, turnId]);
+ if (turnId === 'payment-root' && failPaymentRoot) {
+ failPaymentRoot = false;
+ throw new Error('Host rejected the first Stop');
+ }
+ };
+ const controller = createWorkHubController({ sessions });
+ const confirmed = await controller.submit({
+ requestId: 'confirmed-payment-root',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ assert.equal(confirmed.kind, 'submitted');
+ const pending = controller.submit({
+ requestId: 'pending-payment-root',
+ text: '再次处理支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+
+ await assert.rejects(controller.submit({
+ requestId: 'partially-failed-correction',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: {
+ from: { sessionId: 'payment' },
+ turnId: 'payment-root',
+ },
+ }), /Host rejected the first Stop/u);
+
+ assert.equal(stopAttempts.some(([, turnId]) => turnId === 'reserved-2'), true);
+ finishPending({ turnId: 'payment-host-rebound' });
+ await pending;
+ assert.equal(stopAttempts.some(([, turnId]) => turnId === 'payment-host-rebound'), true);
+
+ await controller.submit({
+ requestId: 'retry-failed-correction',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: {
+ from: { sessionId: 'payment' },
+ turnId: 'payment-root',
+ },
+ });
+ assert.equal(
+ stopAttempts.filter(([, turnId]) => turnId === 'payment-root').length,
+ 2,
+ );
+});
+
+test('the 33rd unresolved root is back-pressured before Host admission', async () => {
+ const facts = Array.from({ length: 33 }, (_, index) =>
+ session(`work-${index}`, { runningTurnIds: [] }));
+ const sessions = port(facts);
+ const finishes = new Map<string, (value: { turnId: string }) => void>();
+ let admitted = 0;
+ let signalThirtyTwo!: () => void;
+ const thirtyTwoAdmitted = new Promise<void>((resolve) => {
+ signalThirtyTwo = resolve;
+ });
+ sessions.submit = async (target, _text, turnId) => {
+ admitted += 1;
+ if (admitted === 32) signalThirtyTwo();
+ return await new Promise<{ turnId: string }>((resolve) => {
+ finishes.set(target.sessionId, resolve);
+ });
+ };
+ const controller = createWorkHubController({ sessions });
+ const inFlight = facts.slice(0, 32).map((fact, index) => controller.submit({
+ requestId: `root-${index}`,
+ text: `开始工作 ${index}`,
+ explicitTarget: fact.target,
+ }));
+ await thirtyTwoAdmitted;
+
+ await assert.rejects(controller.submit({
+ requestId: 'root-33',
+ text: '开始工作 33',
+ explicitTarget: facts[32]!.target,
+ }), /too many unresolved root submissions/u);
+ assert.equal(admitted, 32);
+
+ finishes.get('work-0')?.({ turnId: 'settled-work-0' });
+ await inFlight[0];
+ const thirtyThird = controller.submit({
+ requestId: 'root-33-after-capacity',
+ text: '开始工作 33',
+ explicitTarget: facts[32]!.target,
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+ assert.equal(admitted, 33);
+ finishes.get('work-32')?.({ turnId: 'settled-work-32' });
+ await thirtyThird;
+});
+
+test('an old correction barrier survives more than 32 newer corrections', async () => {
+ const stopped: Array<[string, string]> = [];
+ const fillers = Array.from({ length: 32 }, (_, index) =>
+ session(`barrier-filler-${index}`, { sessionName: `屏障填充 ${index}` }));
+ const sessions = port([
+ session('old-pending', { sessionName: '旧的待定工作', updatedAt: 100 }),
+ session('sink', { sessionName: '安全收件箱', updatedAt: 90 }),
+ ...fillers,
+ ]);
+ let finishOld!: (value: { turnId: string }) => void;
+ const oldTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishOld = resolve;
+ });
+ sessions.submit = async (target, _text, turnId) => {
+ if (target.sessionId === 'old-pending') return oldTurn;
+ if (target.sessionId === 'sink') return { turnId, steered: true };
+ return { turnId };
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+ const oldSubmission = controller.submit({
+ requestId: 'old-pending-root',
+ text: '开始旧的待定工作',
+ explicitTarget: { sessionId: 'old-pending' },
+ });
+ await Promise.resolve();
+ await Promise.resolve();
+ await controller.submit({
+ requestId: 'correct-old-pending',
+ text: '旧工作路由错了',
+ explicitTarget: { sessionId: 'sink' },
+ correction: {
+ from: { sessionId: 'old-pending' },
+ turnId: 'reserved-turn-1',
+ },
+ });
+
+ for (const [index, filler] of fillers.entries()) {
+ const owned = await controller.submit({
+ requestId: `newer-barrier-root-${index}`,
+ text: `开始屏障填充 ${index}`,
+ explicitTarget: filler.target,
+ });
+ assert.equal(owned.kind, 'submitted');
+ if (owned.kind !== 'submitted') continue;
+ await controller.submit({
+ requestId: `newer-barrier-correction-${index}`,
+ text: `屏障填充 ${index} 路由错了`,
+ explicitTarget: { sessionId: 'sink' },
+ correction: { from: filler.target, turnId: owned.turnId },
+ });
+ }
+
+ finishOld({ turnId: 'old-host-rebound' });
+ await oldSubmission;
+ assert.equal(
+ stopped.some(([sessionId, turnId]) =>
+ sessionId === 'old-pending' && turnId === 'old-host-rebound'),
+ true,
+ );
+});
+
+test('a definite Host rejection releases only its own pending admission', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性' }),
+ session('payment', { sessionName: '支付稳定性' }),
+ ]);
+ let shouldReject = true;
+ sessions.submit = async (_target, _text, turnId) => {
+ if (shouldReject) {
+ shouldReject = false;
+ throw new WorkHubSessionSubmitError('not admitted', 'rejected');
+ }
+ return { turnId };
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ await assert.rejects(controller.submit({
+ requestId: 'definitely-rejected',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ }), /not admitted/u);
+ const admitted = await controller.submit({
+ requestId: 'later-admitted',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ assert.equal(admitted.kind, 'submitted');
+ await controller.submit({
+ requestId: 'correct-later-admitted',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'payment' } },
+ });
+
+ assert.deepEqual(stopped, [[
+ 'payment',
+ admitted.kind === 'submitted' ? admitted.turnId : '',
+ ]]);
+});
+
+test('a lost delivery reply is reconciled to its authoritative root ownership', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性' }),
+ session('payment', { sessionName: '支付稳定性' }),
+ ]);
+ sessions.submit = async () => {
+ throw new WorkHubSessionSubmitError('reply lost', 'unknown');
+ };
+ sessions.reconcileSubmission = async () => ({
+ kind: 'root',
+ turnId: 'authoritative-payment-root',
+ });
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ await assert.rejects(controller.submit({
+ requestId: 'reply-lost',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ }), /reply lost/u);
+ sessions.submit = async (_target, _text, turnId) => ({ turnId });
+ await controller.submit({
+ requestId: 'correct-reconciled-root',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'payment' } },
+ });
+
+ assert.deepEqual(stopped, [['payment', 'authoritative-payment-root']]);
+});
+
+test('an unknown delivery remains pending until a later authoritative reconciliation', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性' }),
+ session('payment', { sessionName: '支付稳定性' }),
+ ]);
+ sessions.submit = async () => {
+ throw new WorkHubSessionSubmitError('reply lost', 'unknown');
+ };
+ let reconciliation: Awaited<ReturnType<WorkHubSessionPort['reconcileSubmission']>> = {
+ kind: 'unknown',
+ };
+ sessions.reconcileSubmission = async () => reconciliation;
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ await assert.rejects(controller.submit({
+ requestId: 'unknown-delivery',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ }), /reply lost/u);
+ reconciliation = { kind: 'root', turnId: 'later-authoritative-root' };
+ await controller.read();
+ sessions.submit = async (_target, _text, turnId) => ({ turnId });
+ await controller.submit({
+ requestId: 'correct-later-reconciled-root',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'payment' } },
+ });
+
+ assert.deepEqual(stopped, [['payment', 'later-authoritative-root']]);
+});
+
+test('a partial multi-Host catalog never erases confirmed ownership', async () => {
+ const stopped: Array<[string, string]> = [];
+ const allSessions = [
+ session('login', { sessionName: '登录稳定性' }),
+ session('remote-payment', { sessionName: '远端支付稳定性' }),
+ ];
+ const sessions = port(allSessions);
+ let visible = allSessions;
+ let paymentCatalogComplete = true;
+ sessions.listCatalog = async () => ({
+ sessions: visible,
+ isCompleteFor: (target) =>
+ target.sessionId !== 'remote-payment' || paymentCatalogComplete,
+ });
+ sessions.submit = async (_target, _text, turnId) => ({ turnId });
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+ const owned = await controller.submit({
+ requestId: 'remote-root',
+ text: '继续远端支付',
+ explicitTarget: { sessionId: 'remote-payment' },
+ });
+ assert.equal(owned.kind, 'submitted');
+
+ visible = [allSessions[0]!];
+ paymentCatalogComplete = false;
+ await controller.submit({
+ requestId: 'correct-after-partial-catalog',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'remote-payment' } },
+ });
+
+ assert.deepEqual(stopped, [[
+ 'remote-payment',
+ owned.kind === 'submitted' ? owned.turnId : '',
+ ]]);
+});
+
+test('a stale complete catalog never erases newer confirmed ownership', async () => {
+ const stopped: Array<[string, string]> = [];
+ const allSessions = [
+ session('login', { sessionName: '登录稳定性' }),
+ session('payment', { sessionName: '支付稳定性' }),
+ ];
+ const sessions = port(allSessions);
+ let signalStaleReadStarted!: () => void;
+ const staleReadStarted = new Promise<void>((resolve) => {
+ signalStaleReadStarted = resolve;
+ });
+ let finishStaleRead!: (value: {
+ sessions: WorkHubSessionFacts[];
+ isCompleteFor(target: { sessionId: string }): boolean;
+ }) => void;
+ const staleCatalog = new Promise<{
+ sessions: WorkHubSessionFacts[];
+ isCompleteFor(target: { sessionId: string }): boolean;
+ }>((resolve) => {
+ finishStaleRead = resolve;
+ });
+ let catalogReads = 0;
+ sessions.listCatalog = async () => {
+ catalogReads += 1;
+ if (catalogReads === 1) {
+ signalStaleReadStarted();
+ return staleCatalog;
+ }
+ return {
+ sessions: allSessions,
+ isCompleteFor: () => true,
+ };
+ };
+ sessions.submit = async (_target, _text, turnId) => ({ turnId });
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ const staleRead = controller.read();
+ await staleReadStarted;
+ const owned = await controller.submit({
+ requestId: 'payment-root-after-stale-read-started',
+ text: '继续支付稳定性',
+ explicitTarget: { sessionId: 'payment' },
+ });
+ assert.equal(owned.kind, 'submitted');
+
+ finishStaleRead({
+ sessions: [allSessions[0]!],
+ isCompleteFor: () => true,
+ });
+ await staleRead;
+ await controller.submit({
+ requestId: 'correct-after-stale-complete-catalog',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'payment' } },
+ });
+
+ assert.deepEqual(stopped, [[
+ 'payment',
+ owned.kind === 'submitted' ? owned.turnId : '',
+ ]]);
+});
+
+test('authoritative Session removal releases uncertain admissions before global backpressure', async () => {
+ const stale = Array.from({ length: 32 }, (_, index) =>
+ session(`removed-${index}`, { sessionName: `已删除工作 ${index}` }));
+ const fresh = session('fresh', { sessionName: '新工作' });
+ const sessions = port(stale);
+ let visible = stale;
+ let removedCatalogComplete = false;
+ sessions.listCatalog = async () => ({
+ sessions: visible,
+ isCompleteFor: (target) =>
+ target.sessionId.startsWith('removed-') && removedCatalogComplete,
+ });
+ sessions.submit = async () => {
+ throw new WorkHubSessionSubmitError('reply lost', 'unknown');
+ };
+ sessions.reconcileSubmission = async () => ({ kind: 'unknown' });
+ const controller = createWorkHubController({ sessions });
+
+ for (const [index, fact] of stale.entries()) {
+ await assert.rejects(controller.submit({
+ requestId: `uncertain-${index}`,
+ text: `开始已删除工作 ${index}`,
+ explicitTarget: fact.target,
+ }), /reply lost/u);
+ }
+
+ visible = [fresh];
+ removedCatalogComplete = true;
+ sessions.submit = async (_target, _text, turnId) => ({ turnId });
+ const admitted = await controller.submit({
+ requestId: 'after-authoritative-removal',
+ text: '开始新工作',
+ explicitTarget: fresh.target,
+ });
+
+ assert.equal(admitted.kind, 'submitted');
+ assert.deepEqual(admitted.kind === 'submitted' ? admitted.target : undefined, fresh.target);
+});
+
+test('a lost reply reconciled as steering never claims the pre-existing root', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性' }),
+ session('payment', { sessionName: '支付稳定性' }),
+ ]);
+ sessions.submit = async () => {
+ throw new WorkHubSessionSubmitError('steering reply lost', 'unknown');
+ };
+ sessions.reconcileSubmission = async () => ({ kind: 'steered' });
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+
+ await assert.rejects(controller.submit({
+ requestId: 'steering-reply-lost',
+ text: '补充支付测试',
+ explicitTarget: { sessionId: 'payment' },
+ }), /steering reply lost/u);
+ sessions.submit = async (_target, _text, turnId) => ({ turnId });
+ await controller.submit({
+ requestId: 'correct-after-steering-reply-loss',
+ text: '不是支付,改成登录',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'payment' } },
+ });
+
+ assert.deepEqual(stopped, []);
+});
+
+test('WorkHub-owned root remains stoppable after navigating away and back', async () => {
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', updatedAt: 30 }),
+ ]);
+ sessions.submit = async (target) => ({ turnId: 'turn-' + target.sessionId });
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read();
+ await controller.submit({
+ requestId: 'request-owned-before-navigation',
+ text: '继续这个工作',
+ });
+ controller.resetVisitContext();
+ await controller.read({ focus: { sessionId: 'payment' } });
+
+ const corrected = await controller.submit({
+ requestId: 'request-correction-after-return',
+ text: '不是这个工作,换成登录稳定性',
+ });
+
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(stopped, [['payment', 'turn-payment']]);
+});
+
+test('natural-language correction never stops a pre-existing focused Session', async () => {
+ const stopped: string[] = [];
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性', updatedAt: 20 }),
+ session('payment', { sessionName: '支付稳定性', state: 'running', updatedAt: 30 }),
+ ]);
+ sessions.submit = async (target) => ({ turnId: `turn-${target.sessionId}` });
+ sessions.stop = async (target) => {
+ stopped.push(target.sessionId);
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read();
+
+ const corrected = await controller.submit({
+ requestId: 'request-safe-natural-correction',
+ text: '不是这个,用登录那个',
+ });
+
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.correctedFrom : undefined, {
+ sessionId: 'payment',
+ });
+ assert.deepEqual(stopped, []);
+});
+
+test('English natural-language correction names the replacement Session', async () => {
+ const submitted: string[] = [];
+ const sessions = port([
+ session('login', { sessionName: 'Login Reliability', updatedAt: 20 }),
+ session('payment', { sessionName: 'Payment Webhooks', updatedAt: 30 }),
+ ]);
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: `turn-${submitted.length}` };
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read();
+
+ const corrected = await controller.submit({
+ requestId: 'request-english-natural-correction',
+ text: 'Not that work; switch to Login Reliability and add the retry checks',
+ });
+
+ assert.deepEqual(corrected.kind === 'submitted' ? corrected.target : undefined, {
+ sessionId: 'login',
+ });
+ assert.equal(
+ corrected.kind === 'submitted' ? corrected.evidence : undefined,
+ 'route_correction',
+ );
+});
+
+test('ambiguous natural-language correction preserves correction context through clarification', async () => {
+ const submitted: string[] = [];
+ const stopped: Array<[string, string]> = [];
+ const sessions = port([
+ session('login-api', { sessionName: '登录 API 稳定性', updatedAt: 20 }),
+ session('login-ui', { sessionName: '登录 UI 稳定性', updatedAt: 10 }),
+ session('payment', { sessionName: '支付回调幂等性', updatedAt: 30 }),
+ ]);
+ sessions.submit = async (target) => {
+ submitted.push(target.sessionId);
+ return { turnId: `turn-${submitted.length}` };
+ };
+ sessions.stop = async (target, turnId) => {
+ stopped.push([target.sessionId, turnId]);
+ };
+ const controller = createWorkHubController({ sessions });
+ await controller.read();
+ await controller.submit({
+ requestId: 'request-payment-before-clarification',
+ text: '继续这个工作',
+ });
+
+ const clarification = await controller.submit({
+ requestId: 'request-natural-clarification',
+ text: '不是这个,换成登录那个',
+ });
+ assert.equal(clarification.kind, 'clarification');
+ if (clarification.kind !== 'clarification') return;
+ assert.deepEqual(
+ clarification.options.map((option) => option.target.sessionId),
+ ['login-api', 'login-ui'],
+ );
+ assert.deepEqual(clarification.correction, {
+ from: { sessionId: 'payment' },
+ turnId: 'turn-1',
+ });
+
+ const corrected = await controller.submit({
+ requestId: clarification.requestId,
+ text: clarification.text,
+ explicitTarget: { sessionId: 'login-api' },
+ correction: clarification.correction,
+ });
+ assert.equal(corrected.kind, 'submitted');
+ assert.deepEqual(stopped, [['payment', 'turn-1']]);
+ assert.deepEqual(submitted, ['payment', 'login-api']);
+});
+
+test('latest route correction wins for the same expression family', async () => {
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性' }),
+ session('payment', { sessionName: '支付稳定性' }),
+ ]);
+ sessions.submit = async (_target) => ({ turnId: 'turn' });
+ const controller = createWorkHubController({ sessions });
+
+ await controller.submit({
+ requestId: 'correction-login',
+ text: '继续白鹭点,列出验收项。',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'payment' }, turnId: 'turn' },
+ });
+ await controller.submit({
+ requestId: 'correction-payment',
+ text: '继续白鹭点,列出异常项。',
+ explicitTarget: { sessionId: 'payment' },
+ correction: { from: { sessionId: 'login' }, turnId: 'turn' },
+ });
+
+ const result = await controller.submit({
+ requestId: 'correction-latest',
+ text: '继续白鹭点,补充回滚条件。',
+ });
+
+ assert.deepEqual(result.kind === 'submitted' ? result.target : undefined, {
+ sessionId: 'payment',
+ });
+ assert.equal(result.kind === 'submitted' ? result.evidence : undefined, 'route_correction');
+});
+
+test('user correction order wins when overlapping submissions finish out of order', async () => {
+ const sessions = port([
+ session('login', { sessionName: '登录稳定性' }),
+ session('payment', { sessionName: '支付稳定性' }),
+ ]);
+ let signalOlderStarted!: () => void;
+ const olderStarted = new Promise<void>((resolve) => {
+ signalOlderStarted = resolve;
+ });
+ let finishOlder!: (value: { turnId: string }) => void;
+ const olderTurn = new Promise<{ turnId: string }>((resolve) => {
+ finishOlder = resolve;
+ });
+ sessions.submit = async (target) => {
+ if (target.sessionId === 'login') {
+ signalOlderStarted();
+ return olderTurn;
+ }
+ return { turnId: 'turn-payment' };
+ };
+ const controller = createWorkHubController({ sessions });
+
+ const olderCorrection = controller.submit({
+ requestId: 'correction-older-login',
+ text: '继续白鹭点,列出验收项。',
+ explicitTarget: { sessionId: 'login' },
+ correction: { from: { sessionId: 'payment' } },
+ });
+ await olderStarted;
+ controller.resetVisitContext();
+ await controller.submit({
+ requestId: 'correction-newer-payment',
+ text: '继续白鹭点,列出异常项。',
+ explicitTarget: { sessionId: 'payment' },
+ correction: { from: { sessionId: 'login' } },
+ });
+ finishOlder({ turnId: 'turn-login' });
+ await olderCorrection;
+
+ const result = await controller.submit({
+ requestId: 'correction-after-overlap',
text: '继续白鹭点,补充回滚条件。',
});
@@ -846,7 +2291,7 @@ test('waiting Session rejects a second root request without calling submit', asy
assert.deepEqual(result, {
kind: 'waiting',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-waiting',
text: '排查令牌过期重复登录问题:补充一条等待状态下的新请求。',
target: { sessionId: 'login' },
@@ -935,7 +2380,7 @@ test('submit keeps unmatched non-executable conversation in WorkHub', async () =
assert.deepEqual(result, {
kind: 'discussion',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-discussion',
text: '你觉得统一入口最重要的价值是什么?',
});
@@ -1000,7 +2445,7 @@ test('submit creates an ordinary Session for a clear unmatched executable goal',
assert.deepEqual(result, {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-new-work',
target: { sessionId: 'invoice-export' },
turnId: 'turn-invoice-export',
diff --git a/apps/desktop/src/main/__tests__/workhub-session-port.test.ts b/apps/desktop/src/main/__tests__/workhub-session-port.test.ts
index e96bebb81..719d9c81c 100644
--- a/apps/desktop/src/main/__tests__/workhub-session-port.test.ts
+++ b/apps/desktop/src/main/__tests__/workhub-session-port.test.ts
@@ -27,6 +27,7 @@ import {
projectWorkHubSessionTurns,
type WorkHubDesktopSession,
} from '../../renderer/workhub-session-port.js';
+import { WorkHubSessionSubmitError } from '../../renderer/workhub-controller.js';
function desktopSession(
id: string,
@@ -51,6 +52,48 @@ const unusedTranscripts = {
},
};
+function transcriptsWith(messages: readonly StoredMessage[]) {
+ return {
+ open: async (sessionId: string, handler: (batch: DesktopTranscriptBatch) => void) => {
+ const parsed = JSON.parse(sessionId) as [string, string];
+ const fragments = messages.map((message, identity) => {
+ const data = new TextEncoder().encode(JSON.stringify(message));
+ return {
+ source: 'durable' as const,
+ identity,
+ order: null,
+ byteOffset: 0,
+ totalBytes: data.byteLength,
+ data,
+ };
+ });
+ handler({
+ sessionId: parsed[1],
+ deliverySequence: 1,
+ generation: 'generation-reconcile',
+ hostEpoch: 'epoch-reconcile',
+ durableThrough: messages.length - 1,
+ fragments,
+ evictedDurableSequences: [],
+ completedOverlayMessageIds: [],
+ hasOlder: false,
+ hasNewer: false,
+ reset: true,
+ ready: true,
+ });
+ return {
+ sessionId,
+ generation: 'generation-reconcile',
+ hostEpoch: 'epoch-reconcile',
+ readThroughMessageId: null,
+ loadBefore: async () => {},
+ loadAround: async () => {},
+ close: async () => {},
+ };
+ },
+ };
+}
+
test('projects durable Session messages into an ordered WorkHub conversation', () => {
const turns = projectWorkHubSessionTurns({
target: { sessionId: 'payment' },
@@ -310,6 +353,7 @@ test('desktop adapter projects Session catalog facts without owning copies', asy
kind: 'ordinary',
archived: false,
state: 'running',
+ runningTurnIds: ['turn-running'],
latestResult: '正在补充重复投递测试',
updatedAt: 30,
},
@@ -320,6 +364,7 @@ test('desktop adapter projects Session catalog facts without owning copies', asy
kind: 'internal',
archived: false,
state: 'active',
+ runningTurnIds: [],
updatedAt: 20,
},
{
@@ -329,6 +374,7 @@ test('desktop adapter projects Session catalog facts without owning copies', asy
kind: 'ordinary',
archived: false,
state: 'waiting_for_user',
+ runningTurnIds: ['turn-waiting'],
updatedAt: 15,
},
{
@@ -338,11 +384,41 @@ test('desktop adapter projects Session catalog facts without owning copies', asy
kind: 'subagent',
archived: false,
state: 'active',
+ runningTurnIds: [],
updatedAt: 10,
},
]);
});
+test('desktop adapter preserves per-Host catalog coverage for ownership reconciliation', async () => {
+ const localSessionId = desktopSessionKey({ hostId: 'local-host', sessionId: 'local' });
+ const adapter = createDesktopWorkHubSessionPort({
+ transcripts: unusedTranscripts,
+ sessions: {
+ list: async () => [],
+ listWithCoverage: async () => ({
+ sessions: [desktopSession(localSessionId)],
+ completeHostIds: ['local-host'],
+ }),
+ listTurns: async () => [],
+ create: async () => { throw new Error('not used'); },
+ send: async () => { throw new Error('not used'); },
+ stop: async () => {},
+ subscribeChanges: () => () => {},
+ },
+ projectName: () => 'Maka',
+ newTurnId: () => 'unused',
+ });
+
+ const catalog = await adapter.listCatalog?.();
+ assert.ok(catalog);
+ assert.equal(catalog.sessions[0]?.target.sessionId, localSessionId);
+ assert.equal(catalog.isCompleteFor({ sessionId: localSessionId }), true);
+ assert.equal(catalog.isCompleteFor({
+ sessionId: desktopSessionKey({ hostId: 'remote-host', sessionId: 'remote' }),
+ }), false);
+});
+
test('desktop adapter delegates create, send, and invalidation to Session APIs', async () => {
const calls: unknown[] = [];
let onChanged: (() => void) | undefined;
@@ -375,7 +451,8 @@ test('desktop adapter delegates create, send, and invalidation to Session APIs',
});
const created = await adapter.create({ name: '实现导出发票 PDF 功能' });
- const turn = await adapter.submit(created.target, '实现导出发票 PDF 功能');
+ const turnId = adapter.reserveTurnId();
+ const turn = await adapter.submit(created.target, '实现导出发票 PDF 功能', turnId);
await adapter.stop(created.target, 'turn-new');
let invalidations = 0;
const unsubscribe = adapter.subscribe(() => {
@@ -417,11 +494,111 @@ test('desktop adapter preserves when Session delivery steered an existing root T
});
assert.deepEqual(
- await adapter.submit({ sessionId: 'busy' }, '补充已有执行流'),
+ await adapter.submit(
+ { sessionId: 'busy' },
+ '补充已有执行流',
+ adapter.reserveTurnId(),
+ ),
{ turnId: 'turn-steered', steered: true },
);
});
+test('desktop adapter distinguishes definite rejection from an unknown delivery outcome', async () => {
+ let outcome: 'throw' | 'reject' = 'throw';
+ const adapter = createDesktopWorkHubSessionPort({
+ transcripts: unusedTranscripts,
+ sessions: {
+ list: async () => [],
+ listTurns: async () => [],
+ create: async () => { throw new Error('not used'); },
+ send: async () => {
+ if (outcome === 'throw') throw new Error('transport disconnected');
+ return { ok: false as const, reason: 'archived' as const };
+ },
+ stop: async () => {},
+ subscribeChanges: () => () => {},
+ },
+ projectName: () => 'Maka',
+ newTurnId: () => 'reserved-turn',
+ });
+
+ await assert.rejects(
+ adapter.submit({ sessionId: 'payment' }, '继续支付', 'reserved-turn'),
+ (error) => error instanceof WorkHubSessionSubmitError && error.admission === 'unknown',
+ );
+ outcome = 'reject';
+ await assert.rejects(
+ adapter.submit({ sessionId: 'payment' }, '继续支付', 'reserved-turn'),
+ (error) => error instanceof WorkHubSessionSubmitError && error.admission === 'rejected',
+ );
+});
+
+test('desktop adapter reconciles lost replies from authoritative transcript identity', async () => {
+ const cases: Array<{
+ name: string;
+ message: StoredMessage;
+ expected: { kind: 'root'; turnId: string } | { kind: 'steered' } | { kind: 'unknown' };
+ }> = [
+ {
+ name: 'direct root',
+ message: {
+ type: 'user', id: 'user-root', turnId: 'reserved-turn', ts: 1, text: '开始支付',
+ },
+ expected: { kind: 'root', turnId: 'reserved-turn' },
+ },
+ {
+ name: 'busy-race root',
+ message: {
+ type: 'user', id: 'reserved-turn', turnId: 'host-root', ts: 1, text: '开始支付',
+ },
+ expected: { kind: 'root', turnId: 'host-root' },
+ },
+ {
+ name: 'steering',
+ message: {
+ type: 'user',
+ id: 'reserved-turn',
+ turnId: 'pre-existing-root',
+ steeringEventId: 'steering-event',
+ ts: 1,
+ text: '补充支付测试',
+ },
+ expected: { kind: 'steered' },
+ },
+ {
+ name: 'unrelated message',
+ message: {
+ type: 'user', id: 'other-message', turnId: 'other-root', ts: 1, text: '其他工作',
+ },
+ expected: { kind: 'unknown' },
+ },
+ ];
+
+ for (const fixture of cases) {
+ const adapter = createDesktopWorkHubSessionPort({
+ transcripts: transcriptsWith([fixture.message]),
+ sessions: {
+ list: async () => [],
+ listTurns: async () => [],
+ create: async () => { throw new Error('not used'); },
+ send: async () => { throw new Error('not used'); },
+ stop: async () => {},
+ subscribeChanges: () => () => {},
+ },
+ projectName: () => 'Maka',
+ newTurnId: () => 'reserved-turn',
+ });
+
+ assert.deepEqual(
+ await adapter.reconcileSubmission({
+ sessionId: desktopSessionKey({ hostId: 'local-host', sessionId: fixture.name }),
+ }, 'reserved-turn'),
+ fixture.expected,
+ fixture.name,
+ );
+ }
+});
+
test('desktop adapter binds stop to the root Turn owned by the WorkHub submission', async () => {
const stopped: unknown[] = [];
const adapter = createDesktopWorkHubSessionPort({
diff --git a/apps/desktop/src/main/__tests__/workhub-surface-flow.test.ts b/apps/desktop/src/main/__tests__/workhub-surface-flow.test.ts
index dc6479c08..27edc7eb9 100644
--- a/apps/desktop/src/main/__tests__/workhub-surface-flow.test.ts
+++ b/apps/desktop/src/main/__tests__/workhub-surface-flow.test.ts
@@ -31,6 +31,7 @@ import {
import {
boundedWorkHubTimelineText,
createWorkHubController,
+ WORKHUB_ROUTING_STRATEGY_ID,
type WorkHubController,
type WorkHubSubmitInput,
} from '../../renderer/workhub-controller.js';
@@ -79,14 +80,14 @@ test('surface keeps the Composer draft when routing fails or the target is waiti
assert.equal(workHubSubmissionClearsDraft(undefined), false);
assert.equal(workHubSubmissionClearsDraft({
kind: 'waiting',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'waiting',
text: '继续处理',
target: { sessionId: 'payment' },
}), false);
assert.equal(workHubSubmissionClearsDraft({
kind: 'discussion',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'discussion',
text: '先讨论方向',
}), true);
@@ -95,7 +96,7 @@ test('surface keeps the Composer draft when routing fails or the target is waiti
test('surface disables correction after a request was steered into existing work', () => {
const submission = {
kind: 'submitted' as const,
- strategyId: 'wh-r2.3-session-core-evidence' as const,
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'steered',
target: { sessionId: 'payment' },
turnId: 'turn-existing',
@@ -130,7 +131,7 @@ test('surface hides a rebuilt Session turn while the matching local turn is stil
state: 'settled',
outcome: {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-payment',
target: { sessionId: 'payment' },
turnId: 'turn-payment',
@@ -164,7 +165,7 @@ test('surface canonicalizes bounded text before suppressing a local duplicate',
state: 'settled',
outcome: {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-long',
target: { sessionId: 'payment' },
turnId: 'turn-long',
@@ -195,7 +196,7 @@ test('surface suppresses the newest matching projected steering turn', () => {
state: 'settled',
outcome: {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: 'request-new',
target: { sessionId: 'payment' },
turnId: 'turn-payment',
@@ -208,13 +209,14 @@ test('surface keeps clarification and successful routing in WorkHub', async () =
const submissions: WorkHubSubmitInput[] = [];
const controller: WorkHubController = {
read: async () => ({ sessions: [], turns: [] }),
+ resetVisitContext: () => {},
subscribe: () => () => {},
submit: async (input) => {
submissions.push(input);
if (!input.explicitTarget) {
return {
kind: 'clarification',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: input.requestId,
text: input.text,
options: [{
@@ -226,7 +228,7 @@ test('surface keeps clarification and successful routing in WorkHub', async () =
}
return {
kind: 'submitted',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: input.requestId,
target: input.explicitTarget,
turnId: 'turn-payment',
@@ -256,10 +258,11 @@ test('surface keeps clarification and successful routing in WorkHub', async () =
test('surface leaves discussion in WorkHub instead of creating a task view', async () => {
const controller: WorkHubController = {
read: async () => ({ sessions: [], turns: [] }),
+ resetVisitContext: () => {},
subscribe: () => () => {},
submit: async (input) => ({
kind: 'discussion',
- strategyId: 'wh-r2.3-session-core-evidence',
+ strategyId: WORKHUB_ROUTING_STRATEGY_ID,
requestId: input.requestId,
text: input.text,
}),
diff --git a/apps/desktop/src/main/runtime-host-session-execution-ipc-main.ts b/apps/desktop/src/main/runtime-host-session-execution-ipc-main.ts
index 3be6608f6..bd961f7fd 100644
--- a/apps/desktop/src/main/runtime-host-session-execution-ipc-main.ts
+++ b/apps/desktop/src/main/runtime-host-session-execution-ipc-main.ts
@@ -299,7 +299,9 @@ export function registerRuntimeHostSessionExecutionIpc(
}
const submitted = await deps.client.submitMessage({
sessionId,
- messageId: newId(),
+ // Preserve the renderer's command identity in the durable message so
+ // a lost IPC reply can be reconciled as root-vs-steering later.
+ messageId: turnId,
content: startInput.content,
placement: "current_turn",
});
diff --git a/apps/desktop/src/preload/bridge-contract.d.ts b/apps/desktop/src/preload/bridge-contract.d.ts
index 226e27a32..d47854372 100644
--- a/apps/desktop/src/preload/bridge-contract.d.ts
+++ b/apps/desktop/src/preload/bridge-contract.d.ts
@@ -712,6 +712,10 @@ export interface MakaBridge {
};
sessions: {
list(filter?: SessionListFilter): Promise<DesktopSessionSummary[]>;
+ listWithCoverage(): Promise<{
+ sessions: DesktopSessionSummary[];
+ completeHostIds: string[];
+ }>;
create(input?: CreateSessionRequestInput): Promise<DesktopSessionSummary>;
send(
sessionId: string,
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 5382ec584..656472bf2 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -105,7 +105,10 @@ import type {
import type { BotProvider } from '@maka/core/bot-chat-settings';
import type { BotOnboardingSnapshot, BotOnboardingStartInput } from '@maka/core/bot-onboarding';
import type { HealthSnapshot } from '@maka/core/health';
-import { collectRuntimeHostSessionCatalogs } from './runtime-host-session-catalog.js';
+import {
+ collectRuntimeHostSessionCatalogs,
+ collectRuntimeHostSessionCatalogsWithCoverage,
+} from './runtime-host-session-catalog.js';
import type { ExecutionBoundaryReadModel, SandboxBoundaryResponse } from '@maka/core/sandbox-boundary';
import type {
ActiveInteractionRequestEvent,
@@ -819,6 +822,21 @@ async function listDesktopSessions(
);
}
+async function listDesktopSessionsWithCoverage(): Promise<{
+ sessions: DesktopSessionSummary[];
+ completeHostIds: string[];
+}> {
+ const scopes = await runtimeHostScopeList();
+ return collectRuntimeHostSessionCatalogsWithCoverage(
+ scopes.map((scope) => ({
+ hostId: scope.hostId,
+ sessions: ipcRenderer.invoke('sessions:list', scope)
+ .then((sessions: SessionCatalogSummary[]) =>
+ sessions.map((session) => projectSessionSummary(scope, session))),
+ })),
+ );
+}
+
function sendActiveRuntimeHost(channel: string, ...args: unknown[]): void {
void activeRuntimeHostRef()
.then((scope) => ipcRenderer.send(channel, scope, ...args))
@@ -1492,6 +1510,9 @@ const makaBridge = {
list(filter?: SessionListFilter): Promise<DesktopSessionSummary[]> {
return listDesktopSessions(filter);
},
+ listWithCoverage() {
+ return listDesktopSessionsWithCoverage();
+ },
/**
* The single session-creation channel (#1433). `mode` names a
* product intent — main derives the permission boundary, name and
diff --git a/apps/desktop/src/preload/runtime-host-session-catalog.ts b/apps/desktop/src/preload/runtime-host-session-catalog.ts
index a23f9a6c3..91b721d6b 100644
--- a/apps/desktop/src/preload/runtime-host-session-catalog.ts
+++ b/apps/desktop/src/preload/runtime-host-session-catalog.ts
@@ -19,6 +19,35 @@
import type { DesktopSessionSummary } from './bridge-contract.js';
+export interface RuntimeHostSessionCatalogRequest {
+ readonly hostId: string;
+ readonly sessions: Promise<DesktopSessionSummary[]>;
+}
+
+export interface RuntimeHostSessionCatalogCoverage {
+ readonly sessions: DesktopSessionSummary[];
+ readonly completeHostIds: string[];
+}
+
+export async function collectRuntimeHostSessionCatalogsWithCoverage(
+ requests: readonly RuntimeHostSessionCatalogRequest[],
+): Promise<RuntimeHostSessionCatalogCoverage> {
+ const results = await Promise.allSettled(requests.map((request) => request.sessions));
+ const fulfilled = results.flatMap((result, index) => result.status === 'fulfilled'
+ ? [{ hostId: requests[index]!.hostId, sessions: result.value }]
+ : []);
+ if (requests.length > 0 && fulfilled.length === 0) {
+ throw new AggregateError(
+ results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []),
+ 'Every Runtime Host Session Catalog request failed',
+ );
+ }
+ return {
+ sessions: sortSessionCatalogs(fulfilled.flatMap((entry) => entry.sessions)),
+ completeHostIds: fulfilled.map((entry) => entry.hostId),
+ };
+}
+
export async function collectRuntimeHostSessionCatalogs(
requests: readonly Promise<DesktopSessionSummary[]>[],
): Promise<DesktopSessionSummary[]> {
@@ -30,7 +59,11 @@ export async function collectRuntimeHostSessionCatalogs(
'Every Runtime Host Session Catalog request failed',
);
}
- return groups.flat().sort((left, right) => {
+ return sortSessionCatalogs(groups.flat());
+}
+
+function sortSessionCatalogs(sessions: DesktopSessionSummary[]): DesktopSessionSummary[] {
+ return sessions.sort((left, right) => {
if (left.activityAt === undefined || right.activityAt === undefined) {
throw new Error('Runtime Host Session Catalog activity is unavailable');
}
diff --git a/apps/desktop/src/renderer/app-shell.tsx b/apps/desktop/src/renderer/app-shell.tsx
index 30ed340d2..c599125ae 100644
--- a/apps/desktop/src/renderer/app-shell.tsx
+++ b/apps/desktop/src/renderer/app-shell.tsx
@@ -1476,14 +1476,21 @@ function AppShellContent({
captureActiveComposerClaim,
});
refreshProjectSkillsRef.current = moduleHub.commands.refreshProjectSkills;
- const workHubController = useMemo(() => createWorkHubController({
- sessions: createDesktopWorkHubSessionPort({
- sessions: window.maka.sessions,
- transcripts: window.maka.transcripts,
- projectName: (projectId) => projects.find((project) => project.id === projectId)?.name,
- newTurnId: () => crypto.randomUUID(),
- }),
- }), [projects]);
+ const workHubProjectsRef = useRef(projects);
+ workHubProjectsRef.current = projects;
+ const workHubControllerRef = useRef<ReturnType<typeof createWorkHubController> | null>(null);
+ if (!workHubControllerRef.current) {
+ workHubControllerRef.current = createWorkHubController({
+ sessions: createDesktopWorkHubSessionPort({
+ sessions: window.maka.sessions,
+ transcripts: window.maka.transcripts,
+ projectName: (projectId) =>
+ workHubProjectsRef.current.find((project) => project.id === projectId)?.name,
+ newTurnId: () => crypto.randomUUID(),
+ }),
+ });
+ }
+ const workHubController = workHubControllerRef.current;
// Where a NEW chat starts. Built unconditionally and handed to the composer,
// which renders it only while no session owns it — the project is fixed once
// the first message creates one, so there is nothing to pick after that.
@@ -2802,6 +2809,7 @@ function AppShellContent({
<WorkHubSurface
controller={workHubController}
locale={uiLocale}
+ {...(activeId ? { initialFocusSessionId: activeId } : {})}
onOpenSession={openSessionInChat}
/>
) : (
diff --git a/apps/desktop/src/renderer/styles/workhub.css b/apps/desktop/src/renderer/styles/workhub.css
index 369a71c03..ff666d9d9 100644
--- a/apps/desktop/src/renderer/styles/workhub.css
+++ b/apps/desktop/src/renderer/styles/workhub.css
@@ -91,6 +91,15 @@
flex-direction: column;
}
+.workhub-loading-user {
+ display: flex;
+ justify-content: flex-end;
+}
+
+.workhub-loading-turn {
+ min-height: 172px;
+}
+
.workhub-turn {
display: flex;
flex-direction: column;
diff --git a/apps/desktop/src/renderer/workhub-controller.ts b/apps/desktop/src/renderer/workhub-controller.ts
index 514d47794..e382ee7fd 100644
--- a/apps/desktop/src/renderer/workhub-controller.ts
+++ b/apps/desktop/src/renderer/workhub-controller.ts
@@ -47,11 +47,13 @@ export interface WorkHubSessionFacts {
kind: 'ordinary' | 'internal' | 'subagent';
archived: boolean;
state: WorkHubSessionState;
+ /** Authoritative live Turn IDs when the Session catalog provides them. */
+ runningTurnIds?: readonly string[];
latestResult?: string;
updatedAt: number;
}
-export type WorkHubSessionSummary = Omit<WorkHubSessionFacts, 'kind'>;
+export type WorkHubSessionSummary = Omit<WorkHubSessionFacts, 'kind' | 'runningTurnIds'>;
export type WorkHubProjectedTurnState = 'running' | 'completed' | 'aborted' | 'failed';
@@ -84,14 +86,20 @@ export interface WorkHubSubmitInput {
requestId: string;
text: string;
explicitTarget?: WorkHubSessionTarget;
- correction?: {
- from: WorkHubSessionTarget;
- turnId: string;
- steered?: true;
- };
+ correction?: WorkHubCorrectionContext;
+}
+
+export interface WorkHubCorrectionContext {
+ from: WorkHubSessionTarget;
+ turnId?: string;
+ steered?: true;
+}
+
+export interface WorkHubReadInput {
+ focus?: WorkHubSessionTarget;
}
-export const WORKHUB_ROUTING_STRATEGY_ID = 'wh-r2.3-session-core-evidence' as const;
+export const WORKHUB_ROUTING_STRATEGY_ID = 'wh-r2.4-session-context-continuity' as const;
export type WorkHubRoutingStrategyId = typeof WORKHUB_ROUTING_STRATEGY_ID;
export type WorkHubSubmission = (
@@ -109,6 +117,7 @@ export type WorkHubSubmission = (
requestId: string;
text: string;
options: Array<Pick<WorkHubSessionSummary, 'target' | 'projectName' | 'sessionName'>>;
+ correction?: WorkHubCorrectionContext;
}
| {
kind: 'discussion';
@@ -129,6 +138,14 @@ export type WorkHubSubmission = (
*/
export interface WorkHubSessionPort {
list(): Promise<WorkHubSessionFacts[]>;
+ /**
+ * Lists Sessions with per-target catalog coverage. A target missing from a
+ * partial multi-Host list is not authoritatively absent.
+ */
+ listCatalog?(): Promise<{
+ sessions: WorkHubSessionFacts[];
+ isCompleteFor(target: WorkHubSessionTarget): boolean;
+ }>;
/**
* Rebuilds a bounded recent conversation from the authoritative Session
* transcripts. Missing transcripts are omitted rather than copied elsewhere.
@@ -142,41 +159,448 @@ export interface WorkHubSessionPort {
targets: readonly WorkHubSessionTarget[],
): Promise<Array<{ target: WorkHubSessionTarget; originPrompt?: string }>>;
create(input: { name: string }): Promise<WorkHubSessionFacts>;
+ reserveTurnId(): string;
submit(
target: WorkHubSessionTarget,
text: string,
+ turnId: string,
): Promise<{ turnId: string; steered?: true }>;
+ reconcileSubmission(
+ target: WorkHubSessionTarget,
+ reservedTurnId: string,
+ ): Promise<
+ | { kind: 'root'; turnId: string }
+ | { kind: 'steered' }
+ | { kind: 'unknown' }
+ >;
stop(target: WorkHubSessionTarget, expectedTurnId: string): Promise<void>;
subscribe(handler: () => void): () => void;
}
+export class WorkHubSessionSubmitError extends Error {
+ constructor(
+ message: string,
+ readonly admission: 'rejected' | 'unknown',
+ options?: ErrorOptions,
+ ) {
+ super(message, options);
+ this.name = 'WorkHubSessionSubmitError';
+ }
+}
+
export interface WorkHubController {
- read(): Promise<WorkHubProjection>;
+ read(input?: WorkHubReadInput): Promise<WorkHubProjection>;
submit(input: WorkHubSubmitInput): Promise<WorkHubSubmission>;
subscribe(handler: () => void): () => void;
+ resetVisitContext(): void;
+}
+
+const MAX_TRACKED_WORKHUB_ROOTS = 32;
+
+interface WorkHubRootOwnership {
+ order: number;
+ turnId: string;
+}
+
+interface WorkHubPendingAdmission extends WorkHubRootOwnership {
+ state: 'in_flight' | 'uncertain';
+}
+
+interface WorkHubOwnershipTombstone {
+ order: number;
+ stoppedTurnIds: Set<string>;
}
export function createWorkHubController(deps: {
sessions: WorkHubSessionPort;
}): WorkHubController {
- const routePolicy = createWorkHubRoutePolicy();
+ let routePolicy = createWorkHubRoutePolicy();
+ let focusReadVersion = 0;
+ let pendingFocusReadVersion: number | undefined;
+ const confirmedOwnershipBySessionId = new Map<string, WorkHubRootOwnership>();
+ const pendingAdmissionsBySessionId = new Map<string, WorkHubPendingAdmission[]>();
+ const ownershipTombstoneBySessionId = new Map<string, WorkHubOwnershipTombstone>();
+ const stopAttemptByTurn = new Map<string, Promise<void>>();
+ const stopOperationCountBySessionId = new Map<string, number>();
+ let ownershipRevision = 0;
+ const reconcileFocus = (
+ policy: ReturnType<typeof createWorkHubRoutePolicy>,
+ sessions: readonly WorkHubSessionFacts[],
+ ) => {
+ policy.initializeFocus(sessions
+ .filter((session) => session.kind === 'ordinary' && !session.archived)
+ .sort((left, right) => right.updatedAt - left.updatedAt)
+ .map((session) => session.target));
+ };
+ const correctionFor = (from: WorkHubSessionTarget): WorkHubCorrectionContext => {
+ const confirmed = confirmedOwnershipBySessionId.get(from.sessionId);
+ const pending = pendingAdmissionsBySessionId.get(from.sessionId);
+ const turnId = confirmed?.turnId ?? pending?.at(-1)?.turnId;
+ if (!turnId) return { from };
+ return {
+ from,
+ turnId,
+ };
+ };
+ const pendingAdmissions = (sessionId: string): WorkHubPendingAdmission[] =>
+ pendingAdmissionsBySessionId.get(sessionId) ?? [];
+ const setPendingAdmissions = (
+ sessionId: string,
+ pending: WorkHubPendingAdmission[],
+ ) => {
+ ownershipRevision += 1;
+ if (pending.length === 0) {
+ pendingAdmissionsBySessionId.delete(sessionId);
+ return;
+ }
+ pendingAdmissionsBySessionId.set(
+ sessionId,
+ [...pending].sort((left, right) => left.order - right.order),
+ );
+ };
+ const trackedRootCount = () => {
+ let pendingCount = 0;
+ for (const pending of pendingAdmissionsBySessionId.values()) {
+ pendingCount += pending.length;
+ }
+ return confirmedOwnershipBySessionId.size + pendingCount;
+ };
+ const maybeRetireTombstone = (sessionId: string) => {
+ const tombstone = ownershipTombstoneBySessionId.get(sessionId);
+ if (!tombstone) return;
+ if ((stopOperationCountBySessionId.get(sessionId) ?? 0) > 0) return;
+ if (pendingAdmissions(sessionId).some((candidate) => candidate.order <= tombstone.order)) {
+ return;
+ }
+ ownershipTombstoneBySessionId.delete(sessionId);
+ };
+ const readCatalog = async () => {
+ const revisionAtStart = ownershipRevision;
+ const catalog = deps.sessions.listCatalog
+ ? await deps.sessions.listCatalog()
+ : {
+ sessions: await deps.sessions.list(),
+ isCompleteFor: () => false,
+ };
+ return {
+ catalog,
+ // A catalog request that overlapped an ownership mutation may describe
+ // the state before that mutation. It remains useful for projection, but
+ // it must not authoritatively prune newer ownership or admissions.
+ allowAuthoritativePruning: revisionAtStart === ownershipRevision,
+ };
+ };
+ const reconcileConfirmedOwnership = (catalog: {
+ sessions: readonly WorkHubSessionFacts[];
+ isCompleteFor(target: WorkHubSessionTarget): boolean;
+ }, allowAuthoritativePruning: boolean) => {
+ if (!allowAuthoritativePruning) return;
+ const { sessions } = catalog;
+ const sessionById = new Map(sessions.map((session) => [session.target.sessionId, session]));
+ for (const [sessionId, ownership] of confirmedOwnershipBySessionId) {
+ const session = sessionById.get(sessionId);
+ if (
+ (!session && catalog.isCompleteFor({ sessionId })) ||
+ session?.archived ||
+ (session?.runningTurnIds !== undefined &&
+ !session.runningTurnIds.includes(ownership.turnId))
+ ) {
+ if (confirmedOwnershipBySessionId.delete(sessionId)) {
+ ownershipRevision += 1;
+ }
+ }
+ }
+ };
+ const storeOwnershipTombstone = (
+ sessionId: string,
+ order: number,
+ stoppedTurnIds: Iterable<string> = [],
+ ) => {
+ const existing = ownershipTombstoneBySessionId.get(sessionId);
+ if (existing && existing.order > order) return;
+ const stopped = new Set(existing?.order === order ? existing.stoppedTurnIds : []);
+ for (const turnId of stoppedTurnIds) stopped.add(turnId);
+ ownershipTombstoneBySessionId.set(sessionId, {
+ order,
+ stoppedTurnIds: stopped,
+ });
+ };
+ const reserveOwnedRoot = (
+ target: WorkHubSessionTarget,
+ turnId: string,
+ order: number,
+ ) => {
+ if (trackedRootCount() >= MAX_TRACKED_WORKHUB_ROOTS) {
+ throw new Error('WorkHub has too many unresolved root submissions');
+ }
+ setPendingAdmissions(target.sessionId, [
+ ...pendingAdmissions(target.sessionId),
+ { order, turnId, state: 'in_flight' },
+ ]);
+ };
+ const removePendingRoot = (
+ target: WorkHubSessionTarget,
+ reservedTurnId: string,
+ order: number,
+ ) => {
+ setPendingAdmissions(
+ target.sessionId,
+ pendingAdmissions(target.sessionId).filter((candidate) =>
+ candidate.order !== order || candidate.turnId !== reservedTurnId),
+ );
+ };
+ const markPendingRootUncertain = (
+ target: WorkHubSessionTarget,
+ reservedTurnId: string,
+ order: number,
+ ) => {
+ setPendingAdmissions(
+ target.sessionId,
+ pendingAdmissions(target.sessionId).map((candidate) =>
+ candidate.order === order && candidate.turnId === reservedTurnId
+ ? { ...candidate, state: 'uncertain' }
+ : candidate),
+ );
+ };
+ const attemptStop = (
+ target: WorkHubSessionTarget,
+ turnId: string,
+ ): Promise<void> => {
+ const key = `${target.sessionId}\0${turnId}`;
+ const existing = stopAttemptByTurn.get(key);
+ if (existing) return existing;
+ stopOperationCountBySessionId.set(
+ target.sessionId,
+ (stopOperationCountBySessionId.get(target.sessionId) ?? 0) + 1,
+ );
+ const stopping = deps.sessions.stop(target, turnId).finally(() => {
+ stopAttemptByTurn.delete(key);
+ const remaining = (stopOperationCountBySessionId.get(target.sessionId) ?? 1) - 1;
+ if (remaining === 0) {
+ stopOperationCountBySessionId.delete(target.sessionId);
+ } else {
+ stopOperationCountBySessionId.set(target.sessionId, remaining);
+ }
+ });
+ stopAttemptByTurn.set(key, stopping);
+ return stopping;
+ };
+ const settleOwnedRoot = async (
+ target: WorkHubSessionTarget,
+ reservedTurnId: string,
+ turn: { turnId: string; steered?: true },
+ order: number,
+ ) => {
+ const tombstone = ownershipTombstoneBySessionId.get(target.sessionId);
+ let stopped = false;
+ let stopFailure: unknown;
+ if (!turn.steered && tombstone && tombstone.order >= order) {
+ stopped = tombstone.stoppedTurnIds.has(turn.turnId);
+ if (!stopped) {
+ try {
+ const priorStopAttempt = stopAttemptByTurn.get(
+ `${target.sessionId}\0${turn.turnId}`,
+ );
+ if (priorStopAttempt) {
+ try {
+ await priorStopAttempt;
+ } catch {
+ // Admission is new evidence. Retry against the admitted root even
+ // when the earlier pre-admission Stop failed or observed nothing.
+ }
+ }
+ await attemptStop(target, turn.turnId);
+ const currentBarrier = ownershipTombstoneBySessionId.get(target.sessionId);
+ if (currentBarrier && currentBarrier.order >= order) {
+ storeOwnershipTombstone(target.sessionId, currentBarrier.order, [turn.turnId]);
+ }
+ stopped = true;
+ } catch (error) {
+ stopFailure = error;
+ }
+ }
+ }
+ removePendingRoot(target, reservedTurnId, order);
+ if (!turn.steered && !stopped) {
+ const confirmed = confirmedOwnershipBySessionId.get(target.sessionId);
+ if (!confirmed || confirmed.order <= order) {
+ confirmedOwnershipBySessionId.set(target.sessionId, {
+ order,
+ turnId: turn.turnId,
+ });
+ ownershipRevision += 1;
+ }
+ }
+ maybeRetireTombstone(target.sessionId);
+ if (stopFailure) throw stopFailure;
+ };
+ const releasePendingRoot = (
+ target: WorkHubSessionTarget,
+ reservedTurnId: string,
+ order: number,
+ ) => {
+ removePendingRoot(target, reservedTurnId, order);
+ maybeRetireTombstone(target.sessionId);
+ };
+ const reconcilePendingRoot = async (
+ target: WorkHubSessionTarget,
+ reservedTurnId: string,
+ order: number,
+ ): Promise<boolean> => {
+ const reconciliation = await deps.sessions.reconcileSubmission(target, reservedTurnId);
+ if (reconciliation.kind === 'unknown') return false;
+ await settleOwnedRoot(
+ target,
+ reservedTurnId,
+ reconciliation.kind === 'steered'
+ ? { turnId: reservedTurnId, steered: true }
+ : { turnId: reconciliation.turnId },
+ order,
+ );
+ return true;
+ };
+ const reconcileUncertainAdmissions = (catalog: {
+ sessions: readonly WorkHubSessionFacts[];
+ isCompleteFor(target: WorkHubSessionTarget): boolean;
+ }, allowAuthoritativePruning: boolean): Promise<void> | undefined => {
+ const sessionById = new Map(
+ catalog.sessions.map((session) => [session.target.sessionId, session]),
+ );
+ const uncertain = [...pendingAdmissionsBySessionId.entries()]
+ .flatMap(([sessionId, pending]) => pending
+ .filter((candidate) => candidate.state === 'uncertain')
+ .map((candidate) => ({
+ target: { sessionId },
+ ...candidate,
+ })));
+ if (uncertain.length === 0) return undefined;
+ return Promise.all(uncertain.map(async ({ target, turnId, order }) => {
+ const session = sessionById.get(target.sessionId);
+ if (
+ allowAuthoritativePruning &&
+ (session?.archived || (!session && catalog.isCompleteFor(target)))
+ ) {
+ releasePendingRoot(target, turnId, order);
+ return;
+ }
+ try {
+ await reconcilePendingRoot(target, turnId, order);
+ } catch {
+ // Failed reconciliation preserves the pending or confirmed ownership.
+ }
+ })).then(() => undefined);
+ };
+ const assertSubmissionBarrierOpen = (target: WorkHubSessionTarget) => {
+ maybeRetireTombstone(target.sessionId);
+ const tombstone = ownershipTombstoneBySessionId.get(target.sessionId);
+ const stopCount = stopOperationCountBySessionId.get(target.sessionId) ?? 0;
+ const pendingBarrier = tombstone && pendingAdmissions(target.sessionId)
+ .some((candidate) => candidate.order <= tombstone.order);
+ if (stopCount > 0 || pendingBarrier) {
+ throw new Error('WorkHub is still reconciling a correction for this Session');
+ }
+ };
+ const stopOwnedRoots = async (
+ correction: WorkHubCorrectionContext,
+ order: number,
+ ) => {
+ if (correction.steered) return;
+ const confirmed = confirmedOwnershipBySessionId.get(correction.from.sessionId);
+ const pending = pendingAdmissions(correction.from.sessionId);
+ const turnIds = new Set<string>();
+ const unconfirmedTurnIds = new Set<string>();
+ if (correction.turnId) turnIds.add(correction.turnId);
+ if (confirmed && confirmed.order < order) {
+ turnIds.add(confirmed.turnId);
+ }
+ for (const candidate of pending) {
+ if (candidate.order < order) {
+ turnIds.add(candidate.turnId);
+ unconfirmedTurnIds.add(candidate.turnId);
+ }
+ }
+ if (turnIds.size === 0) return;
+ // Publish only the order barrier before awaiting Host acknowledgements.
+ // Individual IDs become tombstoned only after their Stop succeeds.
+ storeOwnershipTombstone(correction.from.sessionId, order);
+ const failures: unknown[] = [];
+ await Promise.all([...turnIds].map(async (turnId) => {
+ try {
+ await attemptStop(correction.from, turnId);
+ const barrier = ownershipTombstoneBySessionId.get(correction.from.sessionId);
+ if (barrier && barrier.order >= order && !unconfirmedTurnIds.has(turnId)) {
+ storeOwnershipTombstone(correction.from.sessionId, barrier.order, [turnId]);
+ }
+ const owned = confirmedOwnershipBySessionId.get(correction.from.sessionId);
+ if (owned && owned.order < order && owned.turnId === turnId) {
+ confirmedOwnershipBySessionId.delete(correction.from.sessionId);
+ ownershipRevision += 1;
+ }
+ } catch (error) {
+ failures.push(error);
+ }
+ }));
+ maybeRetireTombstone(correction.from.sessionId);
+ if (failures.length > 0) throw failures[0];
+ };
return {
subscribe(handler) {
return deps.sessions.subscribe(handler);
},
- async read() {
- const facts = await deps.sessions.list();
- const ordinary = facts
- .filter((session) => session.kind === 'ordinary')
- .sort((left, right) => right.updatedAt - left.updatedAt);
- return {
- sessions: ordinary
- .map(({ kind: _kind, ...session }) => session),
- turns: await deps.sessions.recentTurns(ordinary.map((session) => session.target)),
- };
+ async read(input) {
+ const readPolicy = routePolicy;
+ let readFocusVersion = focusReadVersion;
+ if (input?.focus) {
+ readFocusVersion = ++focusReadVersion;
+ pendingFocusReadVersion = readFocusVersion;
+ readPolicy.rememberTarget(input.focus);
+ }
+ try {
+ const { catalog, allowAuthoritativePruning } =
+ await readCatalog();
+ reconcileConfirmedOwnership(catalog, allowAuthoritativePruning);
+ const reconciliation = reconcileUncertainAdmissions(
+ catalog,
+ allowAuthoritativePruning,
+ );
+ if (reconciliation) await reconciliation;
+ const facts = catalog.sessions;
+ const ordinary = facts
+ .filter((session) => session.kind === 'ordinary')
+ .sort((left, right) => right.updatedAt - left.updatedAt);
+ if (
+ readFocusVersion === focusReadVersion &&
+ (input?.focus || pendingFocusReadVersion === undefined)
+ ) {
+ reconcileFocus(readPolicy, facts);
+ }
+ return {
+ sessions: ordinary
+ .map(({ kind: _kind, runningTurnIds: _runningTurnIds, ...session }) => session),
+ turns: await deps.sessions.recentTurns(ordinary.map((session) => session.target)),
+ };
+ } finally {
+ if (input?.focus && pendingFocusReadVersion === readFocusVersion) {
+ pendingFocusReadVersion = undefined;
+ }
+ }
},
async submit(input) {
- const sessions = await deps.sessions.list();
+ const submissionPolicy = routePolicy;
+ // Reserve the order synchronously, before any await. Corrections are
+ // learned only after successful delivery, but their precedence follows
+ // user submission order rather than network completion order.
+ const submissionOrder = submissionPolicy.reserveSubmissionOrder();
+ const { catalog, allowAuthoritativePruning } =
+ await readCatalog();
+ reconcileConfirmedOwnership(catalog, allowAuthoritativePruning);
+ const reconciliation = reconcileUncertainAdmissions(
+ catalog,
+ allowAuthoritativePruning,
+ );
+ if (reconciliation) await reconciliation;
+ const sessions = catalog.sessions;
+ reconcileFocus(submissionPolicy, sessions);
const ordinary = sessions.filter((session) => session.kind === 'ordinary');
// Archived Sessions remain visible as historical work, but Runtime Host
// rejects new root Turns for them. Never offer one as a routing target.
@@ -184,7 +608,7 @@ export function createWorkHubController(deps: {
const routingEvidence = input.explicitTarget
? []
: await deps.sessions.routingEvidence(routable.map((session) => session.target));
- const decision = routePolicy.resolve({
+ const decision = submissionPolicy.resolve({
text: input.text,
sessions: routable,
originPromptBySessionId: new Map(
@@ -193,6 +617,9 @@ export function createWorkHubController(deps: {
...(input.explicitTarget ? { explicitTarget: input.explicitTarget } : {}),
});
if (decision.kind === 'clarification') {
+ const correction = decision.correctedFrom
+ ? correctionFor(decision.correctedFrom)
+ : undefined;
return {
kind: 'clarification',
strategyId: WORKHUB_ROUTING_STRATEGY_ID,
@@ -203,6 +630,7 @@ export function createWorkHubController(deps: {
projectName: session.projectName,
sessionName: session.sessionName,
})),
+ ...(correction ? { correction } : {}),
};
}
if (decision.kind === 'discussion') {
@@ -215,6 +643,9 @@ export function createWorkHubController(deps: {
}
let target: WorkHubSessionTarget;
let evidence: Extract<WorkHubSubmission, { kind: 'submitted' }>['evidence'];
+ const correction = input.correction ?? (decision.kind === 'target' && decision.correctedFrom
+ ? correctionFor(decision.correctedFrom)
+ : undefined);
if (decision.kind === 'new_session') {
const created = await deps.sessions.create({ name: workHubNewSessionName(input.text) });
if (created.kind !== 'ordinary') {
@@ -224,7 +655,7 @@ export function createWorkHubController(deps: {
evidence = 'new_session';
} else {
target = decision.target;
- evidence = input.correction ? 'route_correction' : decision.evidence;
+ evidence = correction ? 'route_correction' : decision.evidence;
}
const targetSession = routable.find(
(session) => session.target.sessionId === target.sessionId,
@@ -241,12 +672,37 @@ export function createWorkHubController(deps: {
target,
};
}
- if (input.correction && !input.correction.steered) {
- await deps.sessions.stop(input.correction.from, input.correction.turnId);
+ if (correction) {
+ await stopOwnedRoots(correction, submissionOrder);
+ }
+ assertSubmissionBarrierOpen(target);
+ const reservedTurnId = deps.sessions.reserveTurnId();
+ reserveOwnedRoot(target, reservedTurnId, submissionOrder);
+ let turn: { turnId: string; steered?: true };
+ try {
+ turn = await deps.sessions.submit(target, input.text, reservedTurnId);
+ } catch (error) {
+ if (
+ error instanceof WorkHubSessionSubmitError &&
+ error.admission === 'rejected'
+ ) {
+ releasePendingRoot(target, reservedTurnId, submissionOrder);
+ } else {
+ markPendingRootUncertain(target, reservedTurnId, submissionOrder);
+ try {
+ await reconcilePendingRoot(target, reservedTurnId, submissionOrder);
+ } catch {
+ // The original delivery error remains primary. Reconciliation keeps
+ // any unresolved admission reachable for a later read/correction.
+ }
+ }
+ throw error;
+ }
+ await settleOwnedRoot(target, reservedTurnId, turn, submissionOrder);
+ submissionPolicy.rememberTarget(target);
+ if (correction) {
+ submissionPolicy.rememberCorrection(input.text, target, submissionOrder);
}
- const turn = await deps.sessions.submit(target, input.text);
- routePolicy.rememberTarget(target);
- if (input.correction) routePolicy.rememberCorrection(input.text, target);
return {
kind: 'submitted',
strategyId: WORKHUB_ROUTING_STRATEGY_ID,
@@ -255,8 +711,13 @@ export function createWorkHubController(deps: {
turnId: turn.turnId,
...(turn.steered ? { steered: true as const } : {}),
evidence,
- ...(input.correction ? { correctedFrom: input.correction.from } : {}),
+ ...(correction ? { correctedFrom: correction.from } : {}),
};
},
+ resetVisitContext() {
+ focusReadVersion += 1;
+ pendingFocusReadVersion = undefined;
+ routePolicy = routePolicy.newVisit();
+ },
};
}
diff --git a/apps/desktop/src/renderer/workhub-route-policy.ts b/apps/desktop/src/renderer/workhub-route-policy.ts
index 570031ba1..7edb39b5a 100644
--- a/apps/desktop/src/renderer/workhub-route-policy.ts
+++ b/apps/desktop/src/renderer/workhub-route-policy.ts
@@ -34,10 +34,12 @@ export type WorkHubRouteDecision =
kind: 'target';
target: WorkHubSessionTarget;
evidence: WorkHubRouteEvidence;
+ correctedFrom?: WorkHubSessionTarget;
}
| {
kind: 'clarification';
options: WorkHubSessionFacts[];
+ correctedFrom?: WorkHubSessionTarget;
}
| { kind: 'discussion' }
| { kind: 'new_session' };
@@ -49,8 +51,11 @@ export interface WorkHubRoutePolicy {
originPromptBySessionId: ReadonlyMap<string, string | undefined>;
explicitTarget?: WorkHubSessionTarget;
}): WorkHubRouteDecision;
+ initializeFocus(targets: readonly WorkHubSessionTarget[]): void;
+ newVisit(): WorkHubRoutePolicy;
rememberTarget(target: WorkHubSessionTarget): void;
- rememberCorrection(text: string, target: WorkHubSessionTarget): void;
+ reserveSubmissionOrder(): number;
+ rememberCorrection(text: string, target: WorkHubSessionTarget, order: number): void;
}
export function workHubNewSessionName(text: string): string {
@@ -76,6 +81,11 @@ interface RouteCorrection {
sequence: number;
}
+interface RouteCorrectionMemory {
+ corrections: RouteCorrection[];
+ sequence: number;
+}
+
const MAX_ROUTE_CORRECTIONS = 32;
const MIN_EXACT_SESSION_NAME_LENGTH = 2;
const MIN_CORRECTION_TERM_LENGTH = 3;
@@ -88,16 +98,21 @@ const MAX_UNCERTAINTY_OPTIONS = 5;
const MAX_RELATED_CLARIFICATION_OPTIONS = 4;
/**
- * Deep routing module for R2.3.
+ * Deep routing module for R2.4.
*
* It owns only transient inference context. Session identity, transcript,
* execution state, and recovery continue to come from the Session port.
*/
export function createWorkHubRoutePolicy(): WorkHubRoutePolicy {
+ return createWorkHubRoutePolicyVisit({ corrections: [], sequence: 0 });
+}
+
+function createWorkHubRoutePolicyVisit(
+ correctionMemory: RouteCorrectionMemory,
+): WorkHubRoutePolicy {
let currentFocus: WorkHubSessionTarget | undefined;
let previousFocus: WorkHubSessionTarget | undefined;
- const corrections: RouteCorrection[] = [];
- let correctionSequence = 0;
+ const corrections = correctionMemory.corrections;
return {
resolve({ text, sessions, originPromptBySessionId, explicitTarget }) {
@@ -109,17 +124,58 @@ export function createWorkHubRoutePolicy(): WorkHubRoutePolicy {
return { kind: 'new_session' };
}
- const exact = sessions.map((session) => {
- const qualifiedName = `${session.projectName}/${session.sessionName}`;
+ const correctionText = naturalCorrectionTargetText(text);
+ const correctedFrom = currentFocus && sessions.some((session) =>
+ session.target.sessionId === currentFocus?.sessionId)
+ ? currentFocus
+ : undefined;
+ if (
+ !correctionText &&
+ correctedFrom &&
+ looksLikeRecentFocus(text) &&
+ looksLikeContentReplacement(text)
+ ) {
+ return { kind: 'target', target: correctedFrom, evidence: 'recent_focus' };
+ }
+ if (correctionText && correctedFrom) {
+ const alternatives = sessions.filter((session) =>
+ session.target.sessionId !== correctedFrom.sessionId);
+ const exactCorrection = rankExactSessions(correctionText, alternatives);
+ if (
+ exactCorrection[0] &&
+ exactCorrection[0].matchLength > (exactCorrection[1]?.matchLength ?? 0)
+ ) {
+ return {
+ kind: 'target',
+ target: exactCorrection[0].session.target,
+ evidence: 'route_correction',
+ correctedFrom,
+ };
+ }
+ const relatedCorrection = rankRelatedSessions(
+ correctionText,
+ alternatives,
+ originPromptBySessionId,
+ );
+ if (relatedCorrection.length === 1) {
+ return {
+ kind: 'target',
+ target: relatedCorrection[0]!.session.target,
+ evidence: 'route_correction',
+ correctedFrom,
+ };
+ }
+ const options = relatedCorrection.length > 1
+ ? relatedCorrection.map(({ session }) => session)
+ : alternatives.sort((left, right) => right.updatedAt - left.updatedAt);
return {
- session,
- matchLength: Math.max(
- exactIdentityMatchLength(text, qualifiedName),
- exactIdentityMatchLength(text, session.sessionName),
- ),
+ kind: 'clarification',
+ options: options.slice(0, MAX_UNCERTAINTY_OPTIONS),
+ correctedFrom,
};
- }).filter(({ matchLength }) => matchLength >= MIN_EXACT_SESSION_NAME_LENGTH)
- .sort((left, right) => right.matchLength - left.matchLength);
+ }
+
+ const exact = rankExactSessions(text, sessions);
if (exact[0] && exact[0].matchLength > (exact[1]?.matchLength ?? 0)) {
return {
kind: 'target',
@@ -152,19 +208,28 @@ export function createWorkHubRoutePolicy(): WorkHubRoutePolicy {
const previousReference = looksLikePreviousFocus(text);
const currentReference = !previousReference && looksLikeRecentFocus(text);
- const focused = previousReference
+ const focusCandidate = previousReference
? previousFocus
: currentReference
? currentFocus
: undefined;
+ const focused = focusCandidate && sessions.some((session) =>
+ session.target.sessionId === focusCandidate.sessionId)
+ ? focusCandidate
+ : undefined;
const strongEvidenceElsewhere = focused
? related.some(({ session, strongEvidence }) =>
session.target.sessionId !== focused.sessionId && strongEvidence)
: false;
+ const weakEvidenceElsewhere = focused
+ ? related.some(({ session }) => session.target.sessionId !== focused.sessionId)
+ : false;
const ambiguousEvidence = related.length > 1;
if (
focused &&
- (previousReference || (!strongEvidenceElsewhere && !ambiguousEvidence))
+ (previousReference || (
+ !strongEvidenceElsewhere && !weakEvidenceElsewhere && !ambiguousEvidence
+ ))
) {
return { kind: 'target', target: focused, evidence: 'recent_focus' };
}
@@ -194,19 +259,63 @@ export function createWorkHubRoutePolicy(): WorkHubRoutePolicy {
}
return looksExecutable(text) ? { kind: 'new_session' } : { kind: 'discussion' };
},
+ initializeFocus(targets) {
+ const ordered = targets.filter((target, index) =>
+ targets.findIndex((candidate) => candidate.sessionId === target.sessionId) === index);
+ const first = ordered[0];
+ if (!first) return;
+ const available = new Set(ordered.map((target) => target.sessionId));
+ if (currentFocus && !available.has(currentFocus.sessionId)) {
+ currentFocus = first;
+ previousFocus = ordered[1];
+ return;
+ }
+ if (!currentFocus) {
+ currentFocus = first;
+ previousFocus = ordered[1];
+ return;
+ }
+ if (!previousFocus || !available.has(previousFocus.sessionId)) {
+ previousFocus = ordered.find((target) => target.sessionId !== currentFocus?.sessionId);
+ }
+ },
+ newVisit() {
+ return createWorkHubRoutePolicyVisit(correctionMemory);
+ },
rememberTarget(target) {
if (currentFocus?.sessionId === target.sessionId) return;
previousFocus = currentFocus;
currentFocus = target;
},
- rememberCorrection(text, target) {
- correctionSequence += 1;
- corrections.unshift({ text, target, sequence: correctionSequence });
+ reserveSubmissionOrder() {
+ correctionMemory.sequence += 1;
+ return correctionMemory.sequence;
+ },
+ rememberCorrection(text, target, order) {
+ corrections.push({ text, target, sequence: order });
+ corrections.sort((left, right) => right.sequence - left.sequence);
corrections.splice(MAX_ROUTE_CORRECTIONS);
},
};
}
+function rankExactSessions(
+ text: string,
+ sessions: WorkHubSessionFacts[],
+): Array<{ session: WorkHubSessionFacts; matchLength: number }> {
+ return sessions.map((session) => {
+ const qualifiedName = `${session.projectName}/${session.sessionName}`;
+ return {
+ session,
+ matchLength: Math.max(
+ exactIdentityMatchLength(text, qualifiedName),
+ exactIdentityMatchLength(text, session.sessionName),
+ ),
+ };
+ }).filter(({ matchLength }) => matchLength >= MIN_EXACT_SESSION_NAME_LENGTH)
+ .sort((left, right) => right.matchLength - left.matchLength);
+}
+
function correctedTarget(
text: string,
sessions: WorkHubSessionFacts[],
@@ -297,6 +406,21 @@ function looksLikePreviousFocus(value: string): boolean {
);
}
+function naturalCorrectionTargetText(value: string): string | undefined {
+ const replacement = '(?:应该(?:是|用|改成|改为|切到|转到)?|而是|改成|改为|换成|换到|切到|转到|用|是)';
+ const chinese = value.match(
+ new RegExp(`(?:(?:不是|不要再继续)\\s*(?:(?:这个|那个|当前这个|刚才那个)(?:工作|任务|Session|会话)?|[^,,。;;\\n]{1,32}(?:那个|那项工作|Session|会话|工作|任务))|(?:(?:这个|那个|当前这个|刚才那个)(?:工作|任务|Session|会话)|[^,,。;;\\n]{1,32}(?:那个|那项工作|Session|会话|工作|任务))\\s*(?:不对|搞错了|弄错了))[,,。;;\\n]\\s*${replacement}\\s*(.{2,})$`, 'iu'),
+ )?.[1]?.trim();
+ if (chinese) return chinese;
+ return value.match(
+ /\b(?:not\s+(?:(?:this|that|the\s+current)(?:\s+(?:one|session|work|task))?|[^,.;\n]{1,32}\s+(?:session|work|task))|wrong\s+(?:one|session|work|task))\b[,.;\s]{0,4}(?:use|switch\s+to|change\s+to|move\s+to)\s+(.{2,})$/iu,
+ )?.[1]?.trim();
+}
+
+function looksLikeContentReplacement(value: string): boolean {
+ return /(?:不要(?:再)?用|别用|[^,,。;;\n]{1,32}(?:配置|实现|方案|字段|参数)?(?:不对|错了))[^\n]{0,64}[,,。;;]\s*(?:改成|改为|换成|换用|用)\s*\S{2,}/iu.test(value);
+}
+
function looksLikeTargetUncertainty(value: string): boolean {
return /(?:不确定(?:具体)?(?:是)?哪(?:一)?个|不知道(?:应该)?(?:选|继续|处理)哪(?:一)?个|可能是多个|哪个都可能|\b(?:i(?:'m| am)\s+)?not\s+sure\s+(?:which|where)|\b(?:i\s+)?(?:do\s+not|don't)\s+know\s+(?:which|where)|\b(?:could|might|may)\s+(?:be|belong\s+to)\s+(?:more\s+than\s+one|multiple)|\bwhich\s+(?:one|session|work|task)\b)/iu.test(
value,
diff --git a/apps/desktop/src/renderer/workhub-session-port.ts b/apps/desktop/src/renderer/workhub-session-port.ts
index 47234d0b3..4d6634463 100644
--- a/apps/desktop/src/renderer/workhub-session-port.ts
+++ b/apps/desktop/src/renderer/workhub-session-port.ts
@@ -22,6 +22,7 @@ import type {
DesktopTranscriptBatch,
DesktopTranscriptHandle,
} from '../preload/transcript-contract.js';
+import { parseDesktopSessionKey } from '../shared/runtime-host-identity.js';
import { DesktopTranscriptRangeStore } from './desktop-transcript-range-store.js';
import type {
WorkHubProjectedTurn,
@@ -30,7 +31,10 @@ import type {
WorkHubSessionState,
WorkHubSessionTarget,
} from './workhub-controller.js';
-import { boundedWorkHubTimelineText } from './workhub-controller.js';
+import {
+ boundedWorkHubTimelineText,
+ WorkHubSessionSubmitError,
+} from './workhub-controller.js';
export interface WorkHubDesktopSession {
id: string;
@@ -49,6 +53,10 @@ export interface WorkHubDesktopSession {
export interface WorkHubDesktopSessionBridge {
list(): Promise<readonly WorkHubDesktopSession[]>;
+ listWithCoverage?(): Promise<{
+ sessions: readonly WorkHubDesktopSession[];
+ completeHostIds: readonly string[];
+ }>;
listTurns(sessionId: string): Promise<readonly { userPromptPreview?: string }[]>;
create(input: { name: string }): Promise<WorkHubDesktopSession>;
send(
@@ -104,15 +112,37 @@ export function createDesktopWorkHubSessionPort(deps: {
: 'ordinary',
archived: session.isArchived,
state: projectState(session),
+ ...(session.runningTurnIds !== undefined
+ ? { runningTurnIds: [...session.runningTurnIds] }
+ : {}),
...(session.lastMessagePreview
? { latestResult: session.lastMessagePreview }
: {}),
updatedAt: session.lastMessageAt ?? session.statusUpdatedAt ?? 0,
});
+ const projectCatalog = async () => {
+ const snapshot = deps.sessions.listWithCoverage
+ ? await deps.sessions.listWithCoverage()
+ : { sessions: await deps.sessions.list(), completeHostIds: [] };
+ const completeHostIds = new Set(snapshot.completeHostIds);
+ return {
+ sessions: snapshot.sessions.map(projectSession),
+ isCompleteFor(target: WorkHubSessionTarget) {
+ try {
+ return completeHostIds.has(parseDesktopSessionKey(target.sessionId).hostId);
+ } catch {
+ return false;
+ }
+ },
+ };
+ };
return {
async list() {
- return (await deps.sessions.list()).map(projectSession);
+ return (await projectCatalog()).sessions;
+ },
+ listCatalog() {
+ return projectCatalog();
},
async recentTurns(targets) {
const turnsBySession = await Promise.all(
@@ -157,19 +187,60 @@ export function createDesktopWorkHubSessionPort(deps: {
async create({ name }) {
return projectSession(await deps.sessions.create({ name }));
},
- async submit(target: WorkHubSessionTarget, text: string) {
- const turnId = deps.newTurnId();
- const result = await deps.sessions.send(target.sessionId, {
- type: 'send',
- turnId,
- text,
- });
- if (!result.ok) throw new Error(`WorkHub Session send failed: ${result.reason}`);
+ reserveTurnId() {
+ return deps.newTurnId();
+ },
+ async submit(target: WorkHubSessionTarget, text: string, turnId: string) {
+ let result: Awaited<ReturnType<WorkHubDesktopSessionBridge['send']>>;
+ try {
+ result = await deps.sessions.send(target.sessionId, {
+ type: 'send',
+ turnId,
+ text,
+ });
+ } catch (cause) {
+ throw new WorkHubSessionSubmitError(
+ 'WorkHub Session delivery outcome is unknown',
+ 'unknown',
+ { cause },
+ );
+ }
+ if (!result.ok) {
+ throw new WorkHubSessionSubmitError(
+ `WorkHub Session send failed: ${result.reason}`,
+ 'rejected',
+ );
+ }
return {
turnId: result.turnId,
...(result.steered ? { steered: true as const } : {}),
};
},
+ async reconcileSubmission(target, reservedTurnId) {
+ try {
+ const messages = await readWorkHubSessionMessages(deps.transcripts, target);
+ let message: Extract<StoredMessage, { type: 'user' }> | undefined;
+ for (let index = messages.length - 1; index >= 0; index -= 1) {
+ const entry = messages[index];
+ if (
+ entry?.type === 'user' &&
+ (entry.turnId === reservedTurnId || entry.id === reservedTurnId)
+ ) {
+ message = entry;
+ break;
+ }
+ }
+ if (!message) return { kind: 'unknown' };
+ if (message.turnId === reservedTurnId) {
+ return { kind: 'root', turnId: message.turnId };
+ }
+ return message.steeringEventId
+ ? { kind: 'steered' }
+ : { kind: 'root', turnId: message.turnId };
+ } catch {
+ return { kind: 'unknown' };
+ }
+ },
async stop(target, expectedTurnId) {
await deps.sessions.stop(target.sessionId, {
source: 'stop_button',
diff --git a/apps/desktop/src/renderer/workhub-surface.tsx b/apps/desktop/src/renderer/workhub-surface.tsx
index 143241c78..2c755452d 100644
--- a/apps/desktop/src/renderer/workhub-surface.tsx
+++ b/apps/desktop/src/renderer/workhub-surface.tsx
@@ -18,7 +18,12 @@
*/
import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react';
-import { ChatMessage, ChatMessageBubble, ChatMessageList } from '@astryxdesign/core';
+import {
+ ChatMessage,
+ ChatMessageBubble,
+ ChatMessageList,
+ Skeleton,
+} from '@astryxdesign/core';
import { Button } from '@astryxdesign/core/Button';
import type { UiLocale } from '@maka/core/ui-locale';
import { ChatSurfaceLayout, Composer } from '@maka/ui';
@@ -147,38 +152,45 @@ export function projectedWorkHubTurnPresentation(
export function WorkHubSurface(props: {
controller: WorkHubController;
locale: UiLocale;
+ initialFocusSessionId?: string;
onOpenSession(sessionId: string): void;
}) {
const copy = workHubCopy(props.locale);
const [projection, setProjection] = useState<WorkHubProjection>({ sessions: [], turns: [] });
const [turns, setTurns] = useState<WorkHubConversationTurn[]>([]);
const [pending, setPending] = useState(false);
+ const [initialLoadSettled, setInitialLoadSettled] = useState(false);
// React state paints the lock; the gate closes the same-frame window before
// a rerender can disable Composer and clarification controls.
const routeGate = useRef(new WorkHubSurfaceRouteGate()).current;
const refreshGate = useRef(new WorkHubProjectionRefreshGate()).current;
const [loadError, setLoadError] = useState(false);
- const refresh = useCallback(async () => {
+ const refresh = useCallback(async (focusSessionId?: string) => {
const isLatest = refreshGate.begin();
try {
- const next = await props.controller.read();
+ const next = await props.controller.read(focusSessionId
+ ? { focus: { sessionId: focusSessionId } }
+ : undefined);
if (!isLatest()) return;
setProjection(next);
setLoadError(false);
+ setInitialLoadSettled(true);
} catch {
if (!isLatest()) return;
setLoadError(true);
+ setInitialLoadSettled(true);
}
}, [props.controller, refreshGate]);
useEffect(() => {
- void refresh();
+ void refresh(props.initialFocusSessionId);
const unsubscribe = props.controller.subscribe(() => void refresh());
return () => {
refreshGate.invalidate();
unsubscribe();
+ props.controller.resetVisitContext();
};
- }, [props.controller, refresh, refreshGate]);
+ }, [props.controller, props.initialFocusSessionId, refresh, refreshGate]);
const route = useCallback(async (
input: WorkHubSubmitInput,
@@ -217,14 +229,14 @@ export function WorkHubSurface(props: {
const send = useCallback(async (value: string) => {
const text = value.trim();
- if (!text || routeGate.pending) return false;
+ if (!text || !initialLoadSettled || routeGate.pending) return false;
const requestId = crypto.randomUUID();
setTurns((current) => [...current, { requestId, text, state: 'routing' }]);
const result = await route({ requestId, text });
// Composer clears only accepted drafts. Waiting, delivery failures, and a
// ref-blocked duplicate keep the exact text available for retry.
return workHubSubmissionClearsDraft(result);
- }, [route, routeGate]);
+ }, [initialLoadSettled, route, routeGate]);
const projectedTurns = visibleWorkHubProjectedTurns(projection.turns, turns);
const conversationEmpty = projectedTurns.length === 0 && turns.length === 0;
@@ -237,7 +249,7 @@ export function WorkHubSurface(props: {
draftKey="workhub"
onSend={send}
onStop={() => {}}
- sendBlocked={pending}
+ sendBlocked={pending || !initialLoadSettled}
modelLabel="WorkHub"
/>
)}
@@ -248,7 +260,9 @@ export function WorkHubSurface(props: {
<h1>WorkHub</h1>
<p>{copy.subtitle}</p>
</div>
- <span>{copy.workCount(projection.sessions.length)}</span>
+ <span>{initialLoadSettled
+ ? copy.workCount(projection.sessions.length)
+ : copy.loading}</span>
</header>
<div className="maka-chat-shell">
@@ -258,7 +272,9 @@ export function WorkHubSurface(props: {
gap={4}
isStreaming={pending}
>
- {loadError ? (
+ {!initialLoadSettled ? (
+ <WorkHubLoadingState label={copy.loading} />
+ ) : loadError ? (
<div className="workhub-empty" role="alert">{copy.loadFailed}</div>
) : conversationEmpty ? (
<div className="workhub-empty">
@@ -287,6 +303,9 @@ export function WorkHubSurface(props: {
requestId: turn.requestId,
text: turn.text,
explicitTarget: target,
+ ...(turn.outcome?.kind === 'clarification' && turn.outcome.correction
+ ? { correction: turn.outcome.correction }
+ : {}),
})}
onCorrect={(from, target) => void route({
requestId: turn.requestId,
@@ -310,6 +329,27 @@ export function WorkHubSurface(props: {
);
}
+function WorkHubLoadingState(props: { label: string }) {
+ return (
+ <div
+ className="workhub-turns workhub-loading"
+ role="status"
+ aria-busy="true"
+ aria-label={props.label}
+ >
+ {[0, 1].map((index) => (
+ <div key={index} className="workhub-turn workhub-loading-turn" aria-hidden="true">
+ <div className="workhub-loading-user">
+ <Skeleton width="38%" height={44} radius="rounded" index={index * 3} />
+ </div>
+ <Skeleton width="28%" height={12} radius="rounded" index={index * 3 + 1} />
+ <Skeleton width="100%" height={72} radius={3} index={index * 3 + 2} />
+ </div>
+ ))}
+ </div>
+ );
+}
+
function ProjectedWorkHubTurnView(props: {
turn: WorkHubProjectedTurn;
projection: WorkHubProjection;
@@ -533,6 +573,7 @@ function workHubCopy(locale: UiLocale) {
waitingForDecision: '这项工作正在等待你的决定。',
requestNotSent: '新请求尚未发送;处理原 Session 中的交互后可以再次发送。',
routing: '正在判断应该交给哪个 Session…', loadFailed: '无法读取已有工作。',
+ loading: '正在读取已有工作…',
submitFailed: '输入未能送达,请重试。', scrollToBottom: '滚动到底部', archived: '已归档',
states: { active: '活跃', running: '进行中', waiting_for_user: '等待你', blocked: '受阻', aborted: '已中止' },
turnStates: { running: '进行中', completed: '已完成', aborted: '已中止', failed: '失败' },
@@ -557,6 +598,7 @@ function workHubCopy(locale: UiLocale) {
waitingForDecision: 'This work is waiting for your decision.',
requestNotSent: 'The new request was not sent. Resolve the interaction in its Session, then send again.',
routing: 'Choosing the right Session…', loadFailed: 'Could not read existing work.',
+ loading: 'Loading existing work…',
submitFailed: 'The input could not be delivered. Try again.', scrollToBottom: 'Scroll to bottom', archived: 'Archived',
states: { active: 'Active', running: 'Running', waiting_for_user: 'Waiting for you', blocked: 'Blocked', aborted: 'Aborted' },
turnStates: { running: 'Running', completed: 'Completed', aborted: 'Aborted', failed: 'Failed' },
diff --git a/docs/workhub-domain-language.md b/docs/workhub-domain-language.md
index 3d0231fd8..ef1467b47 100644
--- a/docs/workhub-domain-language.md
+++ b/docs/workhub-domain-language.md
@@ -19,18 +19,57 @@
# WorkHub domain language
-WorkHub gives users one conversational place to continue, create, and inspect work while ordinary Sessions remain the product's canonical work records.
+WorkHub gives users one persistent conversational place to ask, clarify, continue,
+create, and inspect work. It is backed by one stable Coordination Session per
+Runtime Host while concrete execution remains authoritative in ordinary Sessions.
+
+This document names the approved target architecture. The current R2.4
+implementation is a transitional deterministic router and does not yet create the
+Coordination Session described below.
## Terms
-**Session**: The authoritative record for identity, transcript, execution state, permissions, interactions, and recovery. A Session ID is the stable identity of the work.
+**Session**: The existing transcript, execution-boundary, permission, interaction,
+and recovery substrate. A Session owns only the conversation or execution admitted
+to that Session.
+
+**Coordination Session**: A special Session role used by WorkHub. Each Runtime Host
+has at most one stable Coordination Session. It owns WorkHub user messages, ordinary
+Q&A, clarification, coordination decisions, delegation references, and coordination
+summaries. It is hidden from the ordinary Session list and never routes to itself.
-**Work**: The user-facing continuity of exactly one ordinary Session. “Work” is a product-language view of a Session, not a second stored record.
+**Ordinary Session**: A Session that owns concrete work execution, including its
+project/filesystem scope, model and permissions, root-Turn admission, tools,
+artifacts, recovery, lifecycle, and authoritative execution transcript.
-**WorkHub**: A projection and routing surface over ordinary Sessions. It may keep transient inference context while mounted, but it does not own a transcript or execution state.
+**Work**: User-facing continuity around a goal. Whether Work is 1:1 with Session,
+1:N over Sessions, or an independent durable entity is deliberately unresolved.
+
+**WorkHub**: The unified conversational entry and coordination surface backed by
+the active Runtime Host's Coordination Session. It may answer locally, clarify,
+delegate to an existing ordinary Session, or create a new ordinary Session.
**Session projection**: A rebuildable view derived from Session facts for display and routing. It can be discarded and recreated without losing work.
-**Route correction**: A user's decision that an input belongs to a different existing Session. It may influence later transient routing, but it does not become an authority for Session content or state.
+**Disposition**: The coordination outcome for one WorkHub input:
+`answer_here`, `delegate_existing`, `create_new`, or `clarify`.
+
+**Delegation**: A reference from a Coordination Turn to a target ordinary Session
+and Turn. Delegation links the two authoritative transcripts; it does not copy the
+target execution transcript into WorkHub.
+
+**Action Gate**: The deterministic Runtime boundary that validates a proposed
+disposition, target, creation, Stop, confirmation, tools, and permissions. A model
+or routing policy may propose an action but cannot authorize it.
+
+**Route correction**: A user's decision that an input belongs to a different
+existing Session. R2.4 retains only bounded inference memory for later target
+resolution. Correction precedence follows user submission order, not asynchronous
+completion order, and it never replaces either Session's transcript authority.
+
+**R2.4**: The deterministic context-continuity routing baseline. It remains useful
+as an experiment baseline or target resolver behind WorkHub's coordination layer;
+it is not the final architecture or authority boundary of WorkHub.
-_Avoid_: independent Work records, copied transcripts, or a second writable WorkHub state store.
+_Avoid_: copied execution transcripts, self-routing, a second Session/WorkHub
+storage substrate, or treating model/routing output as execution authority.
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@maka.apache.org
For additional commands, e-mail: commits-help@maka.apache.org