@bbigbang/core 0.1.0

package/dist/web/taskMemoryNotes.js

@@ -0,0 +1,224 @@
+import { buildThreadShortId, formatBeijingPromptTimestamp, } from '@bbigbang/protocol';
+import { channelMemoryNotePath } from './channelMemoryNotes.js';
+const WORK_LOG_PATH = 'notes/work-log/legacy.md';
+const WORK_LOG_INSTRUCTION = 'Append important completed work, decisions, and follow-ups here.';
+const CHANNEL_NOTE_INSTRUCTION = 'Durable notes and reset markers for this channel.';
+const RECENT_DURABLE_OUTCOMES_START = '<!-- recent-durable-outcomes:start -->';
+const RECENT_DURABLE_OUTCOMES_END = '<!-- recent-durable-outcomes:end -->';
+const TASK_MEMORY_AUDIT_PATH = '.bigbang/task-memory-sync-audit.md';
+const TASK_MEMORY_AUDIT_HEADER = '# Task Memory Sync Audit';
+const TASK_MEMORY_AUDIT_INSTRUCTION = 'Framework-observed task status changes are recorded here for audit/debug only. Agents remain responsible for MEMORY.md and task notes.';
+const TASK_MEMORY_SYNC_MODE_ENV = 'BIGBANG_TASK_MEMORY_SYNC_MODE';
+function isNotFoundError(error) {
+    const message = String(error?.message ?? error);
+    return message.startsWith('not_found:');
+}
+function normalizeInlineNoteText(value, fallback) {
+    const normalized = (value ?? '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return normalized || fallback;
+}
+function fallbackTaskRef(taskId) {
+    return `task_${taskId.replace(/[^a-zA-Z0-9]/g, '').toLowerCase().slice(0, 12) || 'unknown'}`;
+}
+function normalizeManagedNoteSource(content) {
+    return content.replace(/\r\n/g, '\n');
+}
+function stripLeadingManagedHeader(params) {
+    let remaining = normalizeManagedNoteSource(params.content).trim();
+    if (!remaining.startsWith(params.titleLine))
+        return remaining;
+    remaining = remaining.slice(params.titleLine.length);
+    while (true) {
+        remaining = remaining.replace(/^(?:[ \t]*\n)+/u, '');
+        if (!params.introLine || !remaining.startsWith(params.introLine))
+            break;
+        remaining = remaining.slice(params.introLine.length);
+    }
+    return remaining.trim();
+}
+function stripStandaloneInstructionLines(content, instruction) {
+    const normalized = normalizeManagedNoteSource(content).trim();
+    if (!normalized)
+        return '';
+    return normalized
+        .replace(new RegExp(`(?:^|\\n\\n)${escapeRegex(instruction)}(?=\\n\\n|$)`, 'g'), '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+function buildWorkLogEntry(snapshot) {
+    return [
+        `## ${formatBeijingPromptTimestamp(snapshot.updatedAt)} — ${snapshot.taskRef}`,
+        `- target: ${normalizeInlineNoteText(snapshot.targetLabel, snapshot.channelId)}`,
+        `- root_message: ${normalizeInlineNoteText(snapshot.rootMessage, 'No root message recorded.')}`,
+        `- key decision: Task moved to ${snapshot.status}.`,
+        `- risk / follow-up: ${normalizeInlineNoteText(snapshot.residualRisks, 'None recorded.')}`,
+        '',
+    ].join('\n');
+}
+function appendWorkLog(existingContent, snapshot) {
+    const header = '# Work Log';
+    const body = stripLeadingManagedHeader({
+        content: existingContent,
+        titleLine: header,
+        introLine: WORK_LOG_INSTRUCTION,
+    });
+    const entry = buildWorkLogEntry(snapshot).trimEnd();
+    const dedupedBody = body.replace(new RegExp(`(?:^|\\n\\n)${escapeRegex(entry)}(?=\\n\\n|$)`, 'g'), '').trim();
+    const normalizedBody = stripStandaloneInstructionLines(dedupedBody, WORK_LOG_INSTRUCTION);
+    const nextBody = [normalizedBody, entry].filter(Boolean).join('\n\n');
+    return `${header}\n\n${WORK_LOG_INSTRUCTION}\n\n${nextBody}\n`;
+}
+function upsertChannelOutcomeSection(existingContent, channelName, snapshot) {
+    const titleLine = `# Channel: #${channelName}`;
+    const header = [
+        titleLine,
+        '',
+        CHANNEL_NOTE_INSTRUCTION,
+    ].join('\n');
+    const content = normalizeManagedNoteSource(existingContent).trim();
+    const body = stripLeadingManagedHeader({
+        content,
+        titleLine,
+        introLine: CHANNEL_NOTE_INSTRUCTION,
+    });
+    const managedPattern = new RegExp(`${escapeRegex(RECENT_DURABLE_OUTCOMES_START)}[\\s\\S]*?${escapeRegex(RECENT_DURABLE_OUTCOMES_END)}\\n*`, 'g');
+    const remainder = body.replace(managedPattern, '').trim();
+    const entry = `- ${formatBeijingPromptTimestamp(snapshot.updatedAt)} ${snapshot.taskRef} [${snapshot.status}] — ${normalizeInlineNoteText(snapshot.title, 'Untitled task')}`;
+    const existingManaged = content.match(new RegExp(`${escapeRegex(RECENT_DURABLE_OUTCOMES_START)}([\\s\\S]*?)${escapeRegex(RECENT_DURABLE_OUTCOMES_END)}`));
+    const priorLines = (existingManaged?.[1] ?? '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('- '))
+        .filter((line) => !line.includes(`${snapshot.taskRef} [`));
+    const managedLines = [
+        '## Recent Durable Outcomes',
+        RECENT_DURABLE_OUTCOMES_START,
+        entry,
+        ...priorLines.slice(0, 4),
+        RECENT_DURABLE_OUTCOMES_END,
+    ];
+    const nextBody = [managedLines.join('\n'), remainder].filter(Boolean).join('\n\n');
+    return `${header}\n\n${nextBody}\n`;
+}
+function buildTaskSyncAuditEntry(snapshot) {
+    return [
+        `## ${formatBeijingPromptTimestamp(snapshot.updatedAt)} — ${snapshot.taskRef}`,
+        `- status: ${normalizeInlineNoteText(snapshot.status, 'unknown')}`,
+        `- target: ${normalizeInlineNoteText(snapshot.targetLabel, snapshot.channelId)}`,
+        `- root_message: ${normalizeInlineNoteText(snapshot.rootMessage, 'No root message recorded.')}`,
+        '- note: Framework observed this task status change in audit-only mode. The agent remains responsible for MEMORY.md, notes/tasks.md, and notes/work-log/<week>.md updates.',
+        '',
+    ].join('\n');
+}
+function appendTaskSyncAudit(existingContent, snapshot) {
+    const body = stripLeadingManagedHeader({
+        content: existingContent,
+        titleLine: TASK_MEMORY_AUDIT_HEADER,
+        introLine: TASK_MEMORY_AUDIT_INSTRUCTION,
+    });
+    const entry = buildTaskSyncAuditEntry(snapshot).trimEnd();
+    const dedupedBody = body.replace(new RegExp(`(?:^|\\n\\n)${escapeRegex(entry)}(?=\\n\\n|$)`, 'g'), '').trim();
+    const normalizedBody = stripStandaloneInstructionLines(dedupedBody, TASK_MEMORY_AUDIT_INSTRUCTION);
+    const nextBody = [normalizedBody, entry].filter(Boolean).join('\n\n');
+    return `${TASK_MEMORY_AUDIT_HEADER}\n\n${TASK_MEMORY_AUDIT_INSTRUCTION}\n\n${nextBody}\n`;
+}
+function normalizeTaskDurableNoteSyncMode(value) {
+    const normalized = (value ?? '').trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (normalized === 'legacy_memory' || normalized === 'legacy' || normalized === 'memory') {
+        return 'legacy_memory';
+    }
+    if (normalized === 'audit_only' || normalized === 'audit') {
+        return 'audit_only';
+    }
+    if (normalized === 'disabled' || normalized === 'off' || normalized === 'none') {
+        return 'disabled';
+    }
+    return null;
+}
+export function resolveTaskDurableNoteSyncMode(value) {
+    return normalizeTaskDurableNoteSyncMode(value) ?? 'audit_only';
+}
+function escapeRegex(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+async function readOptionalFile(broker, agent, relativePath, options) {
+    if (!agent.nodeId || !agent.workspacePath)
+        return '';
+    try {
+        const existing = await broker.readFile(agent.nodeId, agent.workspacePath, relativePath, options);
+        return existing.content;
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return '';
+        throw error;
+    }
+}
+function loadTaskMemorySnapshot(db, taskId) {
+    const row = db.prepare(`SELECT t.task_id as taskId,
+            t.agent_task_ref as taskRef,
+            t.title,
+            t.status,
+            t.channel_id as channelId,
+            t.updated_at as updatedAt,
+            t.message_id as messageId,
+            COALESCE(t.dm_target, cm.target) as messageTarget,
+            cm.content as rootMessageContent,
+            c.name as channelName
+     FROM tasks t
+     LEFT JOIN channel_messages cm ON cm.message_id = t.message_id
+     LEFT JOIN channels c ON c.channel_id = t.channel_id
+     WHERE t.task_id = ?
+     LIMIT 1`).get(taskId);
+    if (!row)
+        return null;
+    const targetLabel = row.messageId && row.messageTarget
+        ? `${row.messageTarget}:${buildThreadShortId(row.messageId)}`
+        : row.messageTarget ?? (row.channelName ? `#${row.channelName}` : row.channelId);
+    return {
+        taskId: row.taskId,
+        taskRef: row.taskRef ?? fallbackTaskRef(row.taskId),
+        title: row.title,
+        status: row.status,
+        channelId: row.channelId,
+        channelName: row.channelName,
+        messageId: row.messageId,
+        messageTarget: row.messageTarget,
+        targetLabel,
+        updatedAt: row.updatedAt,
+        rootMessage: row.rootMessageContent?.trim() || null,
+        residualRisks: row.status === 'in_review' ? 'Awaiting human review or approval.' : 'None recorded.',
+    };
+}
+export async function syncTaskDurableNotesForAgent(params) {
+    const { db, broker, agent, taskId } = params;
+    if (!agent?.nodeId || !agent.workspacePath)
+        return;
+    const snapshot = loadTaskMemorySnapshot(db, taskId);
+    if (!snapshot)
+        return;
+    const mode = resolveTaskDurableNoteSyncMode(params.mode ?? process.env[TASK_MEMORY_SYNC_MODE_ENV]);
+    if (mode === 'disabled')
+        return;
+    if (mode === 'audit_only') {
+        const auditContent = await readOptionalFile(broker, agent, TASK_MEMORY_AUDIT_PATH, { scaffold: false });
+        await broker.writeFile(agent.nodeId, agent.workspacePath, TASK_MEMORY_AUDIT_PATH, appendTaskSyncAudit(auditContent, snapshot), 'overwrite', { scaffold: false });
+        return;
+    }
+    // legacy_memory keeps the previous framework-managed durable-note behavior
+    // as an optional fallback during migration. The agent remains responsible for
+    // MEMORY.md and notes/tasks.md in all modes.
+    if (snapshot.status === 'done') {
+        const workLogContent = await readOptionalFile(broker, agent, WORK_LOG_PATH);
+        await broker.writeFile(agent.nodeId, agent.workspacePath, WORK_LOG_PATH, appendWorkLog(workLogContent, snapshot), 'overwrite');
+    }
+    if (snapshot.channelName && !snapshot.channelId.startsWith('dm:')) {
+        const channelNotePath = channelMemoryNotePath(snapshot.channelName);
+        const channelContent = await readOptionalFile(broker, agent, channelNotePath);
+        await broker.writeFile(agent.nodeId, agent.workspacePath, channelNotePath, upsertChannelOutcomeSection(channelContent, snapshot.channelName, snapshot), 'overwrite');
+    }
+}

package/dist/web/taskNumbers.js

@@ -0,0 +1,16 @@
+export function allocateNextTaskNumber(db, channelId) {
+    db.prepare(`INSERT INTO channel_task_sequences(channel_id, next_task_number)
+     VALUES(
+       ?,
+       COALESCE((SELECT MAX(task_number) FROM tasks WHERE channel_id = ?), 0) + 1
+     )
+     ON CONFLICT(channel_id) DO NOTHING`).run(channelId, channelId);
+    const row = db.prepare(`UPDATE channel_task_sequences
+     SET next_task_number = next_task_number + 1
+     WHERE channel_id = ?
+     RETURNING next_task_number - 1 as taskNumber`).get(channelId);
+    if (!row) {
+        throw new Error(`Failed to allocate task number for channel ${channelId}`);
+    }
+    return row.taskNumber;
+}

package/dist/web/taskOwnerGuards.js

@@ -0,0 +1,49 @@
+/**
+ * 返回 task 的当前 owner agent id。
+ * 权威源为 `task_participants.participant_role='owner'`；若缺则回落到 `tasks.claimed_by_agent_id`。
+ */
+export function loadTaskOwnerAgentId(db, taskId) {
+    if (!taskId)
+        return null;
+    const participantRow = db
+        .prepare(`SELECT agent_id AS agentId FROM task_participants
+       WHERE task_id = ? AND participant_role = 'owner'
+       LIMIT 1`)
+        .get(taskId);
+    if (participantRow?.agentId)
+        return participantRow.agentId;
+    const taskRow = db
+        .prepare(`SELECT claimed_by_agent_id AS claimedByAgentId FROM tasks WHERE task_id = ? LIMIT 1`)
+        .get(taskId);
+    const fallback = taskRow?.claimedByAgentId?.trim();
+    return fallback ? fallback : null;
+}
+export function isAgentTaskOwner(db, taskId, agentId) {
+    if (!taskId || !agentId)
+        return false;
+    return loadTaskOwnerAgentId(db, taskId) === agentId;
+}
+/**
+ * 构造 agent 端 "非 owner 不得修改 task" 拒绝响应。
+ * 调用方：reply.code(denial.status); return denial.body;
+ */
+export function buildAgentTaskOwnerDenial(params) {
+    const taskNumber = typeof params.taskNumber === 'number' && Number.isFinite(params.taskNumber)
+        ? params.taskNumber
+        : null;
+    const label = taskNumber !== null ? `#${taskNumber}` : `task ${params.taskId}`;
+    return {
+        status: 403,
+        body: {
+            error: `Only the task owner can modify ${label}. Ask the owner or user to change the task instead.`,
+            error_code: 'task_owner_required',
+            required_action: 'ask_owner_or_user',
+            source_target: params.sourceTarget ?? null,
+            requested_target: {
+                type: 'task',
+                taskId: params.taskId,
+                taskNumber,
+            },
+        },
+    };
+}

package/dist/web/taskParticipantResolver.js

@@ -0,0 +1,42 @@
+import { MAX_TASK_PARTICIPANTS, replaceTaskParticipants, } from './taskParticipants.js';
+/**
+ * Single entry point for all task participant writes.
+ *
+ * Enforces MAX_TASK_PARTICIPANTS (1 owner + bounded collaborators).
+ * Handles owner change preservation, collaborator merging, deduplication,
+ * and empty-list clearing.
+ */
+export function resolveTaskParticipants(db, params) {
+    const ownerId = params.ownerAgentId?.trim() || null;
+    // Normalize and deduplicate incoming collaborator IDs, excluding owner
+    const incomingCollaboratorIds = Array.from(new Set((params.collaboratorAgentIds ?? [])
+        .map((id) => (typeof id === 'string' ? id.trim() : ''))
+        .filter((id) => id.length > 0 && id !== ownerId)));
+    // Load existing participants when preserving
+    let existingCollaboratorIds = [];
+    if (params.preserveExistingCollaborators) {
+        const rows = db.prepare(`SELECT agent_id as agentId
+       FROM task_participants
+       WHERE task_id = ?
+         AND participant_role = 'collaborator'`).all(params.taskId);
+        existingCollaboratorIds = rows
+            .map((r) => r.agentId)
+            .filter((id) => id && id !== ownerId);
+    }
+    // Merge: existing + incoming, deduplicated
+    const collaboratorAgentIds = params.preserveExistingCollaborators
+        ? Array.from(new Set([...existingCollaboratorIds, ...incomingCollaboratorIds]))
+        : incomingCollaboratorIds;
+    // M9 enforcement: bounded collaborators plus owner.
+    if (collaboratorAgentIds.length > MAX_TASK_PARTICIPANTS - 1) {
+        throw new Error(`Too many collaborators (max ${MAX_TASK_PARTICIPANTS - 1}, plus owner = ${MAX_TASK_PARTICIPANTS} total)`);
+    }
+    // Write to DB via replaceTaskParticipants
+    replaceTaskParticipants(db, {
+        taskId: params.taskId,
+        ownerAgentId: ownerId,
+        collaboratorAgentIds,
+        updatedAt: params.updatedAt,
+    });
+    return { ownerId, collaboratorAgentIds };
+}

package/dist/web/taskParticipants.js

@@ -0,0 +1,97 @@
+/** Maximum number of task participants (1 owner + up to 19 collaborators = 20 total). */
+export const MAX_TASK_PARTICIPANTS = 20;
+export function upsertTaskParticipant(db, params) {
+    const agentId = params.agentId?.trim();
+    if (!agentId)
+        return;
+    const updatedAt = params.updatedAt ?? Date.now();
+    db.prepare(`INSERT INTO task_participants(
+       task_id,
+       agent_id,
+       participant_role,
+       joined_at,
+       last_updated_at
+     )
+     VALUES(?, ?, ?, ?, ?)
+     ON CONFLICT(task_id, agent_id) DO UPDATE SET
+       participant_role = CASE
+         WHEN excluded.participant_role = 'owner' THEN 'owner'
+         ELSE task_participants.participant_role
+       END,
+       joined_at = MIN(task_participants.joined_at, excluded.joined_at),
+       last_updated_at = MAX(task_participants.last_updated_at, excluded.last_updated_at)`).run(params.taskId, agentId, params.role, updatedAt, updatedAt);
+}
+export function listTaskCollaboratorAgentIds(db, params) {
+    const rows = db.prepare(`SELECT agent_id as agentId
+       FROM task_participants
+      WHERE task_id = ?
+        AND participant_role = 'collaborator'
+      ORDER BY last_updated_at ASC, agent_id ASC`).all(params.taskId);
+    return rows
+        .map((row) => row.agentId?.trim() ?? '')
+        .filter((agentId) => agentId.length > 0);
+}
+export function captureTaskParticipantSnapshot(db, params) {
+    const row = db.prepare(`SELECT participant_role as participantRole,
+            joined_at as joinedAt,
+            last_updated_at as lastUpdatedAt
+       FROM task_participants
+      WHERE task_id = ? AND agent_id = ?
+      LIMIT 1`).get(params.taskId, params.agentId);
+    return row ? { exists: true, ...row } : { exists: false };
+}
+export function restoreTaskParticipantSnapshot(db, params) {
+    if (!params.snapshot.exists) {
+        db.prepare(`DELETE FROM task_participants
+        WHERE task_id = ? AND agent_id = ?`).run(params.taskId, params.agentId);
+        return;
+    }
+    db.prepare(`INSERT INTO task_participants(
+       task_id,
+       agent_id,
+       participant_role,
+       joined_at,
+       last_updated_at
+     )
+     VALUES(?, ?, ?, ?, ?)
+     ON CONFLICT(task_id, agent_id) DO UPDATE SET
+       participant_role = excluded.participant_role,
+       joined_at = excluded.joined_at,
+       last_updated_at = excluded.last_updated_at`).run(params.taskId, params.agentId, params.snapshot.participantRole, params.snapshot.joinedAt, params.snapshot.lastUpdatedAt);
+}
+export function clearTaskParticipants(db, params) {
+    db.prepare(`DELETE FROM task_participants WHERE task_id = ?`).run(params.taskId);
+}
+export function removeTaskParticipant(db, params) {
+    const agentId = params.agentId?.trim();
+    if (!agentId)
+        return;
+    // Shared-task unclaim only removes the releasing owner. Collaborators stay visible
+    // so the shared task can still be discovered and potentially re-owned.
+    db.prepare(`DELETE FROM task_participants
+     WHERE task_id = ? AND agent_id = ?`).run(params.taskId, agentId);
+}
+export function replaceTaskParticipants(db, params) {
+    clearTaskParticipants(db, { taskId: params.taskId });
+    const ownerAgentId = params.ownerAgentId?.trim() ?? null;
+    const collaboratorAgentIds = Array.from(new Set((params.collaboratorAgentIds ?? [])
+        .map((agentId) => agentId?.trim() ?? '')
+        .filter((agentId) => agentId && agentId !== ownerAgentId)));
+    const updatedAt = params.updatedAt ?? Date.now();
+    if (ownerAgentId) {
+        upsertTaskParticipant(db, {
+            taskId: params.taskId,
+            agentId: ownerAgentId,
+            role: 'owner',
+            updatedAt,
+        });
+    }
+    for (const collaboratorAgentId of collaboratorAgentIds) {
+        upsertTaskParticipant(db, {
+            taskId: params.taskId,
+            agentId: collaboratorAgentId,
+            role: 'collaborator',
+            updatedAt,
+        });
+    }
+}

package/dist/web/taskSourceDetails.js

@@ -0,0 +1,20 @@
+const SOURCE_MESSAGE_SECTION_LABEL = 'Source message:';
+function normalizeForSourceComparison(value) {
+    return (value ?? '').replace(/\s+/g, ' ').trim();
+}
+export function appendTaskSourceMessageToDescription(params) {
+    const description = params.description.trim();
+    const sourceMessage = params.sourceMessage?.trim();
+    if (!sourceMessage)
+        return description;
+    const normalizedSource = normalizeForSourceComparison(sourceMessage);
+    if (!normalizedSource)
+        return description;
+    if (normalizeForSourceComparison(params.title) === normalizedSource)
+        return description;
+    if (normalizeForSourceComparison(description).includes(normalizedSource))
+        return description;
+    return description
+        ? `${description}\n\n${SOURCE_MESSAGE_SECTION_LABEL}\n${sourceMessage}`
+        : `${SOURCE_MESSAGE_SECTION_LABEL}\n${sourceMessage}`;
+}

package/dist/web/taskStateViews.js

@@ -0,0 +1,210 @@
+import { buildThreadShortId } from '@bbigbang/protocol';
+import { isClearedTaskRootTarget } from './clearedTaskRoots.js';
+export function listVisibleTasksForAgent(db, agentId, options) {
+    const requestedStatus = options?.status ?? 'all';
+    const requestedScope = options?.scope ?? 'all';
+    const params = [agentId, agentId, agentId];
+    const conditions = ['(t.claimed_by_agent_id = ? OR tp.agent_id = ?)'];
+    if (requestedStatus !== 'all') {
+        conditions.push('t.status = ?');
+        params.push(requestedStatus);
+    }
+    if (requestedScope === 'dm') {
+        conditions.push(`t.channel_id LIKE 'dm:%'`);
+    }
+    else if (requestedScope === 'channel') {
+        conditions.push(`t.channel_id NOT LIKE 'dm:%'`);
+    }
+    const rows = db.prepare(`${VISIBLE_TASK_SELECT}
+     ${VISIBLE_TASK_FROM}
+     WHERE ${conditions.join(' AND ')}
+     ORDER BY t.updated_at DESC, t.created_at DESC`).all(...params);
+    return rows.map(toVisibleTaskView);
+}
+export function getVisibleTaskLookupByRef(db, agentId, taskRef) {
+    const row = db.prepare(`${VISIBLE_TASK_SELECT}
+     ${VISIBLE_TASK_FROM}
+     WHERE t.agent_task_ref = ?
+       AND (t.claimed_by_agent_id = ? OR tp.agent_id = ?)
+     LIMIT 1`).get(agentId, taskRef, agentId, agentId);
+    if (!row)
+        return null;
+    return {
+        record: row,
+        task: toVisibleTaskView(row),
+    };
+}
+export function getDeletedTaskLookupByRef(db, agentId, taskRef) {
+    const row = db.prepare(`SELECT dt.task_id as taskId,
+            dt.agent_task_ref as agentTaskRef,
+            dt.channel_id as channelId,
+            dt.channel_name as channelName,
+            dt.task_number as taskNumber,
+            dt.title,
+            dt.description,
+            dt.status,
+            dt.claimed_by_name as claimedByName,
+            dt.created_by_name as createdByName,
+            dt.message_id as messageId,
+            dt.source_target as sourceTarget,
+            dt.thread_root_id as threadRootId,
+            dt.deleted_by_name as deletedByName,
+            dt.created_at as createdAt,
+            dt.updated_at as updatedAt,
+            dt.deleted_at as deletedAt
+       FROM deleted_tasks dt
+      WHERE dt.agent_task_ref = ?
+        AND (
+          dt.claimed_by_agent_id = ?
+          OR EXISTS (
+            SELECT 1
+              FROM deleted_task_participants dtp
+             WHERE dtp.task_id = dt.task_id
+               AND dtp.agent_id = ?
+          )
+        )
+      LIMIT 1`).get(taskRef, agentId, agentId);
+    if (!row)
+        return null;
+    return {
+        record: row,
+        deletedTask: toDeletedTaskView(row),
+    };
+}
+export function listTaskHistoryEventViews(db, taskId, limit) {
+    const rows = db.prepare(`SELECT event_id as eventId,
+            event_type as eventType,
+            actor_type as actorType,
+            actor_id as actorId,
+            actor_name as actorName,
+            from_status as fromStatus,
+            to_status as toStatus,
+            claimed_by_agent_id_after as claimedByAgentIdAfter,
+            claimed_by_name_after as claimedByNameAfter,
+            message_id as messageId,
+            thread_target as threadTarget,
+            created_at as createdAt
+       FROM task_events
+      WHERE task_id = ?
+      ORDER BY created_at DESC
+      LIMIT ?`).all(taskId, limit);
+    return rows.map((row) => ({
+        eventId: row.eventId,
+        type: row.eventType,
+        actorType: row.actorType,
+        actorId: row.actorId,
+        actorName: row.actorName,
+        fromStatus: row.fromStatus,
+        toStatus: row.toStatus,
+        claimedByAgentIdAfter: row.claimedByAgentIdAfter,
+        claimedByNameAfter: row.claimedByNameAfter,
+        messageId: row.messageId,
+        threadTarget: row.threadTarget,
+        createdAt: new Date(row.createdAt).toISOString(),
+    }));
+}
+export function buildTaskSourceTarget(channelId, sourceTarget, channelName) {
+    if (isClearedTaskRootTarget(sourceTarget))
+        return channelId.startsWith('dm:') ? null : `#${channelName ?? channelId}`;
+    if (sourceTarget?.trim())
+        return sourceTarget.trim();
+    if (channelId.startsWith('dm:'))
+        return null;
+    return `#${channelName ?? channelId}`;
+}
+export function buildTaskSourceLabel(channelId, sourceTarget, channelName) {
+    if (sourceTarget?.startsWith('dm:@'))
+        return sourceTarget;
+    if (channelName)
+        return `#${channelName}`;
+    if (channelId.startsWith('dm:'))
+        return 'DM';
+    if (sourceTarget?.trim())
+        return sourceTarget.trim();
+    return channelId;
+}
+export function buildTaskThreadTarget(sourceTarget, messageId) {
+    if (!sourceTarget || !messageId)
+        return null;
+    const normalizedTarget = sourceTarget.trim();
+    if (!(normalizedTarget.startsWith('dm:@') || normalizedTarget.startsWith('#')))
+        return null;
+    if (isThreadTargetValue(normalizedTarget))
+        return normalizedTarget;
+    return `${normalizedTarget}:${buildThreadShortId(messageId)}`;
+}
+const VISIBLE_TASK_SELECT = `SELECT t.task_id as taskId,
+              t.agent_task_ref as agentTaskRef,
+              t.channel_id as channelId,
+              t.task_number as taskNumber,
+              t.title,
+              t.description,
+              t.status,
+              t.claimed_by_agent_id as claimedByAgentId,
+              t.claimed_by_name as claimedByName,
+              t.created_by_agent_id as createdByAgentId,
+              t.created_by_name as createdByName,
+              t.created_at as createdAt,
+              t.updated_at as updatedAt,
+              t.message_id as messageId,
+              COALESCE(t.dm_target, cm.target) as sourceTarget,
+              ch.name as channelName`;
+const VISIBLE_TASK_FROM = `FROM tasks t
+       LEFT JOIN task_participants tp
+              ON tp.task_id = t.task_id
+             AND tp.agent_id = ?
+       LEFT JOIN channel_messages cm
+              ON cm.message_id = t.message_id
+       LEFT JOIN channels ch
+              ON ch.channel_id = t.channel_id`;
+function toVisibleTaskView(row) {
+    const sourceTarget = buildTaskSourceTarget(row.channelId, row.sourceTarget, row.channelName);
+    return {
+        taskId: row.taskId,
+        agentTaskRef: row.agentTaskRef,
+        channelId: row.channelId,
+        taskNumber: row.taskNumber,
+        title: row.title,
+        description: row.description ?? null,
+        status: row.status,
+        claimedByName: row.claimedByName ?? null,
+        createdByName: row.createdByName ?? null,
+        messageId: row.messageId ?? null,
+        sourceTarget,
+        sourceLabel: buildTaskSourceLabel(row.channelId, sourceTarget, row.channelName),
+        threadTarget: buildTaskThreadTarget(sourceTarget, row.messageId ?? null),
+        createdAt: new Date(row.createdAt).toISOString(),
+        updatedAt: new Date(row.updatedAt).toISOString(),
+    };
+}
+function toDeletedTaskView(row) {
+    const sourceTarget = buildTaskSourceTarget(row.channelId, row.sourceTarget, row.channelName);
+    const threadTarget = row.threadRootId && sourceTarget ? `${sourceTarget}:${row.threadRootId}` : null;
+    return {
+        deleted: true,
+        taskId: row.taskId,
+        agentTaskRef: row.agentTaskRef,
+        channelId: row.channelId,
+        taskNumber: row.taskNumber,
+        title: row.title,
+        description: row.description ?? null,
+        status: row.status,
+        claimedByName: row.claimedByName ?? null,
+        createdByName: row.createdByName ?? null,
+        messageId: row.messageId ?? null,
+        sourceTarget,
+        sourceLabel: buildTaskSourceLabel(row.channelId, sourceTarget, row.channelName),
+        threadTarget,
+        deletedByName: row.deletedByName ?? null,
+        createdAt: new Date(row.createdAt).toISOString(),
+        updatedAt: new Date(row.updatedAt).toISOString(),
+        deletedAt: new Date(row.deletedAt).toISOString(),
+    };
+}
+function isThreadTargetValue(target) {
+    if (target.startsWith('dm:@'))
+        return target.split(':').length >= 3;
+    if (target.startsWith('#'))
+        return target.includes(':');
+    return false;
+}

package/dist/web/taskStatusTransitions.js

@@ -0,0 +1,9 @@
+const VALID_TRANSITIONS = {
+    todo: ['in_progress'],
+    in_progress: ['in_review'],
+    in_review: ['done', 'in_progress'],
+    done: [],
+};
+export function isValidTransition(from, to) {
+    return VALID_TRANSITIONS[from]?.includes(to) ?? false;
+}