termdock 1.4.195 → 1.4.197

package/dist/server/agent/collaborationPrompt.js

@@ -1,3 +1,4 @@
+import { canonicalShortId } from './collaborationProtocol.js';
 import { sanitizeCollaborationRole } from './collaborationStore.js';
 const SHELL_RULE = '─'.repeat(30);
 /** Body larger than this (in UTF-8 bytes) is replaced by a retrieval pointer
@@ -25,51 +26,78 @@ export function sanitizeCollaborationName(name, max = 40) {
         .trim();
     return cleaned.length > max ? `${cleaned.slice(0, max - 1)}…` : cleaned;
 }
-/** The one line of a delivered block that carries `message.id`, chosen by what
- *  the recipient can actually do with it: an agent-sourced message gets the
+/** The id form a delivery shows and the confirm gate searches for, per message.
+ *  Canonical UUIDs shorten to their SHORT_ID_LENGTH prefix (a 36-character id
+ *  wraps in a narrow pane and has to be retyped by whoever answers it); ids
+ *  that are not canonical UUIDs pass through untouched. A prefix shared by two
+ *  messages in the same delivery would make a `includes` search match the wrong block —
+ *  including against the other one's line still sitting in terminal history —
+ *  so every colliding message falls back to its full id. The batch is the unit
+ *  because one delivery is what a confirm search scans against.
+ *
+ *  Delivered text and the confirm gate must both derive the token here: if the
+ *  text carried a short id while the gate searched the full one, the gate could
+ *  never match a delivery again and would re-write it until the attempt bound
+ *  (the "one message arrived three times" regression). */
+export function collaborationMessageAnchorTokens(messages) {
+    const counts = new Map();
+    for (const message of messages) {
+        const short = canonicalShortId(message.id);
+        counts.set(short, (counts.get(short) ?? 0) + 1);
+    }
+    return new Map(messages.map((message) => {
+        const short = canonicalShortId(message.id);
+        return [message.id, counts.get(short) === 1 ? short : message.id];
+    }));
+}
+/** The one line of a delivered block that carries the message's id, chosen by
+ *  what the recipient can actually do with it: an agent-sourced message gets the
  *  reply command, a user message gets the read-back command (`td collab reply`
  *  refuses user messages — NO_REPLY_TARGET — so naming it there would be a dead
- *  command). The delivery-confirm gate searches the recipient terminal for
- *  `message.id`, so every message must carry it regardless of source: this
- *  function is the single place that decides how, and the invariant is pinned
- *  by the "carries its id" test in collaborationPrompt.test.ts. */
-export function collaborationMessageAnchorLine(message) {
+ *  command). Both routes accept the short form (the CLI resolves id prefixes),
+ *  so whichever token collaborationMessageAnchorTokens picks for this delivery is what
+ *  the recipient can paste back. Every message must carry its token regardless
+ *  of source: the invariant is pinned by the "carries its id" test in
+ *  collaborationPrompt.test.ts. */
+export function collaborationMessageAnchorLine(message, token = canonicalShortId(message.id)) {
     return message.fromSessionId
-        ? `回复:td collab reply ${message.id} "回复内容" --text`
-        : `详情:td collab message get ${message.id} --json`;
+        ? `回复:td collab reply ${token} "回复内容" --text`
+        : `详情:td collab message get ${token} --json`;
 }
 /** A single delivered message: `来自:X · kind` over a fenced body, with the
  * anchor line (reply route / read-back route) kept outside the fence. A fan-out
  * dispatch (message.fanOutIds present) is flagged `· 群发` and names the
  * sibling recipients on their own line, so a broadcast is never mistaken for
  * a one-to-one assignment — raw ids fall back to the sanitized id itself. */
