termdock 1.4.321 → 1.4.322

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -40,6 +40,7 @@ export function writeCollaborationTmuxPane(run, pane, prompt, stdin, assertCurre
     progress?.('queue_wait');
     return serializeTerminalInput(paneInputKey(pane), () => {
         progress?.('queue_acquired');
+        assertCurrent?.('queue_acquired');
         return writeTmuxPrompt(run, pane, prompt, stdin, assertCurrent, progress);
     });
 }
@@ -47,7 +48,7 @@ async function writeTmuxPrompt(run, pane, prompt,
 /** Body travels on stdin so tmux cannot parse its semicolons/backslashes. */
 stdin, assertCurrent, progress) {
     await assertSamePane(run, pane);
-    assertCurrent?.();
+    assertCurrent?.('before_paste');
     // A fixed pane target is independent of the current window, keyboard focus
     // and browser presence. Delivery goes through a named tmux buffer rather
     // than `send-keys -l`: while a pane is in copy-mode, literal bytes are
@@ -81,7 +82,7 @@ stdin, assertCurrent, progress) {
         progress?.('paste_written');
         await waitForPromptSubmit();
         await assertSamePane(run, pane);
-        assertCurrent?.();
+        assertCurrent?.('before_submit');
         progress?.('submit_attempted');
         await run([
             // The submit key rides outside the paste block: inside it, an editor

package/dist/server/agent/integrationCli.js

@@ -61,6 +61,12 @@ export const INTEGRATION_HELP = `td integration — local scoped integration adm
   diagnostics <TD-session-id> (read stored launch/restore diagnostics; administrator only)
     1.4.314 adds phase/timestamps, paste/submit write facts and target-change
     evidence; no argv/environment/credentials or application readiness claim.
+    1.4.322 adds guard_captured/runtime_resolving/runtime_resolved stages and
+    target_change.check_phase/guard_captured_at/checked_at, launch IDs and route revisions.
+    Check actual server agent_launch_generation_consistency=true (minimum 1.4.322),
+    terminal_input_check_diagnostics=true; upgrading only the CLI does not fix a running service.
+    TERMINAL_INPUT_TARGET_CHANGED still rejects an actually replaced target.
+    create never auto-retries; retry-cold remains a separate, explicitly authorized operation.
     Prior versions cannot reconstruct missing launch evidence retroactively.
   create --file <policy.json> --credential-file <private-output.json>
   update --file <policy.json> (same identity/group; preserves the credential)

package/dist/server/agent/integrationServer.js

@@ -246,6 +246,8 @@ export class IntegrationRuntime {
             session_startup_input_clear: true, session_startup_input_clear_min_version: '1.4.310',
             agent_launch_process_check: true, agent_launch_process_check_min_version: '1.4.312',
             terminal_input_runtime_fence: true, terminal_input_runtime_fence_min_version: '1.4.313',
+            agent_launch_generation_consistency: true, agent_launch_generation_consistency_min_version: '1.4.322',
+            terminal_input_check_diagnostics: true,
             session_launch_diagnostics: true, session_launch_diagnostics_min_version: '1.4.314',
             session_cold_retry: true, session_cold_retry_min_version: '1.4.314',
             session_rename: true, session_rename_min_version: '1.4.315',

package/dist/server/agent/promptDelivery.js

@@ -22,12 +22,12 @@ export function writeBracketedPrompt(target, prompt, assertCurrent, progress) {
     progress?.('queue_wait');
     return serializeTerminalInput(target, async () => {
         progress?.('queue_acquired');
-        assertCurrent?.();
+        assertCurrent?.('queue_acquired');
         progress?.('paste_attempted');
         target.write(buildBracketedPasteBytes(prompt));
         progress?.('paste_written');
         await waitForPromptSubmit();
-        assertCurrent?.();
+        assertCurrent?.('before_submit');
         progress?.('submit_attempted');
         target.write('\r');
         progress?.('submit_written');

package/dist/server/agent/sessionLaunchState.js

@@ -0,0 +1,20 @@
+import { TerminalInputTargetChangedError } from './terminalInput.js';
+/** Display/identity metadata may have crossed an await with an old snapshot.
+ * Only the launch lifecycle can change these server-owned control fields. */
+export function mergeSessionLaunchState(candidate, current, change) {
+    if (!change)
+        return current ? { ...candidate,
+            agentLaunchGeneration: current.agentLaunchGeneration ?? null,
+            agentLaunchCheck: current.agentLaunchCheck ?? null,
+        } : candidate;
+    if (!current || (current.agentLaunchGeneration ?? null) !== change.expectedGeneration
+        || (current.agentLaunchCheck?.id ?? null) !== change.expectedCheckId) {
+        throw new TerminalInputTargetChangedError({
+            expected_backend_session_id: candidate.backendSessionId, current_backend_session_id: current?.backendSessionId ?? null,
+            expected_launch_id: change.expectedGeneration, current_launch_id: current?.agentLaunchGeneration ?? null,
+            backend_instance_matches: !!current && candidate.backendSessionId === current.backendSessionId,
+            check_phase: 'launch_state_commit', checked_at: Date.now(),
+        });
+    }
+    return { ...candidate, agentLaunchGeneration: change.generation, agentLaunchCheck: change.check };
+}

package/dist/server/agent/terminalInput.js

@@ -22,6 +22,23 @@ export class TerminalInputTargetChangedError extends Error {
         this.evidence = evidence;
     }
 }
+/** Capture once, including for a launch's own command. Never adopt a newer
+ * generation simply because the physical backend has stayed the same. */
+export function captureRuntimeInputGuard(current, expected = current()) {
+    const capturedAt = Date.now();
+    return (phase = 'guard_capture') => {
+        const actual = current();
+        const matches = actual.backendInstance === expected.backendInstance;
+        if (actual.backendSessionId !== expected.backendSessionId || !matches
+            || actual.launchId !== expected.launchId || actual.routeRevision !== expected.routeRevision) {
+            throw new TerminalInputTargetChangedError({ expected_backend_session_id: expected.backendSessionId,
+                current_backend_session_id: actual.backendSessionId, expected_launch_id: expected.launchId,
+                current_launch_id: actual.launchId, backend_instance_matches: matches, check_phase: phase,
+                guard_captured_at: capturedAt, checked_at: Date.now(), expected_route_revision: expected.routeRevision,
+                current_route_revision: actual.routeRevision });
+        }
+    };
+}
 /** Clearing a one-time launch check does not change the runtime generation. */
 export function captureTerminalInputGuard(current, expected = current()) {
     return () => {

package/dist/server/routes/terminal.js

@@ -51,7 +51,8 @@ import { archiveTaskWorkspace, restoreTaskWorkspace, snapshotTaskWorkspace } fro
 import { isTmuxRecoveryCandidate } from '../utils/tmuxRecoveryCandidate.js';
 import { AutomationStore, normalizeAutomationSchedule } from '../agent/automationStore.js';
 import { writeBracketedPrompt, canDeliverPromptToAgent } from '../agent/promptDelivery.js';
-import { captureTerminalInputGuard, waitAndWriteTerminalInput, TerminalInputTargetChangedError } from '../agent/terminalInput.js';
+import { captureTerminalInputGuard, captureRuntimeInputGuard, waitAndWriteTerminalInput } from '../agent/terminalInput.js';
+import { mergeSessionLaunchState } from '../agent/sessionLaunchState.js';
 import { agentLaunchBlockReason, normalizeAgentLaunchCheck } from '../agent/agentLaunchCheck.js';
 import { prepareSupervisionEnable } from '../utils/enableSupervision.js';
 import { buildServerHealthState, dismissServerHealth } from '../utils/serverHealth.js';
@@ -1082,8 +1083,9 @@ async function withInventoryOpenLock(key, task) {
     inventoryOpenLocks.set(key, pending);
     return pending;
 }
-function upsertGlobalSessionRecord(record) {
-    const normalized = normalizePersistedClientSession(record);
+function upsertGlobalSessionRecord(record, launchChange) {
+    const current = globalSessionState.sessions.find(candidate => candidate.sessionId === record.sessionId);
+    const normalized = normalizePersistedClientSession(mergeSessionLaunchState(record, current, launchChange));
     if (!normalized) {
         throw new Error('invalid session record');
     }
@@ -1462,8 +1464,16 @@ async function beginAgentLaunchCheck(frontendSessionId, agentSlug, nativeSession
     if (!record)
         throw new Error('SESSION_REMOVED');
     const id = randomUUID();
-    upsertGlobalSessionRecord({ ...record, agentLaunchGeneration: id, agentLaunchCheck: { id, agentSlug, nativeSessionId, deadline: Date.now() + 120_000 } });
-    await persistGlobalStateNow();
+    const updated = upsertGlobalSessionRecord(record, { expectedGeneration: record.agentLaunchGeneration ?? null,
+        expectedCheckId: record.agentLaunchCheck?.id ?? null, generation: id,
+        check: { id, agentSlug, nativeSessionId, deadline: Date.now() + 120_000 } });
+    // Capture the guard before persistence yields. The launch command must use
+    // this exact generation, even if another launch occurs during an await.
+    const assertCurrent = terminalInputGuard(updated);
+    assertCurrent('guard_capture');
+    await persistGlobalStateNow(true);
+    assertCurrent('launch_persisted');
+    return assertCurrent;
 }
 async function observeAgentLaunchCheck(record, observed) {
     const check = record.agentLaunchCheck;
@@ -1477,53 +1487,56 @@ async function observeAgentLaunchCheck(record, observed) {
         return { state: 'offline', reason: 'SESSION_REMOVED' };
     if (latest.agentLaunchCheck?.id !== check.id)
         return { state: 'recovering', reason: 'AGENT_LAUNCH_CHANGED' };
-    upsertGlobalSessionRecord({ ...latest, agentLaunchCheck: null });
+    upsertGlobalSessionRecord(latest, { expectedGeneration: latest.agentLaunchGeneration ?? null,
+        expectedCheckId: check.id, generation: latest.agentLaunchGeneration ?? null, check: null });
     await persistGlobalStateNow();
     return null;
 }
 function terminalInputGuard(record) {
     const frontendSessionId = record.sessionId;
     const backendSessionId = record.backendSessionId;
-    const launchId = record.agentLaunchGeneration ?? null;
-    const routeRevision = collaborationRouting.get(frontendSessionId)?.routeRevision ?? null;
-    const backend = backendSessionId ? terminalSessions.get(backendSessionId) : undefined;
-    return () => {
+    const expected = { backendSessionId, launchId: record.agentLaunchGeneration ?? null,
+        routeRevision: collaborationRouting.get(frontendSessionId)?.routeRevision ?? null,
+        backendInstance: backendSessionId ? terminalSessions.get(backendSessionId) : undefined };
+    return captureRuntimeInputGuard(() => {
         const latest = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
         if (!latest)
             throw new Error('SESSION_REMOVED');
-        const instanceMatches = !backendSessionId || terminalSessions.get(backendSessionId) === backend;
-        if ((collaborationRouting.get(frontendSessionId)?.routeRevision ?? null) !== routeRevision
-            || (latest.agentLaunchGeneration ?? null) !== launchId || latest.backendSessionId !== backendSessionId || !instanceMatches) {
-            throw new TerminalInputTargetChangedError({ expected_backend_session_id: backendSessionId, current_backend_session_id: latest.backendSessionId,
-                expected_launch_id: launchId, current_launch_id: latest.agentLaunchGeneration ?? null, backend_instance_matches: instanceMatches });
-        }
-    };
+        return { backendSessionId: latest.backendSessionId, launchId: latest.agentLaunchGeneration ?? null,
+            routeRevision: collaborationRouting.get(frontendSessionId)?.routeRevision ?? null,
+            backendInstance: latest.backendSessionId ? terminalSessions.get(latest.backendSessionId) : undefined };
+    }, expected);
 }
 /** tmux input always uses the pane queue, including automation and launch commands. */
 async function automaticTerminalInput(record, assertCurrent = terminalInputGuard(record), progress) {
-    assertCurrent();
+    progress?.('guard_captured');
+    assertCurrent('runtime_resolve');
+    progress?.('runtime_resolving');
     if (record.mode === 'tmux') {
         const binding = collaborationRouting.get(record.sessionId) ?? {
             sessionId: record.sessionId, backendSessionId: record.backendSessionId, mode: record.mode,
             tmuxSessionName: record.tmuxSessionName, agentSlug: null, nativeSessionId: null, pane: null,
         };
         const inspected = await inspectCollaborationTmux(binding, null, true);
-        assertCurrent();
+        assertCurrent('runtime_resolved');
         if (inspected.state !== 'ready' || !inspected.pane)
             throw new Error(inspected.reason ?? 'TMUX_PANE_UNAVAILABLE');
         const pane = inspected.pane;
+        progress?.('runtime_resolved');
         return (prompt) => writeCollaborationTmuxPane(runTmux, pane, prompt, runTmuxStdin, assertCurrent, progress);
     }
     const backend = record.backendSessionId ? terminalSessions.get(record.backendSessionId) : null;
     if (!backend)
         throw new Error('SHELL_BACKEND_NOT_RUNNING');
+    assertCurrent('runtime_resolved');
+    progress?.('runtime_resolved');
     return (prompt) => writeBracketedPrompt(backend.ptyProcess, prompt, assertCurrent, progress);
 }
-async function writeAutomaticTerminalPrompt(frontendSessionId, prompt, progress) {
+async function writeAutomaticTerminalPrompt(frontendSessionId, prompt, progress, launchGuard) {
     const record = globalSessionState.sessions.find(candidate => candidate.sessionId === frontendSessionId);
     if (!record)
         throw new Error('SESSION_REMOVED');
-    const write = await automaticTerminalInput(record, terminalInputGuard(record), progress);
+    const write = await automaticTerminalInput(record, launchGuard ?? terminalInputGuard(record), progress);
     await write(prompt);
 }
 async function deliverAutomationPromptWhenReady(backendSessionId, prompt) {
@@ -1580,9 +1593,8 @@ async function runAgentAutomation(automation, req) {
                 throw new Error('自动任务会话创建失败');
             if (automation.command) {
                 const agent = detectAgentFromCommand(automation.command, agentCustomCommands());
-                if (agent)
-                    await beginAgentLaunchCheck(frontendSessionId, agent.slug);
-                await writeAutomaticTerminalPrompt(frontendSessionId, automation.command);
+                const launchGuard = agent ? await beginAgentLaunchCheck(frontendSessionId, agent.slug) : undefined;
+                await writeAutomaticTerminalPrompt(frontendSessionId, automation.command, undefined, launchGuard);
             }
             if (automation.prompt) {
                 if (automation.command)
@@ -1970,7 +1982,7 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
     const backend = terminalSessions.get(opened.terminalSession.sessionId);
     if (!backend)
         throw new HttpStatusError(500, 'Agent Session 创建失败', 'COLLAB_AGENT_SESSION_FAILED');
-    await beginAgentLaunchCheck(frontendSessionId, launcher.slug);
+    const launchGuard = await beginAgentLaunchCheck(frontendSessionId, launcher.slug);
     const latestGroup = collaborationStore.getGroup(group.id);
     if (!latestGroup || latestGroup.deleted) {
         const created = globalSessionState.sessions.find(record => record.sessionId === frontendSessionId);
@@ -1993,7 +2005,7 @@ async function spawnCollaborationAgentSession(req, group, sourceSessionId, input
         collaborationStore.setRole({ groupId: group.id, sessionId: frontendSessionId, role: bootstrapRole, creationKey });
     if (profile)
         collaborationStore.setMemberLaunchProfile(group.id, frontendSessionId, profile);
-    await writeAutomaticTerminalPrompt(frontendSessionId, buildCollaborationSpawnCommand({ slug: launcher.slug, command: profile?.command ?? launcher.command }));
+    await writeAutomaticTerminalPrompt(frontendSessionId, buildCollaborationSpawnCommand({ slug: launcher.slug, command: profile?.command ?? launcher.command }), undefined, launchGuard);
     const requestedTask = typeof input.task === 'string' ? input.task.trim().slice(0, 20_000) : '';
     collaborationStore.send({
         groupId: updatedGroup.id,
@@ -2423,8 +2435,8 @@ async function launchIntegrationTerminal(record, restoring, prepared, progress,
         backend.agent = null;
         backend.agentResumeRecovered = false;
         progress?.('launch_intent');
-        await beginAgentLaunchCheck(record.session_id, record.agent_slug, restoring ? record.agent_native_session_id : null);
-        await writeAutomaticTerminalPrompt(record.session_id, integrationLaunchCommand(record, restoring), progress);
+        const launchGuard = await beginAgentLaunchCheck(record.session_id, record.agent_slug, restoring ? record.agent_native_session_id : null);
+        await writeAutomaticTerminalPrompt(record.session_id, integrationLaunchCommand(record, restoring), progress, launchGuard);
         broadcastClientState();
     });
 }
@@ -2471,12 +2483,12 @@ export function prepareCollaborationTaskWorker(task, template, dependencies, ser
                 throw error;
         }
         if (!currentAgent && (!launch || launch.backendId !== opened.terminalSession.sessionId)) {
-            await beginAgentLaunchCheck(record.sessionId, launcher.slug);
+            const launchGuard = await beginAgentLaunchCheck(record.sessionId, launcher.slug);
             // Persist before typing: a retry must never type the launcher into a newly booted Agent's prompt.
             const temporary = `${launchFile}.${process.pid}.tmp`;
             await fs.promises.writeFile(temporary, JSON.stringify({ sessionId: record.sessionId, backendId: opened.terminalSession.sessionId }), { mode: 0o600 });
             await fs.promises.rename(temporary, launchFile);
-            await writeAutomaticTerminalPrompt(opened.session.sessionId, buildCollaborationSpawnCommand({ slug: launcher.slug, command: inheritedProfile?.command ?? launcher.command }));
+            await writeAutomaticTerminalPrompt(opened.session.sessionId, buildCollaborationSpawnCommand({ slug: launcher.slug, command: inheritedProfile?.command ?? launcher.command }), undefined, launchGuard);
         }
         const group = collaborationStore.getGroup(task.groupId);
         if (!group || group.deleted)
@@ -6144,8 +6156,8 @@ router.post('/tmux/recovery/restore-all', async (_req, res) => {
                 const previous = collaborationRouting.get(frontendSessionId);
                 if (previous)
                     collaborationRouting.bind({ ...previous, pane: null });
-                await beginAgentLaunchCheck(frontendSessionId, agent.slug, target.nativeSessionId);
-                await writeAutomaticTerminalPrompt(frontendSessionId, command);
+                const launchGuard = await beginAgentLaunchCheck(frontendSessionId, agent.slug, target.nativeSessionId);
+                await writeAutomaticTerminalPrompt(frontendSessionId, command, undefined, launchGuard);
             }));
             outcomes.push({ sessionId: frontendSessionId, restored: true });
         }
@@ -7098,8 +7110,8 @@ router.post('/operations/execution-archives/:sessionId/restore', executionArchiv
         broadcastClientState();
         throw error;
     }
-    await beginAgentLaunchCheck(record.sessionId, target.slug, target.nativeSessionId);
-    await writeAutomaticTerminalPrompt(opened.session.sessionId, command);
+    const launchGuard = await beginAgentLaunchCheck(record.sessionId, target.slug, target.nativeSessionId);
+    await writeAutomaticTerminalPrompt(opened.session.sessionId, command, undefined, launchGuard);
     restoreArchivedMembership(entry, record.sessionId);
     await persistGlobalStateNow();
     broadcastClientState();
@@ -8343,10 +8355,9 @@ router.post('/:sessionId/agent-resume', async (req, res) => {
     try {
         const frontend = globalSessionState.sessions.find(candidate => candidate.backendSessionId === sessionId);
         const launch = async () => {
+            const launchGuard = frontend ? await beginAgentLaunchCheck(frontend.sessionId, target.slug, target.nativeSessionId) : undefined;
             if (frontend)
-                await beginAgentLaunchCheck(frontend.sessionId, target.slug, target.nativeSessionId);
-            if (frontend)
-                await writeAutomaticTerminalPrompt(frontend.sessionId, target.command);
+                await writeAutomaticTerminalPrompt(frontend.sessionId, target.command, undefined, launchGuard);
             else
                 await writeBracketedPrompt(session.ptyProcess, target.command, captureTerminalInputGuard(() => terminalSessions.get(sessionId), session));
         };

package/docs/integrations.md

@@ -1242,3 +1242,52 @@ message/thread/幂等键或历史，不自动补 Enter、不用屏幕文字识
 投递、不同/缺失/弱原生证据、多匹配/归属/未知旧写入拒绝、绑定持久化和失败、
 只读路由权限/CLI、网页暂停提示及加密传输边界。Mac 实际现场的当前原生身份尚未独立确认，原消息尚待拥有者确认及接入方实际服务
 升级/回读后继续投递；不以维护机回归冒充该现场已恢复。
+
+
+## 1.4.322：启动代次一致性与输入检查诊断
+
+最低实际服务 **1.4.322**，配套 CLI 也升级至 1.4.322。`capabilities` 回读：
+`agent_launch_generation_consistency=true`、
+`agent_launch_generation_consistency_min_version=1.4.322`、
+`terminal_input_check_diagnostics=true`。普通协作协议仍为 2，integration protocol 仍为 1；
+不新增权限。只更新 CLI 不会改变正在运行的旧服务。
+
+启动代次是 TD 服务生成的 `agentLaunchGeneration`，与原生 Agent UUID、
+IntegrationSession 的数值 `generation` 分别记录。同一 backend 在启动准备时从 null
+变为新的启动 UUID 是正常动作。名称、cwd、原生身份元数据等整记录更新过去可能
+携带 await 之前的旧启动字段写回；本版将启动字段交由专门的比较后更新路径管理，
+普通元数据更新继承当前启动代次与一次性检查，不能覆盖或复活旧值。
+
+启动操作在写入本次代次后、持久化之前捕获自己的输入检查令牌，并在持久化返回、
+承载解析、获取输入队列及粘贴/提交前持续使用它。冷启动、精确恢复、显式 cold retry
+和普通启动共用这条保护；不会为了继续输入而采纳后来出现的启动代次。启动状态
+落盘失败时不输入。真实 backend 对象/ID、绑定版本、tmux pane 或启动代次变化仍拒绝，
+保留 `TERMINAL_INPUT_TARGET_CHANGED` / `TMUX_PANE_CHANGED` 等错误。
+
+管理员沿现有入口读取已保存的诊断：
+
+```sh
+td integration diagnostics <TD-session-id>
+```
+
+`launch_diagnostics.steps` 追加可选阶段 `guard_captured / runtime_resolving / runtime_resolved`；
+既有 `queue_wait / queue_acquired / paste_* / submit_*` 保留。拒绝时
+`target_change` 可含 `check_phase / guard_captured_at / checked_at`，以及
+`expected_launch_id / current_launch_id`、backend ID/实例比较、绑定版本比较。
+`check_phase` 包含 `launch_state_commit / guard_capture / launch_persisted / runtime_resolve /
+runtime_resolved / queue_acquired / before_paste / before_submit`。时间是 TD 检查时间，
+不是内核首字节写入时间；不包含正文、argv、环境或凭据。旧记录不补造缺失的证据。
+
+这次修复不增加自动重试：原 create 同键只回读原操作。失败现场保留，先用
+`session get` 核对当前事实；明确授权后才按现有 `session retry-cold` 契约显式操作，
+必须满足无原生 UUID、无 TD 消息历史或待投递、精确原 shell、配置指纹与代次等条件。
+已有原生 UUID 的会话继续精确 restore，不能以 cold retry 替代。消息正文不因升级重发。
+
+升级由现场唯一维护者协调：保留现有 HTTPS/鉴权参数，仅替换并重启 TD 服务；
+核对在跑 tmux/Agent 完整身份没有变化，再回读实际服务版本和以上能力。
+本版不要求重启、重建或重试业务 Agent，不更改 launch profile、sandbox 或业务调度。
+终端动作仍是粘贴一次、50ms 后发送一次回车；TD 仍不保证应用提交、消费或执行完成。
+
+确定性交错回归覆盖延迟改名/元数据回写、清除检查、持久化等待、输入队列等待、
+真实第二次启动、backend 替换及重新绑定；发生真实换代时，旧输入及旧的延迟回车
+仍被拒绝。测试证明 TD 一致性与终端写入边界，不代替私有 Agent 的实机消费验收。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.321",
+  "version": "1.4.322",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.321",
+  "version": "1.4.322",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-oaGYi/P5ob8sd6VnNBOwshKozjhdV+hYiCmLAsn5x00=",
-  "serverBundleHash": "sha256-o36V1OU5HWHaYRXX3y2vcIKrppx0O4wtdbCRN90DifI=",
-  "clientBundleHash": "sha256-rMB/XxqqSbnbT1KeX2KqTnR82mLyuW/NFSb1X7Y6BRE=",
+  "serverBundleHash": "sha256-T9JZp3X9tfMUYciSrnZbiUIXuc+IHqHJuGp6Wf5bHs8=",
+  "clientBundleHash": "sha256-4wVT4/UzD+TMRQjVw307g0c0x0cJm6NknoDeybiIQfA=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

package/dist/client/assets/CollaborationTaskContent-C2sQQp6K.js

@@ -1,2 +0,0 @@
-import{by as r}from"./app-Bj0N393t.js";import{b as m}from"./dnd-BCFAPC0L.js";import{b as n}from"./RightSidebar-BeegDfBO.js";import"./react-XDCjal2T.js";import"./terminal-C7X98Amf.js";import"./App-VAvoVlm2.js";import"./gestureArbiter-nU4jhK3S.js";import"./triangle-alert-CVm2qdGE.js";import"./referenceLongPress-CR3uo3V0.js";import"./DiffReview-DQFgOJPF.js";import"./sparkles-Dx518Xui.js";import"./DiffViewer-DOvGC9bh.js";import"./ChangeWalkthroughPanel-BtXqyUzD.js";function g({content:o}){const e=m.useMemo(()=>n(o.split(`
-`),null,null),[o]);return r.jsx("div",{className:"min-w-0 space-y-3 break-words text-sm leading-6 text-foreground [&_h1]:text-lg [&_h2]:text-base [&_h3]:text-sm [&_pre]:max-w-full [&_table]:text-xs",children:e.map((t,i)=>r.jsx("div",{className:"min-w-0",children:typeof t.content=="function"?t.content(null):t.content},i))})}export{g as default};

package/dist/client/assets/channel-OHMJip5O.js

@@ -1 +0,0 @@
-import{c as a,C as n}from"./mermaid.core-DndzUmju.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/client/assets/classDiagram-ZZMXUADV-DwA5mGyC.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-TICWLB2K-CPpFFmO9.js";import{d as i}from"./mermaid.core-DndzUmju.js";import"./chunk-5VM5RSS4-Cc3Czx6A.js";import"./chunk-XXDRQBXY-Zp_XOFU2.js";import"./chunk-POPQ4Y6H-C4MN3QRd.js";import"./chunk-F27PBJKO-3scxqZTK.js";import"./purify.es-4eNOHKSq.js";import"./app-Bj0N393t.js";import"./react-XDCjal2T.js";import"./dnd-BCFAPC0L.js";import"./terminal-C7X98Amf.js";var g={parser:t,get db(){return new e},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{g as diagram};

package/dist/client/assets/classDiagram-v2-VYDZK3BY-DwA5mGyC.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-TICWLB2K-CPpFFmO9.js";import{d as i}from"./mermaid.core-DndzUmju.js";import"./chunk-5VM5RSS4-Cc3Czx6A.js";import"./chunk-XXDRQBXY-Zp_XOFU2.js";import"./chunk-POPQ4Y6H-C4MN3QRd.js";import"./chunk-F27PBJKO-3scxqZTK.js";import"./purify.es-4eNOHKSq.js";import"./app-Bj0N393t.js";import"./react-XDCjal2T.js";import"./dnd-BCFAPC0L.js";import"./terminal-C7X98Amf.js";var g={parser:t,get db(){return new e},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{g as diagram};