@minionry/minion 0.7.36

package/dist/server/services/websocket/plan-sprint-handlers.js

@@ -0,0 +1,190 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFrontMatterField } from '../plan/front-matter.js';
+import { defaultPmDir, getNextSprintId, parsePlanDirectory, parseSingleSprint, parseSprintArtifacts, resolvePmDir } from '../plan/parser.js';
+import { denyIfViewOnly, resolvePlanPath } from './plan-helpers.js';
+function buildSprintMarkdown(id, title, goal, start, end, issueRefs) {
+    const issuesYaml = issueRefs.length > 0
+        ? `\n${issueRefs.map(p => `  - ${p}`).join('\n')}`
+        : ' []';
+    return `---
+id: ${id}
+title: "${title.replace(/"/g, '\\"')}"
+status: planned
+start: "${start}"
+end: "${end}"
+goal: "${goal.replace(/"/g, '\\"')}"
+capacity: null
+committed: null
+completed: null
+completed_at: null
+issues:${issuesYaml}
+---
+
+# ${id}: ${title}
+
+## Sprint Goal
+${goal}
+
+## Issues
+| Issue | Title | Points | Status |
+|---|---|---|---|
+`;
+}
+function assignIssuesToSprint(workingDir, issues, issueIds, sprintPath) {
+    for (const issueId of issueIds) {
+        const issue = issues.find(i => i.id === issueId);
+        if (!issue)
+            continue;
+        const fullPath = resolvePlanPath(workingDir, issue.path);
+        if (!fullPath || !existsSync(fullPath))
+            continue;
+        const content = replaceFrontMatterField(readFileSync(fullPath, 'utf-8'), 'sprint', sprintPath);
+        writeFileSync(fullPath, content, 'utf-8');
+    }
+}
+export function handleCreateSprint(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const { title, goal = '', start = '', end = '', issueIds = [] } = msg.data || {};
+    if (!title) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Sprint title required' } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir) ?? defaultPmDir(workingDir);
+    const sprintsDir = join(pmDir, 'sprints');
+    if (!existsSync(sprintsDir))
+        mkdirSync(sprintsDir, { recursive: true });
+    const fullState = parsePlanDirectory(workingDir);
+    const id = fullState ? getNextSprintId(fullState.sprints) : 'SPRINT-001';
+    const issueRefs = issueIds.map((issueId) => {
+        const issue = fullState?.issues.find(i => i.id === issueId);
+        return issue ? issue.path : `backlog/${issueId}.md`;
+    });
+    writeFileSync(join(sprintsDir, `${id}.md`), buildSprintMarkdown(id, title, goal, start, end, issueRefs), 'utf-8');
+    const sandboxDir = join(sprintsDir, id);
+    mkdirSync(join(sandboxDir, 'out'), { recursive: true });
+    mkdirSync(join(sandboxDir, 'reviews'), { recursive: true });
+    writeFileSync(join(sandboxDir, 'progress.md'), `# ${id}: ${title} — Progress Log\n`, 'utf-8');
+    if (issueRefs.length > 0 && fullState) {
+        assignIssuesToSprint(workingDir, fullState.issues, issueIds, `sprints/${id}.md`);
+    }
+    const sprint = parseSingleSprint(workingDir, `sprints/${id}.md`);
+    ctx.broadcastToAll({ type: 'planSprintCreated', data: sprint });
+}
+function promoteSprintIssues(_pmDir, _sprint, _allIssues) {
+}
+function updateFileField(filePath, field, value) {
+    if (!existsSync(filePath))
+        return;
+    writeFileSync(filePath, replaceFrontMatterField(readFileSync(filePath, 'utf-8'), field, value), 'utf-8');
+}
+export function handleActivateSprint(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const sprintId = msg.data?.sprintId;
+    if (!sprintId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Sprint ID required' } });
+        return;
+    }
+    const fullState = parsePlanDirectory(workingDir);
+    if (!fullState) {
+        ctx.send(ws, { type: 'planError', data: { error: 'No project found' } });
+        return;
+    }
+    const currentActive = fullState.sprints.find(s => s.status === 'active');
+    if (currentActive && currentActive.id !== sprintId) {
+        ctx.send(ws, { type: 'planError', data: { error: `Sprint ${currentActive.id} is already active. Complete it first.` } });
+        return;
+    }
+    const sprint = fullState.sprints.find(s => s.id === sprintId);
+    if (!sprint) {
+        ctx.send(ws, { type: 'planError', data: { error: `Sprint not found: ${sprintId}` } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    updateFileField(join(pmDir, sprint.path), 'status', 'active');
+    updateFileField(join(pmDir, 'STATE.md'), 'current_sprint', `"${sprint.path}"`);
+    promoteSprintIssues(pmDir, sprint, fullState.issues);
+    const updatedSprint = parseSingleSprint(workingDir, sprint.path);
+    ctx.broadcastToAll({ type: 'planSprintUpdated', data: updatedSprint });
+    const updatedState = parsePlanDirectory(workingDir);
+    if (updatedState) {
+        ctx.broadcastToAll({ type: 'planStateUpdated', data: updatedState });
+    }
+}
+export function handleCompleteSprint(ctx, ws, msg, workingDir, permission) {
+    if (denyIfViewOnly(ctx, ws, permission))
+        return;
+    const sprintId = msg.data?.sprintId;
+    if (!sprintId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Sprint ID required' } });
+        return;
+    }
+    const fullState = parsePlanDirectory(workingDir);
+    if (!fullState) {
+        ctx.send(ws, { type: 'planError', data: { error: 'No project found' } });
+        return;
+    }
+    const sprint = fullState.sprints.find(s => s.id === sprintId);
+    if (!sprint) {
+        ctx.send(ws, { type: 'planError', data: { error: `Sprint not found: ${sprintId}` } });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    const now = new Date().toISOString();
+    const sprintIssues = fullState.issues.filter(i => i.sprint === sprint.path);
+    const completedIssues = sprintIssues.filter(i => i.status === 'done').length;
+    const failedIssues = sprintIssues.filter(i => i.status !== 'done' && i.status !== 'cancelled').length;
+    const sprintPath = join(pmDir, sprint.path);
+    if (existsSync(sprintPath)) {
+        let content = readFileSync(sprintPath, 'utf-8');
+        content = replaceFrontMatterField(content, 'status', 'completed');
+        content = replaceFrontMatterField(content, 'completed_at', `"${now}"`);
+        content = replaceFrontMatterField(content, 'completed', String(completedIssues));
+        if (!content.includes('execution_summary:')) {
+            const summaryYaml = [
+                'execution_summary:',
+                `  total_issues: ${sprintIssues.length}`,
+                `  completed_issues: ${completedIssues}`,
+                `  failed_issues: ${failedIssues}`,
+            ].join('\n');
+            const fmClose = content.indexOf('\n---', content.indexOf('---') + 3);
+            if (fmClose !== -1) {
+                content = `${content.slice(0, fmClose)}\n${summaryYaml}${content.slice(fmClose)}`;
+            }
+        }
+        writeFileSync(sprintPath, content, 'utf-8');
+    }
+    const statePath = join(pmDir, 'STATE.md');
+    if (existsSync(statePath)) {
+        let stateContent = readFileSync(statePath, 'utf-8');
+        stateContent = replaceFrontMatterField(stateContent, 'current_sprint', 'null');
+        writeFileSync(statePath, stateContent, 'utf-8');
+    }
+    const updatedSprint = parseSingleSprint(workingDir, sprint.path);
+    ctx.broadcastToAll({ type: 'planSprintCompleted', data: updatedSprint });
+    const updatedState = parsePlanDirectory(workingDir);
+    if (updatedState) {
+        ctx.broadcastToAll({ type: 'planStateUpdated', data: updatedState });
+    }
+}
+export function handleGetSprintArtifacts(ctx, ws, msg, workingDir) {
+    const sprintId = msg.data?.sprintId;
+    if (!sprintId) {
+        ctx.send(ws, { type: 'planError', data: { error: 'Sprint ID required' } });
+        return;
+    }
+    const artifacts = parseSprintArtifacts(workingDir, sprintId);
+    if (!artifacts) {
+        ctx.send(ws, { type: 'planSprintArtifacts', data: { sprintId, progressLog: '', outputFiles: [], reviewResults: [] } });
+        return;
+    }
+    ctx.send(ws, { type: 'planSprintArtifacts', data: artifacts });
+}

package/dist/server/services/websocket/plan-transfer-handlers.js

@@ -0,0 +1,310 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { validatePathWithinWorkingDir } from '../pathUtils.js';
+import { defaultArchiveFileName, extractBoardArchive, packBoardArchive } from '../plan/board-archive.js';
+import { replaceFrontMatterField } from '../plan/front-matter.js';
+import { getNextBoardId, NO_SPECS_DIR_ERROR, parseBoardDirectory, parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
+import { parseFrontMatter } from '../plan/parser-core.js';
+import { instantiateTemplate, parseTemplate, validateTemplate } from '../plan/template-instantiator.js';
+import { SPACE_DIRNAME, SPACE_LAYOUT } from '../space-layout.js';
+import { isPathInSafeLocation } from './file-utils.js';
+import { formatYamlValue } from './plan-helpers.js';
+const MAX_DOWNLOAD_ZIP_BYTES = 10 * 1024 * 1024;
+const MAX_IMPORT_ZIP_BYTES = 50 * 1024 * 1024;
+const TMP_IMPORT_PREFIX = join(SPACE_DIRNAME, SPACE_LAYOUT.tmp, 'specs-imports');
+const LEGACY_TMP_IMPORT_PREFIX = join(SPACE_DIRNAME, SPACE_LAYOUT.tmp, 'pm-imports');
+function expandHome(path) {
+    if (path === '~')
+        return homedir();
+    if (path.startsWith('~/'))
+        return join(homedir(), path.slice(2));
+    return path;
+}
+function resolveAllowedPath(rawPath, workingDir) {
+    const expanded = expandHome(rawPath.trim());
+    if (expanded.includes('\0'))
+        return { error: 'Invalid path' };
+    const resolved = isAbsolute(expanded) ? resolve(expanded) : resolve(workingDir, expanded);
+    if (isPathInSafeLocation(resolved))
+        return { path: resolved };
+    const validation = validatePathWithinWorkingDir(resolved, workingDir);
+    if (validation.valid)
+        return { path: validation.resolvedPath };
+    return { error: 'Access denied: path must be inside the Space directory or a safe location (Desktop, Documents, Downloads, Pictures, tmp)' };
+}
+export function handleExportBoard(ctx, ws, msg, workingDir, permission) {
+    const { boardId, targetDir, fileName, requestId } = (msg.data || {});
+    const reply = (data) => ctx.send(ws, { type: 'planBoardExported', data: { requestId, boardId, ...data } });
+    if (permission === 'view') {
+        reply({ success: false, error: 'Permission denied' });
+        return;
+    }
+    if (!boardId || !requestId) {
+        reply({ success: false, error: 'boardId and requestId required' });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        reply({ success: false, error: NO_SPECS_DIR_ERROR });
+        return;
+    }
+    try {
+        const rawName = (fileName || '').trim();
+        if (!rawName) {
+            reply({ success: false, error: 'File name required' });
+            return;
+        }
+        if (/[/\\]/.test(rawName) || rawName.includes('\0') || rawName === '.' || rawName === '..') {
+            reply({ success: false, error: 'File name must not contain path separators' });
+            return;
+        }
+        const finalName = rawName.toLowerCase().endsWith('.zip') ? rawName : `${rawName}.zip`;
+        const dirResult = resolveAllowedPath(targetDir?.trim() || workingDir, workingDir);
+        if ('error' in dirResult) {
+            reply({ success: false, error: dirResult.error });
+            return;
+        }
+        const { data } = packBoardArchive(pmDir, boardId);
+        mkdirSync(dirResult.path, { recursive: true });
+        const outPath = join(dirResult.path, finalName);
+        writeFileSync(outPath, data);
+        reply({ success: true, path: outPath });
+    }
+    catch (error) {
+        reply({ success: false, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+export function handleDownloadBoard(ctx, ws, msg, workingDir) {
+    const { boardId, requestId } = (msg.data || {});
+    const reply = (data) => ctx.send(ws, { type: 'planBoardDownloaded', data: { requestId, boardId, ...data } });
+    if (!boardId || !requestId) {
+        reply({ success: false, error: 'boardId and requestId required' });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        reply({ success: false, error: NO_SPECS_DIR_ERROR });
+        return;
+    }
+    try {
+        const { data, board } = packBoardArchive(pmDir, boardId);
+        if (data.byteLength > MAX_DOWNLOAD_ZIP_BYTES) {
+            reply({ success: false, error: 'Board archive exceeds the 10 MB download limit' });
+            return;
+        }
+        reply({ success: true, fileName: defaultArchiveFileName(board), contentBase64: data.toString('base64') });
+    }
+    catch (error) {
+        reply({ success: false, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+export function handleImportBoard(ctx, ws, msg, workingDir, permission) {
+    const { sourcePath, requestId } = (msg.data || {});
+    const reply = (data) => ctx.send(ws, { type: 'planBoardImported', data: { requestId, ...data } });
+    if (permission === 'view') {
+        reply({ success: false, error: 'Permission denied' });
+        return;
+    }
+    if (!sourcePath || !requestId) {
+        reply({ success: false, error: 'sourcePath and requestId required' });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        reply({ success: false, error: NO_SPECS_DIR_ERROR });
+        return;
+    }
+    try {
+        const srcResult = resolveImportSource(sourcePath, workingDir);
+        if ('error' in srcResult) {
+            reply({ success: false, error: srcResult.error });
+            return;
+        }
+        const { files, sourceBoardId } = extractBoardArchive(readFileSync(srcResult.path));
+        const fullState = parsePlanDirectory(workingDir);
+        if (!fullState) {
+            reply({ success: false, error: 'Failed to parse PM directory' });
+            return;
+        }
+        const newBoardId = getNextBoardId(fullState.boards);
+        writeExtractedBoard({
+            files,
+            sourceBoardId,
+            newBoardId,
+            boardDir: join(pmDir, 'boards', newBoardId),
+            existingTitles: fullState.boards.map(board => board.title),
+        });
+        const workspace = registerBoardInWorkspace(pmDir, newBoardId);
+        const boardState = parseBoardDirectory(pmDir, newBoardId);
+        if (!boardState) {
+            reply({ success: false, error: 'Imported board failed to parse' });
+            return;
+        }
+        ctx.broadcastToAll({ type: 'planBoardCreated', data: boardState.board });
+        ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+        cleanupTempImport(srcResult.path, workingDir);
+        reply({ success: true, boardId: newBoardId, title: boardState.board.title });
+    }
+    catch (error) {
+        reply({ success: false, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+const MAX_TEMPLATE_JSON_BYTES = 1024 * 1024;
+function instantiateRequestProblem(templateJson, variables, requestId) {
+    if (!templateJson || typeof templateJson !== 'string' || !requestId) {
+        return 'templateJson and requestId required';
+    }
+    if (Buffer.byteLength(templateJson, 'utf-8') > MAX_TEMPLATE_JSON_BYTES) {
+        return 'Template exceeds the 1 MB limit';
+    }
+    if (variables !== undefined && (typeof variables !== 'object' || variables === null || Array.isArray(variables))) {
+        return 'variables must be an object of string values';
+    }
+    return null;
+}
+export function handleInstantiateTemplate(ctx, ws, msg, workingDir, permission) {
+    const { templateJson, variables, requestId } = (msg.data || {});
+    const reply = (data) => ctx.send(ws, { type: 'planTemplateInstantiated', data: { requestId, ...data } });
+    if (permission === 'view') {
+        reply({ success: false, error: 'Permission denied' });
+        return;
+    }
+    const problem = instantiateRequestProblem(templateJson, variables, requestId);
+    if (problem !== null || typeof templateJson !== 'string') {
+        reply({ success: false, error: problem ?? 'templateJson and requestId required' });
+        return;
+    }
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir) {
+        reply({ success: false, error: NO_SPECS_DIR_ERROR });
+        return;
+    }
+    try {
+        const template = parseTemplate(templateJson);
+        const validation = validateTemplate(template);
+        if (!validation.valid) {
+            const summary = validation.errors.map(e => `${e.pointer ?? '<root>'}: ${e.message}`).join('; ');
+            reply({ success: false, error: `Template is invalid: ${summary}` });
+            return;
+        }
+        const fullState = parsePlanDirectory(workingDir);
+        if (!fullState) {
+            reply({ success: false, error: 'Failed to parse PM directory' });
+            return;
+        }
+        const newBoardId = getNextBoardId(fullState.boards);
+        const boardDir = join(pmDir, 'boards', newBoardId);
+        if (existsSync(boardDir)) {
+            reply({ success: false, error: `Board directory already exists: ${newBoardId}` });
+            return;
+        }
+        try {
+            instantiateTemplate(template, {
+                pmDir,
+                boardId: newBoardId,
+                variables: { ...(variables ?? {}), board_id: newBoardId },
+                failIfExists: true,
+            });
+        }
+        catch (error) {
+            rmSync(boardDir, { recursive: true, force: true });
+            throw error;
+        }
+        const workspace = registerBoardInWorkspace(pmDir, newBoardId);
+        const boardState = parseBoardDirectory(pmDir, newBoardId);
+        if (!boardState) {
+            reply({ success: false, error: 'Instantiated board failed to parse' });
+            return;
+        }
+        ctx.broadcastToAll({ type: 'planBoardCreated', data: boardState.board });
+        ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+        reply({ success: true, boardId: newBoardId, title: boardState.board.title });
+    }
+    catch (error) {
+        reply({ success: false, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+function resolveImportSource(sourcePath, workingDir) {
+    const resolved = resolveAllowedPath(sourcePath, workingDir);
+    if ('error' in resolved)
+        return resolved;
+    if (!existsSync(resolved.path) || !statSync(resolved.path).isFile()) {
+        return { error: `File not found: ${sourcePath}` };
+    }
+    if (statSync(resolved.path).size > MAX_IMPORT_ZIP_BYTES) {
+        return { error: 'Template zip exceeds the 50 MB limit' };
+    }
+    return resolved;
+}
+export function registerBoardInWorkspace(pmDir, boardId) {
+    const wsPath = join(pmDir, 'workspace.json');
+    if (!existsSync(wsPath)) {
+        writeFileSync(wsPath, JSON.stringify({ activeBoardId: null, boardOrder: [] }, null, 2), 'utf-8');
+    }
+    const workspace = JSON.parse(readFileSync(wsPath, 'utf-8'));
+    workspace.boardOrder.push(boardId);
+    if (!workspace.activeBoardId) {
+        workspace.activeBoardId = boardId;
+    }
+    writeFileSync(wsPath, JSON.stringify(workspace, null, 2), 'utf-8');
+    return workspace;
+}
+function isTextReference(relPath) {
+    return relPath.endsWith('.md') || relPath.endsWith('.json');
+}
+function dedupeTitle(title, existing) {
+    const taken = new Set(existing);
+    if (!taken.has(title))
+        return title;
+    for (let n = 2;; n++) {
+        const candidate = `${title} (${n})`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+}
+export function writeExtractedBoard(opts) {
+    const { files, sourceBoardId, newBoardId, boardDir, existingTitles } = opts;
+    try {
+        for (const dir of ['backlog', 'out', 'reviews', 'logs']) {
+            mkdirSync(join(boardDir, dir), { recursive: true });
+        }
+        for (const [relPath, bytes] of files) {
+            const target = join(boardDir, relPath);
+            mkdirSync(dirname(target), { recursive: true });
+            if (sourceBoardId && sourceBoardId !== newBoardId && isTextReference(relPath)) {
+                const text = Buffer.from(bytes).toString('utf-8')
+                    .replaceAll(`boards/${sourceBoardId}/`, `boards/${newBoardId}/`);
+                writeFileSync(target, text, 'utf-8');
+            }
+            else {
+                writeFileSync(target, bytes);
+            }
+        }
+        const boardMdPath = join(boardDir, 'board.md');
+        let boardMd = readFileSync(boardMdPath, 'utf-8');
+        const { frontMatter } = parseFrontMatter(boardMd);
+        const title = dedupeTitle(String(frontMatter.title || '') || 'Imported board', existingTitles);
+        boardMd = replaceFrontMatterField(boardMd, 'id', newBoardId);
+        boardMd = replaceFrontMatterField(boardMd, 'title', formatYamlValue(title));
+        if (frontMatter.status === 'archived') {
+            boardMd = replaceFrontMatterField(boardMd, 'status', 'active');
+        }
+        writeFileSync(boardMdPath, boardMd, 'utf-8');
+    }
+    catch (error) {
+        rmSync(boardDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+function cleanupTempImport(absPath, workingDir) {
+    const tmpRoots = [TMP_IMPORT_PREFIX, LEGACY_TMP_IMPORT_PREFIX].map(prefix => resolve(workingDir, prefix));
+    if (tmpRoots.some(tmpRoot => absPath.startsWith(`${tmpRoot}/`))) {
+        try {
+            rmSync(absPath, { force: true });
+        }
+        catch {   }
+    }
+}

package/dist/server/services/websocket/pm-timeline-broadcast.js

@@ -0,0 +1,28 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { isTimelinePmEvent, PM_COMPOSER_ISSUE_ID } from '../plan/pm-timeline.js';
+export function pmTimelineKey(boardId, issueId) {
+    return `${boardId ?? 'default'}:${issueId || PM_COMPOSER_ISSUE_ID}`;
+}
+export function broadcastPmEvent(ctx, key, type, data) {
+    const buffer = ctx.pmEventBuffers.getOrCreate(key);
+    const seq = buffer.record(type, data);
+    ctx.broadcastToAll({ type, data, seq, pmKey: key });
+    assemblePmTimeline(ctx, key, type, data);
+    return seq;
+}
+function assemblePmTimeline(ctx, key, type, data) {
+    if (!isTimelinePmEvent(type))
+        return;
+    let events;
+    try {
+        events = ctx.pmTimelines.getOrCreate(key).ingest(type, data);
+    }
+    catch (err) {
+        console.error(`[pm-timeline] assembly failed key=${key} type=${type}:`, err);
+        return;
+    }
+    for (const event of events) {
+        broadcastPmEvent(ctx, key, 'pmTimelineEvent', event);
+    }
+}

package/dist/server/services/websocket/post-session-scan.js

@@ -0,0 +1,132 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { relative, resolve } from 'node:path';
+import { getClientId } from '../client-id.js';
+import { notifyQualityChanged } from '../sdk/quality-change-notify.js';
+import { makeSpaceKey } from '../settings.js';
+import { movementWrittenFiles } from './movement-written-files.js';
+import { recordQualityAgentNote } from './quality-agent-notes.js';
+import { getPersistence } from './quality-handlers.js';
+import { QualityPersistence } from './quality-persistence.js';
+import { indexDismissals, runQualityScan } from './quality-service.js';
+import { attributeToTrackedDirectories, filterSourceFiles } from './quality-tools.js';
+function spaceKeyFor(spaceRoot) {
+    return makeSpaceKey(getClientId(), spaceRoot);
+}
+async function planScans(input) {
+    const full = { form: 'full', dir: resolve(input.settleDir) };
+    const sourceFiles = await filterSourceFiles(movementWrittenFiles(input.movement));
+    if (sourceFiles.length === 0)
+        return [full];
+    if (input.worktreePath !== undefined) {
+        const dir = resolve(input.worktreePath);
+        const files = sourceFiles.filter((file) => file === dir || file.startsWith(`${dir}/`)).map((file) => relative(dir, file));
+        return files.length > 0 ? [{ form: 'worktree', dir, files }] : [full];
+    }
+    const attributed = attributeToTrackedDirectories(input.spaceRoot, getPersistence(input.spaceRoot).loadConfig(), sourceFiles);
+    return attributed.length > 0 ? attributed.map(({ path, files }) => ({ form: 'tracked', dir: resolve(input.spaceRoot, path), path, files })) : [full];
+}
+async function scanFor(spaceRoot, job, signal) {
+    if (job.form === 'full') {
+        return { kind: 'postSession', path: '.', results: await runQualityScan(job.dir, { signal }) };
+    }
+    const persistence = getPersistence(spaceRoot);
+    if (job.form === 'worktree') {
+        const results = await runQualityScan(job.dir, {
+            files: job.files,
+            dismissals: indexDismissals('.', persistence.loadSuppressionsFor('.')),
+            signal,
+        });
+        return { kind: 'agentTurn', path: '.', worktree: true, changedFiles: job.files, results };
+    }
+    const results = await runQualityScan(job.dir, {
+        files: job.files,
+        baseline: persistence.loadBaseline(job.path),
+        dismissals: indexDismissals(job.path, persistence.loadSuppressionsFor(job.path)),
+        signal,
+    });
+    return { kind: 'agentTurn', path: job.path, changedFiles: job.files, results };
+}
+async function executeScan(spaceRoot, job, signal) {
+    let notification;
+    try {
+        notification = await scanFor(spaceRoot, job, signal);
+    }
+    catch {
+        return null;
+    }
+    if (signal.aborted)
+        return null;
+    notifyQualityChanged(spaceKeyFor(spaceRoot), notification);
+    return notification;
+}
+const running = new Map();
+let shutdown = new AbortController();
+function foldJobs(pending, incoming) {
+    if (pending.form === 'full')
+        return pending;
+    if (incoming.form === 'full')
+        return incoming;
+    const files = [...new Set([...pending.files, ...incoming.files])];
+    if (pending.form === 'worktree' && incoming.form === 'worktree')
+        return { ...pending, files };
+    if (pending.form === 'tracked' && incoming.form === 'tracked' && pending.path === incoming.path)
+        return { ...pending, files };
+    return { form: 'full', dir: pending.dir };
+}
+function startScan(spaceRoot, job) {
+    const state = { followUp: null };
+    running.set(job.dir, state);
+    const scan = executeScan(spaceRoot, job, shutdown.signal);
+    void scan.then(() => {
+        running.delete(job.dir);
+        const followUp = state.followUp;
+        if (!followUp)
+            return;
+        const result = shutdown.signal.aborted ? Promise.resolve(null) : startScan(spaceRoot, followUp.job);
+        for (const waiter of followUp.waiters)
+            void result.then(waiter);
+    });
+    return scan;
+}
+function scheduleScan(spaceRoot, job) {
+    const state = running.get(job.dir);
+    if (!state)
+        return startScan(spaceRoot, job);
+    if (state.followUp)
+        state.followUp.job = foldJobs(state.followUp.job, job);
+    else
+        state.followUp = { job, waiters: [] };
+    const { waiters } = state.followUp;
+    return new Promise((resolve) => waiters.push(resolve));
+}
+export async function runPostSessionQualityScan(input) {
+    if (!QualityPersistence.isSetUp(input.spaceRoot))
+        return { kind: 'skipped', reason: 'not-set-up' };
+    if (shutdown.signal.aborted)
+        return { kind: 'aborted' };
+    const announced = [];
+    for (const job of await planScans(input)) {
+        if (shutdown.signal.aborted)
+            return { kind: 'aborted' };
+        const notification = await scheduleScan(input.spaceRoot, job);
+        if (notification)
+            announced.push(notification);
+    }
+    if (shutdown.signal.aborted)
+        return { kind: 'aborted' };
+    if (input.noteTabId !== undefined)
+        recordQualityAgentNote(input.noteTabId, input.spaceRoot, input.movement, announced);
+    return { kind: 'scanned', announced };
+}
+export function triggerPostSessionQualityScan(input) {
+    runPostSessionQualityScan(input).catch(() => {
+    });
+}
+export function abortPostSessionScans() {
+    shutdown.abort();
+}
+export function resetPostSessionScans() {
+    running.clear();
+    shutdown = new AbortController();
+}