parallel-codex-tui 0.3.1 → 0.3.2

package/dist/core/task-report.js

@@ -0,0 +1,510 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir, readlink } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { RouteDecisionSchema, TurnMetaSchema } from "../domain/schemas.js";
+import { loadCollaborationTimeline } from "./collaboration-timeline.js";
+import { pathExists, readJson, readTextIfExists } from "./file-store.js";
+import { loadTaskSessionDetails } from "./task-session-details.js";
+export async function buildTaskReport(input) {
+    const taskSummary = {
+        ...input.task,
+        turnCount: 0,
+        workerCount: 0,
+        nativeSessionCount: 0
+    };
+    const [turns, timeline, details, integrations, reconciliation] = await Promise.all([
+        readTaskReportTurns(input.taskDir),
+        loadCollaborationTimeline(input.task.id, input.taskDir),
+        loadTaskSessionDetails({ task: taskSummary, taskDir: input.taskDir }),
+        readTaskReportIntegrations(input.taskDir),
+        reconcileTaskWorkspace(input.taskDir, input.workspaceRoot)
+    ]);
+    const report = {
+        format: "parallel-codex-task-report-v1",
+        generated_at: input.generatedAt,
+        task: input.task,
+        workspace: {
+            path: input.workspaceRoot,
+            reconciliation
+        },
+        turns,
+        features: timeline.features.map((feature) => ({
+            id: feature.id,
+            turn_id: feature.turnId,
+            title: feature.title,
+            description: feature.description,
+            depends_on: feature.dependsOn,
+            state: feature.state,
+            updated_at: feature.updatedAt,
+            ...(feature.actorEngine ? { actor_engine: feature.actorEngine } : {}),
+            ...(feature.actorModel ? { actor_model: feature.actorModel } : {}),
+            ...(feature.criticEngine ? { critic_engine: feature.criticEngine } : {}),
+            ...(feature.criticModel ? { critic_model: feature.criticModel } : {}),
+            findings: feature.findings,
+            replies: feature.replies,
+            ...(typeof feature.resolvedFindings === "number"
+                ? { resolved_findings: feature.resolvedFindings }
+                : {}),
+            ...(typeof feature.unresolvedFindings === "number"
+                ? { unresolved_findings: feature.unresolvedFindings }
+                : {}),
+            ...(feature.latestFinding ? { latest_finding: feature.latestFinding } : {}),
+            ...(feature.latestReply ? { latest_reply: feature.latestReply } : {})
+        })),
+        workers: details.workers.map((worker) => ({
+            id: worker.id,
+            turn_id: worker.turnId,
+            ...(worker.featureId ? { feature_id: worker.featureId } : {}),
+            ...(worker.featureTitle ? { feature_title: worker.featureTitle } : {}),
+            role: worker.role,
+            engine: worker.engine,
+            model: worker.model,
+            ...(worker.modelProvider ? { model_provider: worker.modelProvider } : {}),
+            state: worker.state,
+            phase: worker.phase,
+            summary: worker.summary,
+            last_activity_at: worker.lastActivityAt,
+            ...(worker.nativeSession ? {
+                native_session: {
+                    id: worker.nativeSession.sessionId,
+                    cwd: worker.nativeSession.cwd,
+                    writable_dirs: worker.nativeSession.writableDirs,
+                    created_at: worker.nativeSession.createdAt,
+                    last_used_at: worker.nativeSession.lastUsedAt,
+                    source: worker.nativeSession.source
+                }
+            } : {})
+        })),
+        integrations
+    };
+    return { report, markdown: renderTaskReportMarkdown(report) };
+}
+export async function reconcileTaskWorkspace(taskDir, workspaceRoot) {
+    const { waves, issues, sawIntegrationRecord } = await readIntegratedWaves(taskDir);
+    const authoritative = new Map();
+    for (const wave of waves) {
+        for (const changedPath of wave.changedPaths) {
+            authoritative.set(changedPath, wave);
+        }
+    }
+    const paths = await Promise.all([...authoritative.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(async ([changedPath, wave]) => {
+        const expected = await inspectReportEntry(wave.integrationDir, changedPath);
+        const current = await inspectReportEntry(workspaceRoot, changedPath);
+        return {
+            path: changedPath,
+            state: compareTaskReportEntries(expected, current),
+            source: {
+                turn_id: wave.turnId,
+                wave: wave.wave,
+                feature_ids: wave.featureIds
+            },
+            expected,
+            current
+        };
+    }));
+    const counts = emptyComparisonCounts();
+    for (const path of paths) {
+        counts[path.state] += 1;
+    }
+    const state = paths.length === 0
+        ? sawIntegrationRecord || issues.length > 0 ? "unavailable" : "no-integrations"
+        : counts.unavailable > 0
+            ? "unavailable"
+            : counts.drift + counts.missing + counts.unexpected > 0
+                ? "drifted"
+                : "clean";
+    return {
+        state,
+        integrated_waves: waves.length,
+        changed_paths: paths.length,
+        counts,
+        paths,
+        issues
+    };
+}
+async function readTaskReportTurns(taskDir) {
+    const turnsRoot = join(taskDir, "turns");
+    let entries;
+    try {
+        entries = await readdir(turnsRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const turns = await Promise.all(entries
+        .filter((entry) => entry.isDirectory() && /^\d{4}$/.test(entry.name))
+        .map(async (entry) => {
+        const dir = join(turnsRoot, entry.name);
+        try {
+            const meta = await readJson(join(dir, "turn.json"), TurnMetaSchema);
+            if (meta.turn_id !== entry.name) {
+                return null;
+            }
+            const [request, route, requirements, plan, acceptanceCriteria, summary, featurePlan, judgeValidation, contract, acceptance, validation] = await Promise.all([
+                readTextIfExists(join(dir, "user.md")),
+                readRouteDecision(join(dir, "route.json")),
+                readTextIfExists(join(dir, "requirements.md")),
+                readTextIfExists(join(dir, "plan.md")),
+                readTextIfExists(join(dir, "acceptance.md")),
+                readTextIfExists(join(dir, "supervisor-summary.md")),
+                readOptionalJson(join(dir, "feature-plan.json")),
+                readOptionalJson(join(dir, "judge-validation.json")),
+                readOptionalJson(join(dir, "completion-contract.json")),
+                readOptionalJson(join(dir, "final-acceptance.json")),
+                readOptionalJson(join(dir, "final-acceptance-validation.json"))
+            ]);
+            return {
+                turn_id: meta.turn_id,
+                created_at: meta.created_at,
+                request: request.trimEnd(),
+                ...(route ? { route } : {}),
+                ...(requirements.trim() ? { requirements: requirements.trimEnd() } : {}),
+                ...(plan.trim() ? { plan: plan.trimEnd() } : {}),
+                ...(acceptanceCriteria.trim() ? { acceptance_criteria: acceptanceCriteria.trimEnd() } : {}),
+                ...(summary.trim() ? { supervisor_summary: summary.trimEnd() } : {}),
+                ...(featurePlan !== undefined ? { feature_plan: featurePlan } : {}),
+                ...(judgeValidation !== undefined ? { judge_validation: judgeValidation } : {}),
+                ...(contract !== undefined ? { completion_contract: contract } : {}),
+                ...(acceptance !== undefined ? { final_acceptance: acceptance } : {}),
+                ...(validation !== undefined ? { final_acceptance_validation: validation } : {})
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return turns
+        .filter((turn) => turn !== null)
+        .sort((left, right) => left.turn_id.localeCompare(right.turn_id));
+}
+async function readTaskReportIntegrations(taskDir) {
+    const { waves } = await readIntegratedWaves(taskDir);
+    return Promise.all(waves.map(async (wave) => {
+        const [verification, verificationReview] = await Promise.all([
+            readOptionalJson(join(wave.rootDir, "verification.json")),
+            readTextIfExists(join(wave.rootDir, "verification-review.md"))
+        ]);
+        return {
+            turn_id: wave.turnId,
+            wave: wave.wave,
+            feature_ids: wave.featureIds,
+            changed_paths: wave.changedPaths,
+            ...(verification !== undefined ? { verification } : {}),
+            ...(verificationReview.trim() ? { verification_review: verificationReview.trimEnd() } : {})
+        };
+    }));
+}
+async function readRouteDecision(path) {
+    if (!(await pathExists(path))) {
+        return undefined;
+    }
+    try {
+        return await readJson(path, RouteDecisionSchema);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readOptionalJson(path) {
+    if (!(await pathExists(path))) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(await readTextIfExists(path));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readIntegratedWaves(taskDir) {
+    const workspacesRoot = join(taskDir, "workspaces");
+    const waves = [];
+    const issues = [];
+    let sawIntegrationRecord = false;
+    let turnEntries;
+    try {
+        turnEntries = await readdir(workspacesRoot, { withFileTypes: true });
+    }
+    catch {
+        return { waves, issues, sawIntegrationRecord };
+    }
+    for (const turnEntry of turnEntries
+        .filter((entry) => entry.isDirectory() && /^turn-\d{4,}$/.test(entry.name))
+        .sort((left, right) => left.name.localeCompare(right.name))) {
+        const turnId = turnEntry.name.slice("turn-".length);
+        const turnRoot = join(workspacesRoot, turnEntry.name);
+        let waveEntries;
+        try {
+            waveEntries = await readdir(turnRoot, { withFileTypes: true });
+        }
+        catch (error) {
+            issues.push(`${turnEntry.name}: ${errorMessage(error)}`);
+            continue;
+        }
+        for (const waveEntry of waveEntries
+            .filter((entry) => entry.isDirectory() && /^wave-\d{4,}$/.test(entry.name))
+            .sort((left, right) => left.name.localeCompare(right.name))) {
+            const path = join(turnRoot, waveEntry.name, "integration.json");
+            if (!(await pathExists(path))) {
+                continue;
+            }
+            sawIntegrationRecord = true;
+            const value = await readOptionalJson(path);
+            if (!isRecord(value)) {
+                issues.push(`${turnEntry.name}/${waveEntry.name}: malformed integration.json`);
+                continue;
+            }
+            if (value.state !== "integrated") {
+                continue;
+            }
+            const wave = Number(value.wave);
+            const featureIds = stringArray(value.feature_ids);
+            const changedPaths = stringArray(value.changed_paths);
+            if (!Number.isInteger(wave) || wave < 1 || !featureIds || !changedPaths) {
+                issues.push(`${turnEntry.name}/${waveEntry.name}: invalid integrated checkpoint`);
+                continue;
+            }
+            waves.push({
+                turnId: typeof value.turn_id === "string" ? value.turn_id : turnId,
+                wave,
+                featureIds,
+                changedPaths,
+                rootDir: join(turnRoot, waveEntry.name),
+                integrationDir: join(turnRoot, waveEntry.name, "integration")
+            });
+        }
+    }
+    waves.sort((left, right) => (left.turnId.localeCompare(right.turnId)
+        || left.wave - right.wave));
+    return { waves, issues, sawIntegrationRecord };
+}
+async function inspectReportEntry(root, changedPath) {
+    const safe = safeWorkspacePath(root, changedPath);
+    if (!safe) {
+        return { type: "unavailable", detail: "unsafe relative path" };
+    }
+    const segments = relative(resolve(root), safe).split(sep);
+    let parent = resolve(root);
+    for (const segment of segments.slice(0, -1)) {
+        parent = join(parent, segment);
+        try {
+            const stat = await lstat(parent);
+            if (stat.isSymbolicLink()) {
+                return { type: "unavailable", detail: "parent path is a symbolic link" };
+            }
+            if (!stat.isDirectory()) {
+                return { type: "missing" };
+            }
+        }
+        catch (error) {
+            if (isMissingError(error)) {
+                return { type: "missing" };
+            }
+            return { type: "unavailable", detail: errorMessage(error) };
+        }
+    }
+    try {
+        const stat = await lstat(safe);
+        if (stat.isSymbolicLink()) {
+            return { type: "symlink", target: await readlink(safe) };
+        }
+        if (stat.isFile()) {
+            const content = await readFile(safe);
+            return {
+                type: "file",
+                sha256: createHash("sha256").update(content).digest("hex"),
+                mode: stat.mode & 0o777,
+                size: stat.size
+            };
+        }
+        return { type: "other", detail: stat.isDirectory() ? "directory" : "special entry" };
+    }
+    catch (error) {
+        return isMissingError(error)
+            ? { type: "missing" }
+            : { type: "unavailable", detail: errorMessage(error) };
+    }
+}
+function safeWorkspacePath(root, changedPath) {
+    if (!changedPath || changedPath.includes("\0") || isAbsolute(changedPath)) {
+        return null;
+    }
+    const base = resolve(root);
+    const candidate = resolve(base, changedPath);
+    const relativePath = relative(base, candidate);
+    return relativePath
+        && relativePath !== ".."
+        && !relativePath.startsWith(`..${sep}`)
+        && !isAbsolute(relativePath)
+        ? candidate
+        : null;
+}
+function compareTaskReportEntries(expected, current) {
+    if (expected.type === "unavailable" || current.type === "unavailable") {
+        return "unavailable";
+    }
+    if (expected.type === "missing") {
+        return current.type === "missing" ? "match" : "unexpected";
+    }
+    if (current.type === "missing") {
+        return "missing";
+    }
+    if (expected.type !== current.type) {
+        return "drift";
+    }
+    if (expected.type === "file" && current.type === "file") {
+        return expected.sha256 === current.sha256 && expected.mode === current.mode ? "match" : "drift";
+    }
+    if (expected.type === "symlink" && current.type === "symlink") {
+        return expected.target === current.target ? "match" : "drift";
+    }
+    return expected.detail === current.detail ? "match" : "drift";
+}
+function emptyComparisonCounts() {
+    return { match: 0, drift: 0, missing: 0, unexpected: 0, unavailable: 0 };
+}
+function renderTaskReportMarkdown(report) {
+    const lines = [
+        `# Task Report: ${escapeMarkdownText(report.task.title)}`,
+        "",
+        `- Task: \`${escapeCode(report.task.id)}\``,
+        `- Status: \`${report.task.status}\``,
+        `- Mode: \`${report.task.mode}\``,
+        `- Created: ${report.task.created_at}`,
+        `- Generated: ${report.generated_at}`,
+        `- Workspace: \`${escapeCode(report.workspace.path)}\``,
+        "",
+        "## Workspace Reconciliation",
+        "",
+        `State: **${report.workspace.reconciliation.state}**. `
+            + `${report.workspace.reconciliation.integrated_waves} integrated wave(s), `
+            + `${report.workspace.reconciliation.changed_paths} changed path(s).`,
+        ""
+    ];
+    if (report.workspace.reconciliation.paths.length > 0) {
+        lines.push("| State | Path | Source | Expected | Current |", "| --- | --- | --- | --- | --- |", ...report.workspace.reconciliation.paths.map((entry) => (`| ${entry.state} | \`${escapeCode(entry.path)}\` | turn ${entry.source.turn_id}, wave ${entry.source.wave} | `
+            + `${describeReportEntry(entry.expected)} | ${describeReportEntry(entry.current)} |`)), "");
+    }
+    if (report.workspace.reconciliation.issues.length > 0) {
+        lines.push("### Reconciliation Issues", "", ...report.workspace.reconciliation.issues.map((issue) => `- ${escapeMarkdownText(issue)}`), "");
+    }
+    lines.push("## Turns", "");
+    if (report.turns.length === 0) {
+        lines.push("No valid turn records were found.", "");
+    }
+    for (const turn of report.turns) {
+        lines.push(`### Turn ${turn.turn_id}`, "", `- Created: ${turn.created_at}`, ...(turn.route ? [
+            `- Route: \`${turn.route.mode}\` via \`${turn.route.source ?? "configured"}\``,
+            `- Reason: ${escapeMarkdownText(turn.route.reason)}`
+        ] : []), "", "**Request**", "", ...(turn.request ? quoteMarkdown(turn.request) : ["> (empty)"]), "");
+        if (turn.supervisor_summary) {
+            lines.push("**Supervisor summary**", "", turn.supervisor_summary, "");
+        }
+        for (const [label, value] of [
+            ["Requirements", turn.requirements],
+            ["Plan", turn.plan],
+            ["Acceptance criteria", turn.acceptance_criteria]
+        ]) {
+            if (value) {
+                lines.push(`**${label}**`, "", value, "");
+            }
+        }
+        for (const [label, value] of [
+            ["Feature plan", turn.feature_plan],
+            ["Judge validation", turn.judge_validation],
+            ["Completion contract", turn.completion_contract],
+            ["Final acceptance", turn.final_acceptance],
+            ["Final acceptance validation", turn.final_acceptance_validation]
+        ]) {
+            if (value !== undefined) {
+                lines.push(`**${label}**`, "", fencedJson(value), "");
+            }
+        }
+    }
+    lines.push("## Features", "");
+    if (report.features.length === 0) {
+        lines.push("No Feature records were found.", "");
+    }
+    else {
+        lines.push("| State | Turn | Feature | Actor | Critic | Findings | Replies | Latest review evidence |", "| --- | --- | --- | --- | --- | ---: | ---: | --- |", ...report.features.map((feature) => (`| ${feature.state} | ${feature.turn_id} | ${escapeTableText(feature.title)} (\`${escapeCode(feature.id)}\`) | `
+            + `${escapeTableText(workerAssignment(feature.actor_engine, feature.actor_model))} | `
+            + `${escapeTableText(workerAssignment(feature.critic_engine, feature.critic_model))} | `
+            + `${feature.findings} | ${feature.replies} | `
+            + `${escapeTableText(feature.latest_finding ?? feature.latest_reply ?? "-")} |`)), "");
+    }
+    lines.push("## Integration And Verification", "");
+    if (report.integrations.length === 0) {
+        lines.push("No integrated Wave records were found.", "");
+    }
+    for (const integration of report.integrations) {
+        lines.push(`### Turn ${integration.turn_id}, Wave ${integration.wave}`, "", `- Features: ${integration.feature_ids.map((id) => `\`${escapeCode(id)}\``).join(", ") || "none"}`, `- Changed paths: ${integration.changed_paths.length}`, ...integration.changed_paths.map((path) => `  - \`${escapeCode(path)}\``), "");
+        if (integration.verification_review) {
+            lines.push("**Verification review**", "", integration.verification_review, "");
+        }
+        if (integration.verification !== undefined) {
+            lines.push("**Verification evidence**", "", fencedJson(integration.verification), "");
+        }
+    }
+    lines.push("## Workers", "");
+    if (report.workers.length === 0) {
+        lines.push("No Worker records were found.", "");
+    }
+    else {
+        lines.push("| State | Turn | Role | Engine / model | Feature | Native session | Worker | Summary |", "| --- | --- | --- | --- | --- | --- | --- | --- |", ...report.workers.map((worker) => (`| ${worker.state} | ${worker.turn_id} | ${worker.role} | `
+            + `${escapeTableText(workerAssignment(worker.engine, worker.model, worker.model_provider))} | `
+            + `${escapeTableText(worker.feature_title ?? worker.feature_id ?? "-")} | `
+            + `${escapeTableText(worker.native_session?.id ?? "-")} | \`${escapeCode(worker.id)}\` | `
+            + `${escapeTableText(worker.summary || "-")} |`)), "");
+    }
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function quoteMarkdown(value) {
+    return value.split(/\r?\n/).map((line) => `> ${line}`);
+}
+function fencedJson(value) {
+    const json = JSON.stringify(value, null, 2);
+    const longestRun = Math.max(0, ...Array.from(json.matchAll(/`+/g), (match) => match[0].length));
+    const fence = "`".repeat(Math.max(3, longestRun + 1));
+    return `${fence}json\n${json}\n${fence}`;
+}
+function describeReportEntry(entry) {
+    if (entry.type === "file") {
+        return `file ${entry.sha256?.slice(0, 12) ?? "?"} mode ${entry.mode?.toString(8) ?? "?"}`;
+    }
+    if (entry.type === "symlink") {
+        return `symlink \`${escapeCode(entry.target ?? "")}\``;
+    }
+    return entry.detail ? `${entry.type}: ${escapeTableText(entry.detail)}` : entry.type;
+}
+function workerAssignment(engine, model, provider) {
+    if (!engine) {
+        return "-";
+    }
+    const configured = [provider, model].filter(Boolean).join("/");
+    return configured ? `${engine} (${configured})` : engine;
+}
+function escapeMarkdownText(value) {
+    return value.replace(/[\\`*_{}[\]()#+.!|>-]/g, "\\$&").replace(/\r?\n/g, " ");
+}
+function escapeTableText(value) {
+    return escapeMarkdownText(value).replace(/\r?\n/g, " ");
+}
+function escapeCode(value) {
+    return value.replaceAll("`", "\\`").replace(/\r?\n/g, " ");
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string")
+        ? [...value]
+        : null;
+}
+function isMissingError(error) {
+    return ["ENOENT", "ENOTDIR"].includes(error.code ?? "");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/core/task-search.js

@@ -0,0 +1,142 @@
+export const TASK_SEARCH_FIELDS = [
+    "task",
+    "turn",
+    "feature",
+    "role",
+    "provider",
+    "model",
+    "state"
+];
+const TASK_SEARCH_FIELD_SET = new Set(TASK_SEARCH_FIELDS);
+export function parseTaskSearchQuery(query) {
+    return tokenizeTaskSearchQuery(query)
+        .map((token) => {
+        const separator = token.indexOf(":");
+        if (separator > 0) {
+            const field = normalizeTaskSearchValue(token.slice(0, separator));
+            const value = normalizeTaskSearchValue(token.slice(separator + 1));
+            if (TASK_SEARCH_FIELD_SET.has(field) && value) {
+                return { field: field, value };
+            }
+        }
+        const value = normalizeTaskSearchValue(token);
+        return value ? { field: "any", value } : null;
+    })
+        .filter((term) => term !== null);
+}
+export function matchTaskSearchDocument(query, document) {
+    const terms = typeof query === "string" ? parseTaskSearchQuery(query) : [...query];
+    if (terms.length === 0) {
+        return { fields: [], summary: "" };
+    }
+    const candidates = taskSearchCandidates(document);
+    const matches = [];
+    for (const term of terms) {
+        const match = candidates.find((candidate) => ((term.field === "any" || candidate.field === term.field)
+            && normalizeTaskSearchValue(candidate.value).includes(term.value)));
+        if (!match) {
+            return null;
+        }
+        matches.push(match);
+    }
+    const fields = [...new Set(matches
+            .map((match) => match.field)
+            .filter((field) => field !== "any"))];
+    const summaries = [...new Set(matches.map((match) => match.summary).filter(Boolean))].slice(0, 2);
+    return {
+        fields,
+        summary: summaries.length > 0 ? `match · ${summaries.join(" · ")}` : "match"
+    };
+}
+function taskSearchCandidates(document) {
+    const candidates = [
+        candidate("task", document.task.id, `task ${compactSearchEvidence(document.task.id)}`),
+        candidate("task", document.task.title, `task ${compactSearchEvidence(document.task.title)}`),
+        candidate("task", document.task.cwd, `task ${compactSearchEvidence(document.task.cwd)}`),
+        candidate("task", document.task.mode, `task ${compactSearchEvidence(document.task.mode)}`),
+        candidate("state", document.task.state, `state ${compactSearchEvidence(document.task.state)}`)
+    ];
+    for (const turn of document.turns) {
+        const label = numericTurnLabel(turn.turnId);
+        candidates.push(candidate("turn", turn.turnId, label));
+        candidates.push(candidate("turn", String(Number(turn.turnId)), label));
+        if (turn.request.trim()) {
+            candidates.push(candidate("turn", turn.request, `${label} ${compactSearchEvidence(turn.request, 72)}`));
+        }
+    }
+    for (const worker of document.workers) {
+        if (worker.featureId) {
+            candidates.push(candidate("feature", worker.featureId, `feature ${compactSearchEvidence(worker.featureTitle || worker.featureId)}`));
+        }
+        if (worker.featureTitle) {
+            candidates.push(candidate("feature", worker.featureTitle, `feature ${compactSearchEvidence(worker.featureTitle)}`));
+        }
+        candidates.push(candidate("role", worker.role, `role ${compactSearchEvidence(worker.role)}`));
+        candidates.push(candidate("provider", worker.provider, `provider ${compactSearchEvidence(worker.provider)}`));
+        if (worker.modelProvider) {
+            candidates.push(candidate("provider", worker.modelProvider, `provider ${compactSearchEvidence(worker.modelProvider)}`));
+        }
+        if (worker.model) {
+            candidates.push(candidate("model", worker.model, `model ${compactSearchEvidence(worker.model)}`));
+        }
+        candidates.push(candidate("state", worker.state, `state ${compactSearchEvidence(worker.state)}`));
+        candidates.push(candidate("any", worker.id, `worker ${compactSearchEvidence(worker.id)}`));
+        candidates.push(candidate("any", worker.phase, `phase ${compactSearchEvidence(worker.phase)}`));
+        if (worker.summary) {
+            candidates.push(candidate("any", worker.summary, `worker ${compactSearchEvidence(worker.summary, 72)}`));
+        }
+    }
+    for (const session of document.nativeSessions) {
+        candidates.push(candidate("any", session.sessionId, `session ${compactSearchEvidence(session.sessionId)}`));
+        candidates.push(candidate("provider", session.provider, `provider ${compactSearchEvidence(session.provider)}`));
+    }
+    return candidates.filter((item) => item.value.trim());
+}
+function candidate(field, value, summary) {
+    return { field, value, summary };
+}
+function tokenizeTaskSearchQuery(query) {
+    const tokens = [];
+    let current = "";
+    let quoted = false;
+    for (const character of Array.from(query).slice(0, 1000)) {
+        if (character === '"') {
+            quoted = !quoted;
+            continue;
+        }
+        if (/\s/u.test(character) && !quoted) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += character;
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function normalizeTaskSearchValue(value) {
+    return value
+        .normalize("NFKC")
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase();
+}
+function numericTurnLabel(turnId) {
+    const numeric = Number(turnId);
+    return `turn ${Number.isInteger(numeric) ? numeric : compactSearchEvidence(turnId)}`;
+}
+function compactSearchEvidence(value, maxLength = 48) {
+    const clean = value
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const points = Array.from(clean);
+    return points.length > maxLength
+        ? `${points.slice(0, Math.max(1, maxLength - 3)).join("")}...`
+        : clean;
+}