-function formatCollaborationMessage(message, source, fannedNames, fence) {
+function formatCollaborationMessage(message, source, fannedNames, fence, token) {
     const lines = [`来自:${source} · ${message.kind}${fannedNames.length ? ' · 群发' : ''}`];
     if (fannedNames.length)
         lines.push(`同时发给了:${fannedNames.join('、')}`);
     lines.push('', fence, message.content, fence);
     if (message.task)
         lines.push('', `任务上报:${JSON.stringify(message.task)}`);
-    lines.push('', collaborationMessageAnchorLine(message));
+    lines.push('', collaborationMessageAnchorLine(message, token));
     return lines.join('\n');
 }
 export function formatCollaborationDelivery(input) {
     const groupsById = new Map(input.groups.map((group) => [group.id, group]));
     const sessionsById = new Map(input.sessions.map((session) => [session.sessionId, session]));
+    const tokens = collaborationMessageAnchorTokens(input.messages);
     const blocks = [];
     for (const message of input.messages) {
         const sourceSession = message.fromSessionId ? sessionsById.get(message.fromSessionId) : null;
         const source = message.fromSessionId
             ? sanitizeCollaborationName(sourceSession?.name ?? message.fromSessionId)
             : '用户';
+        const token = tokens.get(message.id) ?? message.id;
         const bytes = Buffer.byteLength(message.content);
         const body = bytes > MAX_INLINE_BODY_BYTES
-            ? `大消息已完整保存（${bytes} 字节）。使用 td collab message get ${message.id} --json 获取正文；不要把这条提示当作消息正文。`
+            ? `大消息已完整保存（${bytes} 字节）。使用 td collab message get ${token} --json 获取正文；不要把这条提示当作消息正文。`
             : message.content;
         const fence = '`'.repeat(Math.max(3, ...Array.from(body.matchAll(/`+/g), (match) => match[0].length + 1)));
         const fannedNames = (message.fanOutIds ?? [])
             .map((sessionId) => sanitizeCollaborationName(sessionsById.get(sessionId)?.name ?? sessionId));
-        blocks.push(formatCollaborationMessage({ ...message, content: body }, source, fannedNames, fence));
+        blocks.push(formatCollaborationMessage({ ...message, content: body }, source, fannedNames, fence, token));
     }
     // The shell header names the group only when every block belongs to one;
     // a mixed batch drops the header entirely (no single-group claim to make).

package/dist/server/agent/collaborationProtocol.js

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 /** Transport facts and application reports deliberately remain separate. */
 export const COLLAB_LIMITS = {
     message_bytes: 1_048_576,
@@ -18,6 +19,96 @@ export class CollaborationError extends Error {
         this.httpStatus = httpStatus;
     }
 }
+/** A delivered terminal shows a short id, because a 36-character one wraps in
+ *  a narrow pane and has to be retyped by whoever answers it. New ids are
+ *  minted at that length already (newCollaborationId); ids stored before that
+ *  change are UUIDs, and read-only shortening renders those as their first
+ *  SHORT_ID_LENGTH characters. Both forms are the same width and both resolve,
+ *  so the display is uniform across the old and new records.
+ *
+ *  The length is 10 rather than 8 because a UUID's 9th character is always a
+ *  hyphen: at 10 characters a legacy UUID displays as `765c8819-a`, and since
+ *  base36 never draws a hyphen that exact id cannot be minted, so a new id
+ *  landing on an older UUID's displayed form is impossible by construction
+ *  instead of merely guarded against. The space is also 36^10 ≈ 3.7e15, 1296×
+ *  the 8-character one.
+ *
+ *  Anything that is neither a UUID nor an already-short id passes through
+ *  untouched — a hand-written session id (`40bc89py`), a
+ *  `remote:<origin>:<id>` address or a `cross-<uuid>` federated group are
+ *  either already short or decoded by their own structural rules
+ *  (`split(':')`), so truncating them would corrupt the parse. Storage, wire
+ *  format, receipts and federation always carry the id as stored; nothing is
+ *  rewritten on read. */
+export const SHORT_ID_LENGTH = 10;
+/** Shortest input accepted as a prefix; below this a lookup is exact-match
+ *  only, so a one-character typo never turns into an ambiguity error. With
+ *  10-character ids a 4-character prefix is routinely shared, so callers who
+ *  type a prefix rather than the whole id should expect to be told to add
+ *  characters. */
+export const MIN_ID_PREFIX_LENGTH = 4;
+const CANONICAL_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function canonicalShortId(id) {
+    return CANONICAL_ID.test(id) ? id.slice(0, SHORT_ID_LENGTH) : id;
+}
+/** Lowercase base36, matching the session ids this system already mints. The
+ *  10-character space is 36^10 ≈ 3.7e15 values. */
+const ID_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+/** Drawn from a CSPRNG: an id is the only thing standing between a caller and
+ *  a message they are not party to, and a predictable sequence would let a
+ *  member of one group walk into another's. */
+export function drawCollaborationId() {
+    let id = '';
+    for (let index = 0; index < SHORT_ID_LENGTH; index += 1)
+        id += ID_ALPHABET[crypto.randomInt(ID_ALPHABET.length)];
+    return id;
+}
+/** Mint a message, thread or group id, refusing anything already in `taken`.
+ *  `taken` must hold every id in use *and* the truncated form each one
+ *  displays as: resolveIdPrefix prefers an exact match, so a new id equal to a
+ *  stored UUID's display prefix would win that race and hide the older
+ *  message. At SHORT_ID_LENGTH = 10 a UUID's displayed form cannot be drawn
+ *  at all (position 9 is a hyphen, which base36 never produces), but the guard
+ *  stays because `taken` also holds ids that are short already. Locally this
+ *  makes collisions impossible.
+ *
+ *  Across machines that merge by id — federation carries ids as given, it
+ *  cannot rewrite them — two independent draws still collide with probability
+ *  ≈ n_A·n_B/36^10, about 1 in 900 million with both sides at the
+ *  2,000-message retention cap. A collision is not detected and does not
+ *  simply drop a message: the two records merge by id, and because a
+ *  higher-ranked status overwrites the receipt, a message that was never
+ *  delivered can be reported as read. That fake receipt is what this length
+ *  buys down (mergeFederatedMessages in collaborationStore.ts). */
+export function newCollaborationId(taken, draw = drawCollaborationId) {
+    for (;;) {
+        const id = draw();
+        if (!taken.has(id)) {
+            taken.add(id);
+            return id;
+        }
+    }
+}
+/** Resolve what a user typed against the ids that exist, git-style: an exact
+ *  match always wins, otherwise a prefix of at least MIN_ID_PREFIX_LENGTH
+ *  characters resolves when it is unique. Callers turn 'ambiguous' into an
+ *  error built by ambiguousIdMessage. */
+export function resolveIdPrefix(ids, input) {
+    if (ids.includes(input))
+        return { status: 'ok', id: input };
+    if (input.length < MIN_ID_PREFIX_LENGTH)
+        return { status: 'not-found' };
+    const matches = ids.filter((id) => id.startsWith(input));
+    if (matches.length === 1)
+        return { status: 'ok', id: matches[0] };
+    return matches.length ? { status: 'ambiguous', matches } : { status: 'not-found' };
+}
+/** Both message and group lookups answer an ambiguous prefix the same way: say
+ *  how many matched, never which ones (a prefix search can reach another
+ *  session's ids), and name the way out. */
+export function ambiguousIdMessage(kind, count) {
+    return `${kind} id 前缀匹配到 ${count} 个对象，请提供更长的前缀或完整 id`;
+}
 export function validateExtras(input) {
     if (input.idempotencyKey !== undefined && (typeof input.idempotencyKey !== 'string' || !input.idempotencyKey.trim() || input.idempotencyKey.length > 256)) {
         throw new CollaborationError('INVALID_IDEMPOTENCY_KEY', 'idempotency key must contain 1–256 characters');

package/dist/server/agent/collaborationRoutes.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { COLLAB_LIMITS, CollaborationError, extrasFromBody } from './collaborationProtocol.js';
+import { COLLAB_LIMITS, CollaborationError, MIN_ID_PREFIX_LENGTH, ambiguousIdMessage, extrasFromBody } from './collaborationProtocol.js';
 /** Member names arrive agent-authored over a CLI; control characters would
  * corrupt terminal shells, tmux options and persisted records. Fold them to
  * spaces, collapse runs, and cap the length (display sanitization for the
@@ -30,10 +30,32 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
         }
         res.json({ ok: true, route: await rebind(sessionId, pane ?? null) });
     }));
+    /** Accepts the short id a terminal shows as well as the full one; an
+     *  ambiguous prefix is refused rather than guessed, so a reply can never
+     *  land on the wrong thread. */
+    const resolveMessage = (id) => {
+        const resolved = store.resolveMessageId(id);
+        if (resolved.status === 'ambiguous')
+            throw new CollaborationError('MESSAGE_ID_AMBIGUOUS', ambiguousIdMessage('消息', resolved.matches.length));
+        return resolved.status === 'ok' ? store.getMessage(resolved.id) : null;
+    };
+    /** "Nothing matched" and "matched, but not yours" used to share both a code
+     *  and a sentence, and the code is what a caller reads first: MESSAGE_NOT_FOUND
+     *  next to "does not belong to this session" reads as a broken id lookup, not
+     *  as a refusal. A caller holding a real id has hit this. So the code names
+     *  the case and the sentence says which way it failed; the status stays 404
+     *  either way, and the body still carries no content the caller may not see. */
     const ownMessage = (id, sessionId, recipientOnly = false) => {
-        const message = store.getMessage(id);
-        if (!message || (message.toSessionId !== sessionId && (recipientOnly || message.fromSessionId !== sessionId)))
-            throw new CollaborationError('MESSAGE_NOT_FOUND', 'Message does not belong to this session', 404);
+        const message = resolveMessage(id);
+        if (!message)
+            throw new CollaborationError('MESSAGE_NOT_FOUND', id.length < MIN_ID_PREFIX_LENGTH
+                ? `No message has this exact id; prefixes are searched from ${MIN_ID_PREFIX_LENGTH} characters up`
+                : 'No message with this id or prefix; it may have expired or been pruned', 404);
+        if (message.toSessionId !== sessionId && (recipientOnly || message.fromSessionId !== sessionId)) {
+            throw new CollaborationError('MESSAGE_NOT_YOURS', recipientOnly
+                ? 'Message exists but was not addressed to this session'
+                : 'Message exists but this session is neither its sender nor its recipient', 404);
+        }
         return message;
     };
     const sent = (res, ids) => {
@@ -83,8 +105,18 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
         const targets = requestedTargets.length > 0 ? requestedTargets : (target ? [target] : []);
         if (!targets.length)
             throw new CollaborationError('NO_TARGET', 'send requires a targetSessionId (or toSessionIds for a fan-out)', 400);
+        // `--group` may be the short id; an unresolvable one must stay a
+        // GROUP_NOT_FOUND below instead of silently falling back to the only
+        // shared group, which would send to a set the sender did not name.
+        let requestedGroupId = typeof req.body.group_id === 'string' ? req.body.group_id : '';
+        if (requestedGroupId) {
+            const resolved = store.resolveGroupId(requestedGroupId);
+            if (resolved.status === 'ambiguous')
+                throw new CollaborationError('GROUP_ID_AMBIGUOUS', ambiguousIdMessage('协作组', resolved.matches.length));
+            requestedGroupId = resolved.status === 'ok' ? resolved.id : requestedGroupId;
+        }
         const groups = store.groupsForSession(sessionId)
-            .filter((group) => targets.every((candidate) => group.sessionIds.includes(candidate)) && (!req.body.group_id || group.id === req.body.group_id));
+            .filter((group) => targets.every((candidate) => group.sessionIds.includes(candidate)) && (!requestedGroupId || group.id === requestedGroupId));
         if (!groups.length)
             throw new CollaborationError('GROUP_NOT_FOUND', 'Sender and recipients must share the specified group');
         if (groups.length > 1 && !req.body.group_id)
@@ -129,9 +161,24 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
         const since = sinceText === undefined ? undefined : /^\d+$/.test(sinceText) ? Number(sinceText) : Date.parse(sinceText);
         if (since !== undefined && !Number.isFinite(since))
             throw new CollaborationError('INVALID_SINCE', 'since must be an ISO timestamp or epoch milliseconds');
+        // `--group` accepts the short id; an unresolvable or ambiguous one
+        // keeps the caller's text, which matches no group and yields an empty page
+        // (the pre-existing behavior for an unknown group filter).
+        let groupFilter = string('group');
+        if (groupFilter) {
+            const resolved = store.resolveGroupId(groupFilter);
+            if (resolved.status === 'ok')
+                groupFilter = resolved.id;
+        }
+        let threadFilter = string('thread');
+        if (threadFilter) {
+            const resolved = store.resolveThreadId(threadFilter);
+            if (resolved.status === 'ok')
+                threadFilter = resolved.id;
+        }
         const page = store.page(sessionId, { unread: string('unread') === 'true', since, afterId: string('after_id'), cursor: string('cursor'),
             consumer: string('consumer'), limit: string('limit') ? Number(string('limit')) : undefined,
-            from: string('from'), group: string('group'), thread: string('thread'), kind: string('kind'), responseKind: string('response_kind'), order: string('order') });
+            from: string('from'), group: groupFilter, thread: threadFilter, kind: string('kind'), responseKind: string('response_kind'), order: string('order') });
         // Fan-out edges carry sibling recipients; the names map lets the CLI text
         // renderer show 同时发给了:… as people instead of bare session ids. The
         // fallback to the raw id stays server-side agnostic (federated/offline).
@@ -143,7 +190,10 @@ export function collaborationRoutes({ store, resolveSession, deliver, rebind, re
         res.json({ ok: true, consumer: req.body.consumer, cursor: req.body.cursor });
     }));
     const groupOf = (id, sessionId) => {
-        const group = store.getGroup(id);
+        const resolved = store.resolveGroupId(id);
+        if (resolved.status === 'ambiguous')
+            throw new CollaborationError('GROUP_ID_AMBIGUOUS', ambiguousIdMessage('协作组', resolved.matches.length));
+        const group = resolved.status === 'ok' ? store.getGroup(resolved.id) : null;
         if (!group || group.deleted)
             throw new CollaborationError('GROUP_NOT_FOUND', 'Collaboration group not found', 404);
         if (!group.sessionIds.includes(sessionId))

package/dist/server/agent/collaborationStore.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { COLLAB_LIMITS, CollaborationError, STATUS_RANK, validateExtras } from './collaborationProtocol.js';
+import { COLLAB_LIMITS, CollaborationError, STATUS_RANK, canonicalShortId, drawCollaborationId, newCollaborationId, resolveIdPrefix, validateExtras } from './collaborationProtocol.js';
 /** Characters that would corrupt a role line injected into the delivery shell
  * (`你的定位:...`) or smuggle terminal output. Unlike names, roles are plain
  * prose — 「」 and · are harmless there — so only control sequences are barred. */
@@ -25,10 +25,15 @@ const MAX_MESSAGES = 2_000;
 const MESSAGE_KINDS = new Set(['message', 'ask', 'reply', 'task', 'handoff', 'done']);
 export class CollaborationStore {
     filePath;
+    drawId;
     document = { version: 2, groups: [], messages: [] };
     persistedDocument = JSON.stringify(this.document);
-    constructor(filePath) {
+    /** `drawId` is the random source behind newCollaborationId. It is a
+     *  constructor seam so tests can force a collision and prove the guard
+     *  below actually skips it; production always uses the CSPRNG default. */
+    constructor(filePath, drawId = drawCollaborationId) {
         this.filePath = filePath;
+        this.drawId = drawId;
         try {
             const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
             if (Array.isArray(parsed.groups)) {
@@ -57,6 +62,36 @@ export class CollaborationStore {
     getGroup(id) {
         return this.document.groups.find((group) => group.id === id) ?? null;
     }
+    /** Typed lookups accept the short id a terminal shows as well as the full
+     *  one: exact match first, then a unique prefix. Ambiguity is reported,
+     *  never guessed at, and resolution happens before any send so the
+     *  idempotency payload hash still sees the full id. */
+    resolveGroupId(id) {
+        return resolveIdPrefix(this.document.groups.map((group) => group.id), id);
+    }
+    /** Everything a freshly minted id must not collide with. It holds two forms
+     *  of each stored id: the id itself, and the truncated form it displays as.
+     *  The second form is what keeps a new id from landing on the visible form
+     *  of an older UUID — resolveIdPrefix prefers an exact match, so that
+     *  collision would silently answer lookups with the wrong message. Ids
+     *  arrive from federation as given and cannot be rewritten, so this only
+     *  guarantees uniqueness within what this store has seen. */
+    takenIds() {
+        const taken = new Set();
+        const add = (id) => {
+            if (!id)
+                return;
+            taken.add(id);
+            taken.add(canonicalShortId(id));
+        };
+        for (const group of this.document.groups)
+            add(group.id);
+        for (const message of this.document.messages) {
+            add(message.id);
+            add(message.threadId);
+        }
+        return taken;
+    }
     save(input) {
         const now = Date.now();
         const existing = input.id ? this.document.groups.find((group) => group.id === input.id) : null;
@@ -64,7 +99,7 @@ export class CollaborationStore {
         const group = pruneRoles({
             ...existing,
             ...(existing?.remoteSessions ? { remoteSessions: existing.remoteSessions.filter((session) => sessionIds.includes(session.sessionId)) } : {}),
-            id: existing?.id ?? crypto.randomUUID(),
+            id: existing?.id ?? newCollaborationId(this.takenIds(), this.drawId),
             name: input.name.trim(),
             sessionIds,
             createdAt: existing?.createdAt ?? now,
@@ -197,11 +232,12 @@ export class CollaborationStore {
                 throw new CollaborationError('IDEMPOTENCY_RECORD_GONE', 'Original message removed; this key cannot be reused yet', 409);
             return originals;
         }
-        const threadId = input.threadId?.trim() || crypto.randomUUID();
+        const taken = this.takenIds();
+        const threadId = input.threadId?.trim() || newCollaborationId(taken, this.drawId);
         const messages = recipients.map((toSessionId) => ({
             idempotencyKey: input.idempotencyKey, responseKind: extras.responseKind, metadata: extras.metadata, task: extras.task, expiresAt: extras.expiresAt,
             sequence: this.nextSequence(),
-            id: crypto.randomUUID(), groupId: group.id, fromSessionId: input.fromSessionId,
+            id: newCollaborationId(taken, this.drawId), groupId: group.id, fromSessionId: input.fromSessionId,
             toSessionId, kind: input.kind, content, threadId,
             fanOutIds: recipients.length > 1 ? recipients.filter((id) => id !== toSessionId) : undefined,
             replyTo: input.replyTo?.trim() || null, status: 'pending', createdAt: now,
@@ -222,6 +258,16 @@ export class CollaborationStore {
         this.expire();
         return this.document.messages.find((message) => message.id === id) ?? null;
     }
+    resolveMessageId(id) {
+        this.expire();
+        return resolveIdPrefix(this.document.messages.map((message) => message.id), id);
+    }
+    /** Thread ids are shown shortened alongside message ids, so the `--thread`
+     *  filter has to take one back the same way. */
+    resolveThreadId(id) {
+        this.expire();
+        return resolveIdPrefix([...new Set(this.document.messages.map((message) => message.threadId).filter((threadId) => Boolean(threadId)))], id);
+    }
     inbox(sessionId, options = {}) {
         this.expire();
         const matches = this.document.messages.filter((message) => message.toSessionId === sessionId && (!options.pendingOnly || message.status === 'pending'));

package/dist/server/routes/terminal.js

@@ -40,6 +40,7 @@ import { collaborationRoutes } from '../agent/collaborationRoutes.js';
 import { COLLAB_LIMITS, extrasFromBody } from '../agent/collaborationProtocol.js';
 import { CollaborationStore } from '../agent/collaborationStore.js';
 import { COLLAB_NAME_FORBIDDEN, formatCollaborationDelivery } from '../agent/collaborationPrompt.js';
+import { ambiguousIdMessage } from '../agent/collaborationProtocol.js';
 import { buildCollaborationSpawnCommand, resolveCollaborationSpawnMode } from '../agent/collaborationSpawn.js';
 import { SessionSearchStore } from '../agent/sessionSearchStore.js';
 import { resolveCollaborationBackend, resolveCollaborationSessionId } from '../agent/sessionBindingRecovery.js';
@@ -5519,8 +5520,20 @@ router.post('/operations/collaboration-federation', (req, res) => {
 });
 router.use('/operations', collaborationGroupRoutes({ store: collaborationStore,
     sessions: () => globalSessionState.sessions.map(orchestrationSessionSnapshot) }));
+/** Group id from a URL param: the short id a terminal shows resolves to
+ *  its full id, an ambiguous prefix is refused with 409, and anything else is
+ *  simply "no such group" — the same 404 each route already answers. */
+function resolveGroupParam(id) {
+    const resolved = collaborationStore.resolveGroupId(id);
+    if (resolved.status === 'ambiguous')
+        return { group: null, ambiguous: resolved.matches.length };
+    return { group: resolved.status === 'ok' ? collaborationStore.getGroup(resolved.id) : null, ambiguous: 0 };
+}
+const ambiguousGroupResponse = (res, count) => res.status(409).json({ error: ambiguousIdMessage('协作组', count), code: 'GROUP_ID_AMBIGUOUS' });
 router.post('/operations/collaboration-groups/:groupId/spawn', async (req, res) => {
-    const group = collaborationStore.getGroup(req.params.groupId);
+    const { group, ambiguous } = resolveGroupParam(req.params.groupId);
+    if (ambiguous)
+        return ambiguousGroupResponse(res, ambiguous);
     if (!group)
         return res.status(404).json({ error: '协作组不存在' });
     try {
@@ -5533,14 +5546,18 @@ router.post('/operations/collaboration-groups/:groupId/spawn', async (req, res)
     }
 });
 router.get('/operations/collaboration-groups/:groupId/messages', (req, res) => {
-    const group = collaborationStore.getGroup(req.params.groupId);
+    const { group, ambiguous } = resolveGroupParam(req.params.groupId);
+    if (ambiguous)
+        return ambiguousGroupResponse(res, ambiguous);
     if (!group)
         return res.status(404).json({ error: '协作组不存在' });
     res.json({ messages: collaborationStore.listMessages(group.id, Number(req.query.limit) || 200) });
 });
 router.post('/operations/collaboration-groups/:groupId/messages', (req, res) => {
     try {
-        const group = collaborationStore.getGroup(req.params.groupId);
+        const { group, ambiguous } = resolveGroupParam(req.params.groupId);
+        if (ambiguous)
+            return ambiguousGroupResponse(res, ambiguous);
         if (!group)
             return res.status(404).json({ error: '协作组不存在' });
         const fromSessionId = resolveFrontendSessionId(req.body ?? {});
@@ -5592,7 +5609,9 @@ router.post('/operations/orchestration/members', (req, res) => {
     const groupId = typeof req.body?.groupId === 'string' ? req.body.groupId.trim() : '';
     const targetSessionId = typeof req.body?.targetSessionId === 'string' ? req.body.targetSessionId.trim() : '';
     const action = req.body?.action === 'remove' ? 'remove' : req.body?.action === 'add' ? 'add' : null;
-    const group = collaborationStore.getGroup(groupId);
+    const { group, ambiguous } = resolveGroupParam(groupId);
+    if (ambiguous)
+        return ambiguousGroupResponse(res, ambiguous);
     if (!sourceSessionId)
         return res.status(400).json({ error: '无法识别当前会话；请从 Termdock 会话内运行 td collab' });
     if (!group || !group.sessionIds.includes(sourceSessionId))
@@ -5613,7 +5632,9 @@ router.post('/operations/orchestration/members', (req, res) => {
 router.post('/operations/orchestration/spawn', async (req, res) => {
     const sourceSessionId = resolveFrontendSessionId(req.body ?? {});
     const groupId = typeof req.body?.groupId === 'string' ? req.body.groupId.trim() : '';
-    const group = collaborationStore.getGroup(groupId);
+    const { group, ambiguous } = resolveGroupParam(groupId);
+    if (ambiguous)
+        return ambiguousGroupResponse(res, ambiguous);
     if (!sourceSessionId)
         return res.status(400).json({ error: '无法识别当前会话；请从 Termdock 会话内运行 td collab' });
     if (!group || !group.sessionIds.includes(sourceSessionId))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.195",
+  "version": "1.4.197",
   "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.195",
+  "version": "1.4.197",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-T9Yr6kyM0VWWMdS6LFYinasOYunqdstwvkzVg2zQqZE=",
-  "clientBundleHash": "sha256-wpGsT/oJup/G4MyJSKqpHBJlzc2Ha3wFIWmtp4vc/Wc=",
+  "serverBundleHash": "sha256-+T9vc3U3rPgbrg1oKb9GWwaTbuYXTow0I3cAqV6TIlc=",
+  "clientBundleHash": "sha256-GKvLn08PjXFK40TGm1OlgtPAA9Tcvy+GYnD2hU+pys0=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

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

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

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

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-TICWLB2K-N3OPIvmU.js";import{d as i}from"./mermaid.core-Ny4ifEul.js";import"./chunk-5VM5RSS4-BofAFEcC.js";import"./chunk-XXDRQBXY-IurIojt5.js";import"./chunk-POPQ4Y6H-MXmTC-sG.js";import"./chunk-F27PBJKO-CLNw1JDM.js";import"./purify.es-4eNOHKSq.js";import"./app-5zC_J9mq.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-Dahb2o7K.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as t,C as e}from"./chunk-TICWLB2K-N3OPIvmU.js";import{d as i}from"./mermaid.core-Ny4ifEul.js";import"./chunk-5VM5RSS4-BofAFEcC.js";import"./chunk-XXDRQBXY-IurIojt5.js";import"./chunk-POPQ4Y6H-MXmTC-sG.js";import"./chunk-F27PBJKO-CLNw1JDM.js";import"./purify.es-4eNOHKSq.js";import"./app-5zC_J9mq.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};