dominds 1.20.2 → 1.20.3

package/dist/tools/prompts/control/zh/tools.md

@@ -143,6 +143,7 @@ status: ok|error
 **参数：**
 
 - `selector`（必需）：章节选择器（goals/constraints/progress）
+- `category`（可选）：额外章节目录；与 `selector` 组合定位 `<category>/<selector>.md`
 - `content`（必需）：新内容（整段替换）
 
 **返回：**
@@ -156,7 +157,7 @@ updated_at: <更新时间戳>
 **特点：**
 
 - 每次调用替换整个章节
-- 不重置对话轮次
+- 不开启新 course
 - 变更对所有队友可见
 - 约束规则：`constraints` 只写任务特有硬要求，不得重复系统提示/工具文档中的全局规则；一经发现重复，必须删除并告知用户
 
@@ -184,10 +185,25 @@ mind_more({
 - 只追加，不会自动去重、改写或压缩旧内容
 - 适合给 `progress` 补一两条当前仍有效的状态、决策、下一步或阻塞
 - 不适合把每一步调查过程、长日志、完整方案或验收记录当流水账追加进去；这些细节应写入 rtws 正式文档，差遣牒只写摘要和文档定位 pointer
-- 若需要删除陈旧项、重排结构或压缩公告牌，仍使用 `change_mind` 做整章替换
+- 若需要删除陈旧项、重排结构或压缩公告牌，仍使用 `change_mind` 做整章替换；若要删除整个章节文件，使用 `never_mind`
 - 当同一主题已经有多条阶段记录时，优先 `change_mind` 合并成当前仍有效的简明公告，而不是继续 `mind_more`
 
-### 7. recall_taskdoc
+### 7. never_mind
+
+删除差遣牒章节文件。
+
+**参数：**
+
+- `selector`（必需）：章节选择器；顶层章节可用 `goals` / `constraints` / `progress`
+- `category`（可选）：额外章节目录；与 `selector` 组合定位 `<category>/<selector>.md`
+
+**特点：**
+
+- 只删除整章文件，不做内容编辑
+- 仅用于章节整体不再成立；如果只是删除几条陈旧项或压缩结构，优先用 `change_mind` 写回整理后的全文
+- 不开启新 course
+
+### 8. recall_taskdoc
 
 读取差遣牒章节。
 

package/dist/tools/prompts/personal_memory/en/principles.md

@@ -90,7 +90,7 @@ The `personal_memory` toolset uses a **path key-value storage** model:
 
 - **team_memory**: Team shared memory, visible to all members
 - **reminder**: Temporary reminder, session-level
-- **mind_more / change_mind**: Append to or replace Taskdoc (goals/constraints/progress)
+- **mind_more / change_mind / never_mind**: Append to, replace, or delete Taskdoc sections (goals/constraints/progress)
 
 ## Limitations and Notes
 

package/dist/tools/prompts/personal_memory/zh/principles.md

@@ -90,7 +90,7 @@ personal_memory 工具集采用**路径键值存储**模型：
 
 - **team_memory**：团队共享记忆，所有成员可见
 - **reminder**：临时提醒，会话级别
-- **mind_more / change_mind**：追加或替换差遣牒（goals/constraints/progress）
+- **mind_more / change_mind / never_mind**：追加、替换或删除差遣牒章节（goals/constraints/progress）
 
 ## 限制与注意事项
 

package/dist/tools/prompts/team_memory/en/principles.md

@@ -80,7 +80,7 @@ The team_memory toolset uses a **path key-value storage** model, similar to pers
 
 - **personal_memory**: Personal memory, only current agent visible
 - **reminder**: Temporary reminder, session-level
-- **mind_more / change_mind**: Append to or replace Taskdoc (goals/constraints/progress)
+- **mind_more / change_mind / never_mind**: Append to, replace, or delete Taskdoc sections (goals/constraints/progress)
 
 > Note: `team_memory` carries long-lived team consensus; Taskdoc `progress` carries quasi-real-time team-wide task announcements during execution. Do not mix them.
 

package/dist/tools/prompts/team_memory/zh/principles.md

@@ -80,7 +80,7 @@ team_memory 工具集采用**路径键值存储**模型，与 personal_memory
 
 - **personal_memory**：个人记忆，仅当前智能体可见
 - **reminder**：临时提醒，会话级别
-- **mind_more / change_mind**：追加或替换差遣牒（goals/constraints/progress）
+- **mind_more / change_mind / never_mind**：追加、替换或删除差遣牒章节（goals/constraints/progress）
 
 > 注：`team_memory` 承接团队长期共识；Taskdoc `progress` 承接任务执行期的准实时全队公告，不应混淆。
 

package/dist/tools/team_mgmt.js

@@ -3221,7 +3221,7 @@ function renderPermissionsManual(language) {
                 '模式支持 `*` 和 `**`，按“目录范围”语义匹配（按目录/路径前缀范围来理解）。',
                 '示例：`dominds/**` 会匹配 `dominds/README.md`、`dominds/main/server.ts`、`dominds/webapp/src/...` 等路径。',
                 '示例：`.minds/**` 会匹配 `.minds/team.yaml`、`.minds/team/<id>/persona.zh.md` 等；常用于限制普通成员访问 minds 资产。',
-                '`*.tsk/` 是封装差遣牒：只能用函数工具 `mind_more` / `change_mind` 维护。任何通用文件工具都无法访问该目录树（硬编码无条件拒绝）。',
+                '`*.tsk/` 是封装差遣牒：只能用函数工具 `mind_more` / `change_mind` / `never_mind` 维护。任何通用文件工具都无法访问该目录树（硬编码无条件拒绝）。',
                 '`.minds/**` 是 rtws（运行时工作区）的“团队配置/记忆/资产”目录：任何通用文件工具都无法访问（硬编码无条件拒绝）。只有专用的 `.minds/` 工具集（例如 `team_mgmt`）可访问它。',
                 '在当前内建模型中，`.minds/team/**`、`.minds/team.yaml`、`.minds/skills/**`、`.minds/priming/**` 等团队资产目录，只有持有 `team_mgmt` 的成员才应修改。',
                 '`.minds/team/<id>/*` 的“角色归属对象”只表示它描述哪个角色，不构成任何额外写权限。未持有 `team_mgmt` 的成员，即使只是想更新“自己的” persona/knowhow/pitfalls，也应通过回贴建议内容，由具备权限的团队管理者代写。',
@@ -3249,7 +3249,7 @@ function renderPermissionsManual(language) {
             'Patterns support `*` and `**` with directory-scope semantics (think directory/path-range matching).',
             'Example: `dominds/**` matches `dominds/README.md`, `dominds/main/server.ts`, `dominds/webapp/src/...`, etc.',
             'Example: `.minds/**` matches `.minds/team.yaml` and `.minds/team/<id>/persona.*.md`; commonly used to restrict normal members from minds assets.',
-            '`*.tsk/` is an encapsulated Taskdoc: it must be maintained via `mind_more` / `change_mind` only. It is hard-denied for all general file tools.',
+            '`*.tsk/` is an encapsulated Taskdoc: it must be maintained via `mind_more` / `change_mind` / `never_mind` only. It is hard-denied for all general file tools.',
             '`.minds/**` stores rtws (runtime workspace) team config/memory/assets: it is hard-denied for all general file tools. Only dedicated `.minds/`-scoped toolsets (e.g. `team_mgmt`) may access it.',
             'In the current built-in model, team asset paths such as `.minds/team/**`, `.minds/team.yaml`, `.minds/skills/**`, and `.minds/priming/**` should only be modified by members who hold `team_mgmt`.',
             'The “owner role” of `.minds/team/<id>/*` only tells you which role the asset describes; it does not grant extra write permission. Without `team_mgmt`, a member should not rewrite even “their own” persona/knowhow/pitfalls directly, and should instead hand back suggested content for an authorized team manager to apply.',

package/dist/utils/task-package.d.ts

@@ -129,6 +129,15 @@ export declare function appendTaskPackageByChangeMindTarget(params: {
     sep: string;
     updatedBy?: string;
 }): Promise<void>;
+export declare function deleteTaskPackageByChangeMindTarget(params: {
+    taskPackageDirFullPath: string;
+    target: TaskPackageChangeMindTarget;
+}): Promise<{
+    kind: 'deleted';
+} | {
+    kind: 'missing';
+}>;
+export declare function taskPackageRelativePathForChangeMindTarget(target: TaskPackageChangeMindTarget): string;
 export declare function ensureTaskPackage(taskPackageDirFullPath: string, _updatedBy?: string): Promise<void>;
 export declare function readTaskPackageSections(taskPackageDirFullPath: string): Promise<TaskPackageSectionsState>;
 export declare function formatEffectiveTaskDocFromSections(language: LanguageCode, sections: TaskPackageSectionsState, bearInMind?: TaskPackageBearInMindState): string;

package/dist/utils/task-package.js

@@ -54,6 +54,8 @@ exports.taskPackageFilenameForSection = taskPackageFilenameForSection;
 exports.bearInMindFilenameForSection = bearInMindFilenameForSection;
 exports.updateTaskPackageByChangeMindTarget = updateTaskPackageByChangeMindTarget;
 exports.appendTaskPackageByChangeMindTarget = appendTaskPackageByChangeMindTarget;
+exports.deleteTaskPackageByChangeMindTarget = deleteTaskPackageByChangeMindTarget;
+exports.taskPackageRelativePathForChangeMindTarget = taskPackageRelativePathForChangeMindTarget;
 exports.ensureTaskPackage = ensureTaskPackage;
 exports.readTaskPackageSections = readTaskPackageSections;
 exports.formatEffectiveTaskDocFromSections = formatEffectiveTaskDocFromSections;
@@ -200,6 +202,26 @@ async function appendTaskPackageByChangeMindTarget(params) {
     const next = current === null || current.trim() === '' ? content : joinForAppend(current, content, sep);
     await writeMarkdownFileWithCanonicalEnding(filePath, next);
 }
+async function deleteTaskPackageByChangeMindTarget(params) {
+    const filePath = taskPackageFilePathForChangeMindTarget(params.taskPackageDirFullPath, params.target);
+    try {
+        const st = await fs.promises.stat(filePath);
+        if (!st.isFile()) {
+            throw new Error(`Taskdoc section target is not a file: ${filePath}`);
+        }
+        await fs.promises.unlink(filePath);
+        return { kind: 'deleted' };
+    }
+    catch (err) {
+        if (typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            err.code === 'ENOENT') {
+            return { kind: 'missing' };
+        }
+        throw err;
+    }
+}
 async function writeMarkdownFileWithCanonicalEnding(filePath, content) {
     await fs.promises.writeFile(filePath, withCanonicalMarkdownFileEnding(content), 'utf8');
 }
@@ -209,20 +231,23 @@ function withCanonicalMarkdownFileEnding(content) {
         return '';
     return `${stripped}\n`;
 }
-function taskPackageFilePathForChangeMindTarget(taskPackageDirFullPath, target) {
+function taskPackageRelativePathForChangeMindTarget(target) {
     switch (target.kind) {
         case 'top_level':
-            return path.join(taskPackageDirFullPath, taskPackageFilenameForSection(target.section));
+            return taskPackageFilenameForSection(target.section);
         case 'bearinmind':
-            return path.join(taskPackageDirFullPath, 'bearinmind', bearInMindFilenameForSection(target.section));
+            return path.join('bearinmind', bearInMindFilenameForSection(target.section));
         case 'category':
-            return path.join(taskPackageDirFullPath, target.category, `${target.selector}.md`);
+            return path.join(target.category, `${target.selector}.md`);
         default: {
             const _exhaustive = target;
             return _exhaustive;
         }
     }
 }
+function taskPackageFilePathForChangeMindTarget(taskPackageDirFullPath, target) {
+    return path.join(taskPackageDirFullPath, taskPackageRelativePathForChangeMindTarget(target));
+}
 async function readTextFileIfPresent(filePath) {
     try {
         return await fs.promises.readFile(filePath, 'utf8');

package/dist/utils/taskdoc-search-worker-client.d.ts

@@ -0,0 +1,12 @@
+import type { SearchTaskDocumentSuggestionsResult } from './taskdoc-search';
+export type TaskdocSuggestionWorkerPayload = {
+    rootDir?: string;
+    query: string;
+    limit?: number;
+};
+type TaskdocSuggestionWorkerOptions = {
+    signal?: AbortSignal;
+};
+export declare function buildTaskDocumentSuggestionRequestKey(payload: TaskdocSuggestionWorkerPayload): string;
+export declare function searchTaskDocumentSuggestionsInWorker(payload: TaskdocSuggestionWorkerPayload, options?: TaskdocSuggestionWorkerOptions): Promise<SearchTaskDocumentSuggestionsResult>;
+export {};

package/dist/utils/taskdoc-search-worker-client.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskDocumentSuggestionRequestKey = buildTaskDocumentSuggestionRequestKey;
+exports.searchTaskDocumentSuggestionsInWorker = searchTaskDocumentSuggestionsInWorker;
+const fs_1 = __importDefault(require("fs"));
+const module_1 = require("module");
+const path = __importStar(require("path"));
+const worker_threads_1 = require("worker_threads");
+const requireFn = (0, module_1.createRequire)(__filename);
+const TASKDOC_SUGGESTION_WORKER_TIMEOUT_MS = 10000;
+const TASKDOC_SUGGESTION_MAX_WORKERS = 2;
+const TASKDOC_SUGGESTION_MAX_PENDING_WORKERS = 8;
+const TASKDOC_SUGGESTION_CACHE_TTL_MS = 3000;
+const TASKDOC_SUGGESTION_CACHE_MAX_ENTRIES = 64;
+let activeTaskdocSuggestionWorkers = 0;
+const pendingTaskdocSuggestionWorkerSlots = [];
+const taskdocSuggestionCache = new Map();
+const taskdocSuggestionInFlightByCacheKey = new Map();
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeTaskdocSuggestionLimit(limit) {
+    return typeof limit === 'number' && Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 50;
+}
+function normalizeTaskdocSuggestionQueryKey(query) {
+    const normalized = query.trim().toLowerCase();
+    return normalized.endsWith('.tsk') ? normalized.slice(0, -4) : normalized;
+}
+function buildTaskDocumentSuggestionRequestKey(payload) {
+    return normalizeTaskdocSuggestionQueryKey(payload.query);
+}
+function buildTaskDocumentSuggestionCacheKey(payload) {
+    return [
+        path.resolve(payload.rootDir ?? '.'),
+        String(normalizeTaskdocSuggestionLimit(payload.limit)),
+        buildTaskDocumentSuggestionRequestKey(payload),
+    ].join('\u0000');
+}
+function readTaskDocumentSuggestionCache(cacheKey) {
+    const cached = taskdocSuggestionCache.get(cacheKey);
+    if (!cached)
+        return undefined;
+    if (cached.expiresAtMs <= Date.now()) {
+        taskdocSuggestionCache.delete(cacheKey);
+        return undefined;
+    }
+    return cached.result;
+}
+function writeTaskDocumentSuggestionCache(cacheKey, result) {
+    if (result.kind !== 'ok')
+        return;
+    const now = Date.now();
+    for (const [key, cached] of taskdocSuggestionCache) {
+        if (cached.expiresAtMs <= now)
+            taskdocSuggestionCache.delete(key);
+    }
+    taskdocSuggestionCache.delete(cacheKey);
+    taskdocSuggestionCache.set(cacheKey, {
+        expiresAtMs: now + TASKDOC_SUGGESTION_CACHE_TTL_MS,
+        result,
+    });
+    while (taskdocSuggestionCache.size > TASKDOC_SUGGESTION_CACHE_MAX_ENTRIES) {
+        const oldestKey = taskdocSuggestionCache.keys().next().value;
+        if (typeof oldestKey !== 'string')
+            break;
+        taskdocSuggestionCache.delete(oldestKey);
+    }
+}
+async function waitForTaskDocumentSuggestionResult(promise, signal) {
+    if (!signal)
+        return await promise;
+    if (signal.aborted) {
+        return { kind: 'error', errorText: 'Taskdoc suggestion request aborted' };
+    }
+    return await new Promise((resolve) => {
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', abortWait);
+            resolve(result);
+        };
+        const abortWait = () => {
+            settle({ kind: 'error', errorText: 'Taskdoc suggestion request aborted' });
+        };
+        signal.addEventListener('abort', abortWait, { once: true });
+        promise.then(settle, (error) => {
+            settle({
+                kind: 'error',
+                errorText: error instanceof Error ? error.message : 'Taskdoc suggestion worker failed',
+            });
+        });
+    });
+}
+function parseWorkerMessage(value) {
+    if (!isRecord(value))
+        throw new Error('Taskdoc suggestion worker returned non-object message');
+    const kind = value['kind'];
+    switch (kind) {
+        case 'ok': {
+            const suggestionsRaw = value['suggestions'];
+            if (!isRecord(suggestionsRaw)) {
+                throw new Error('Taskdoc suggestion worker ok message missing suggestions');
+            }
+            if (suggestionsRaw['kind'] === 'ok') {
+                const listRaw = suggestionsRaw['suggestions'];
+                if (!Array.isArray(listRaw)) {
+                    throw new Error('Taskdoc suggestion worker ok result missing suggestions list');
+                }
+                return {
+                    kind: 'ok',
+                    suggestions: {
+                        kind: 'ok',
+                        suggestions: listRaw.map((item) => {
+                            if (!isRecord(item)) {
+                                throw new Error('Taskdoc suggestion worker returned invalid suggestion item');
+                            }
+                            const pathRaw = item['path'];
+                            const relativePath = item['relativePath'];
+                            const name = item['name'];
+                            if (typeof pathRaw !== 'string' ||
+                                typeof relativePath !== 'string' ||
+                                typeof name !== 'string') {
+                                throw new Error('Taskdoc suggestion worker returned malformed suggestion item');
+                            }
+                            return { path: pathRaw, relativePath, name };
+                        }),
+                    },
+                };
+            }
+            if (suggestionsRaw['kind'] === 'error') {
+                const errorText = suggestionsRaw['errorText'];
+                if (typeof errorText !== 'string') {
+                    throw new Error('Taskdoc suggestion worker error result missing errorText');
+                }
+                return { kind: 'ok', suggestions: { kind: 'error', errorText } };
+            }
+            throw new Error('Taskdoc suggestion worker returned unknown suggestions kind');
+        }
+        case 'error': {
+            const errorText = value['errorText'];
+            if (typeof errorText !== 'string') {
+                throw new Error('Taskdoc suggestion worker error message missing errorText');
+            }
+            return { kind: 'error', errorText };
+        }
+        default:
+            throw new Error(`Taskdoc suggestion worker returned unknown message kind: ${String(kind)}`);
+    }
+}
+function resolveTaskdocSuggestionWorkerEntrypointAbs() {
+    const distCandidate = path.resolve(__dirname, 'taskdoc-search-worker.js');
+    if (fs_1.default.existsSync(distCandidate)) {
+        return { ok: true, kind: 'compiled_js', scriptAbs: distCandidate };
+    }
+    const tsCandidate = path.resolve(__dirname, 'taskdoc-search-worker.ts');
+    if (fs_1.default.existsSync(tsCandidate)) {
+        const tsxCjsRegisterAbs = requireFn.resolve('tsx/cjs');
+        return { ok: true, kind: 'tsx_cjs_bridge', scriptAbs: tsCandidate, tsxCjsRegisterAbs };
+    }
+    return {
+        ok: false,
+        errorText: `Cannot find taskdoc suggestion worker entrypoint at ${distCandidate} or ${tsCandidate}`,
+    };
+}
+async function acquireTaskdocSuggestionWorkerSlot() {
+    if (activeTaskdocSuggestionWorkers < TASKDOC_SUGGESTION_MAX_WORKERS) {
+        activeTaskdocSuggestionWorkers += 1;
+        return;
+    }
+    if (pendingTaskdocSuggestionWorkerSlots.length >= TASKDOC_SUGGESTION_MAX_PENDING_WORKERS) {
+        throw new Error('Taskdoc suggestion worker queue is full');
+    }
+    await new Promise((resolve) => {
+        const grantSlot = () => {
+            activeTaskdocSuggestionWorkers += 1;
+            resolve();
+        };
+        pendingTaskdocSuggestionWorkerSlots.push(grantSlot);
+    });
+}
+function releaseTaskdocSuggestionWorkerSlot() {
+    activeTaskdocSuggestionWorkers = Math.max(0, activeTaskdocSuggestionWorkers - 1);
+    const next = pendingTaskdocSuggestionWorkerSlots.shift();
+    if (next) {
+        next();
+        return;
+    }
+}
+async function runTaskDocumentSuggestionsWorker(payload) {
+    const entry = resolveTaskdocSuggestionWorkerEntrypointAbs();
+    if (!entry.ok)
+        return { kind: 'error', errorText: entry.errorText };
+    let acquiredWorkerSlot = false;
+    try {
+        await acquireTaskdocSuggestionWorkerSlot();
+        acquiredWorkerSlot = true;
+        const worker = entry.kind === 'compiled_js'
+            ? new worker_threads_1.Worker(entry.scriptAbs, { workerData: payload })
+            : new worker_threads_1.Worker('const { workerData } = require("worker_threads"); require(workerData.tsxCjsRegisterAbs); require(workerData.scriptAbs);', {
+                eval: true,
+                workerData: {
+                    ...payload,
+                    scriptAbs: entry.scriptAbs,
+                    tsxCjsRegisterAbs: entry.tsxCjsRegisterAbs,
+                },
+            });
+        return await new Promise((resolve) => {
+            let settled = false;
+            const timeout = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                releaseTaskdocSuggestionWorkerSlot();
+                void worker.terminate();
+                resolve({ kind: 'error', errorText: 'Taskdoc suggestion worker timed out' });
+            }, TASKDOC_SUGGESTION_WORKER_TIMEOUT_MS);
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                releaseTaskdocSuggestionWorkerSlot();
+                void worker.terminate();
+                resolve(result);
+            };
+            worker.once('message', (raw) => {
+                try {
+                    const message = parseWorkerMessage(raw);
+                    if (message.kind === 'ok') {
+                        settle(message.suggestions);
+                        return;
+                    }
+                    settle({ kind: 'error', errorText: message.errorText });
+                }
+                catch (error) {
+                    settle({
+                        kind: 'error',
+                        errorText: error instanceof Error ? error.message : 'Invalid taskdoc worker response',
+                    });
+                }
+            });
+            worker.once('error', (error) => {
+                settle({ kind: 'error', errorText: error.message });
+            });
+            worker.once('exit', (code) => {
+                if (settled)
+                    return;
+                settle({ kind: 'error', errorText: `Taskdoc suggestion worker exited with code ${code}` });
+            });
+        });
+    }
+    catch (error) {
+        if (acquiredWorkerSlot)
+            releaseTaskdocSuggestionWorkerSlot();
+        return {
+            kind: 'error',
+            errorText: error instanceof Error ? error.message : 'Failed to start taskdoc worker',
+        };
+    }
+}
+async function searchTaskDocumentSuggestionsInWorker(payload, options = {}) {
+    if (options.signal?.aborted) {
+        return { kind: 'error', errorText: 'Taskdoc suggestion request aborted' };
+    }
+    const cacheKey = buildTaskDocumentSuggestionCacheKey(payload);
+    const cached = readTaskDocumentSuggestionCache(cacheKey);
+    if (cached)
+        return cached;
+    let inFlight = taskdocSuggestionInFlightByCacheKey.get(cacheKey);
+    if (!inFlight) {
+        inFlight = runTaskDocumentSuggestionsWorker(payload)
+            .then((result) => {
+            writeTaskDocumentSuggestionCache(cacheKey, result);
+            return result;
+        })
+            .finally(() => {
+            taskdocSuggestionInFlightByCacheKey.delete(cacheKey);
+        });
+        taskdocSuggestionInFlightByCacheKey.set(cacheKey, inFlight);
+    }
+    return await waitForTaskDocumentSuggestionResult(inFlight, options.signal);
+}

package/dist/utils/taskdoc-search-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/taskdoc-search-worker.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const taskdoc_search_1 = require("./taskdoc-search");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseWorkerPayload(value) {
+    if (!isRecord(value)) {
+        throw new Error('Taskdoc suggestion worker payload must be an object');
+    }
+    const query = value['query'];
+    if (typeof query !== 'string') {
+        throw new Error('Taskdoc suggestion worker payload.query must be a string');
+    }
+    const rootDirRaw = value['rootDir'];
+    const limitRaw = value['limit'];
+    return {
+        query,
+        ...(typeof rootDirRaw === 'string' ? { rootDir: rootDirRaw } : {}),
+        ...(typeof limitRaw === 'number' ? { limit: limitRaw } : {}),
+    };
+}
+async function main() {
+    if (worker_threads_1.parentPort === null) {
+        throw new Error('Taskdoc suggestion worker requires a parentPort');
+    }
+    try {
+        const payload = parseWorkerPayload(worker_threads_1.workerData);
+        const suggestions = await (0, taskdoc_search_1.searchTaskDocumentSuggestionsInRtws)(payload);
+        const message = { kind: 'ok', suggestions };
+        worker_threads_1.parentPort.postMessage(message);
+    }
+    catch (error) {
+        const message = {
+            kind: 'error',
+            errorText: error instanceof Error ? error.message : 'Taskdoc suggestion worker failed',
+        };
+        worker_threads_1.parentPort.postMessage(message);
+    }
+}
+void main();

package/dist/utils/taskdoc-search.d.ts

@@ -1,10 +1,19 @@
-export interface TaskDocumentSummary {
-    path: string;
-    relativePath: string;
-    name: string;
-    size: number;
-    lastModified: string;
-}
+/**
+ * Module: utils/taskdoc-search
+ *
+ * rtws (runtime workspace) search utilities for Taskdocs (`*.tsk/`).
+ *
+ * Taskdocs are encapsulated directories ending in `.tsk`. For search, we treat each `*.tsk/`
+ * directory as a single unit and do not recurse into it.
+ *
+ * Ignore rules:
+ * - Default ignore patterns skip common non-task directories (at any depth).
+ * - A `.taskdoc-ignore` file may exist in any directory. Its patterns apply to that directory's
+ *   subtree only (like a simplified `.gitignore`).
+ * - Patterns are interpreted as paths relative to the `.taskdoc-ignore` directory (unless they
+ *   start with `/`, in which case they are rtws-root-relative).
+ */
+import type { TaskDocumentSuggestion, TaskDocumentSummary } from '@longrun-ai/kernel/types/taskdoc';
 export type ListTaskDocumentsResult = {
     kind: 'ok';
     taskDocuments: TaskDocumentSummary[];
@@ -12,8 +21,20 @@ export type ListTaskDocumentsResult = {
     kind: 'error';
     errorText: string;
 };
+export type SearchTaskDocumentSuggestionsResult = {
+    kind: 'ok';
+    suggestions: TaskDocumentSuggestion[];
+} | {
+    kind: 'error';
+    errorText: string;
+};
 interface ListTaskDocumentsParams {
     rootDir?: string;
 }
+interface SearchTaskDocumentSuggestionsParams extends ListTaskDocumentsParams {
+    query: string;
+    limit?: number;
+}
 export declare function listTaskDocumentsInRtws(params?: ListTaskDocumentsParams): Promise<ListTaskDocumentsResult>;
+export declare function searchTaskDocumentSuggestionsInRtws(params: SearchTaskDocumentSuggestionsParams): Promise<SearchTaskDocumentSuggestionsResult>;
 export {};