@minionry/minion 0.7.36

package/dist/server/services/sdk/pm.js

@@ -0,0 +1,634 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getNextId, parseBoardDirectory, parsePlanDirectory, parseSingleIssue, resolvePmDir } from '../plan/parser.js';
+import { tryCompleteParentEpic } from '../plan/state-reconciler.js';
+import { renderIssueMarkdown } from '../plan/template-instantiator.js';
+import { applyBoardFieldUpdates } from '../websocket/plan-board-handlers.js';
+import { resolvePlanPath } from '../websocket/plan-helpers.js';
+import { applyIssueFieldUpdates, deleteIssueFile } from '../websocket/plan-issue-handlers.js';
+import { logAppAudit } from './audit.js';
+import { getGrant } from './grant-store.js';
+import { listLiveSubscriptions, registerLiveSubscription } from './live-registry.js';
+import { SdkMethodError } from './registry.js';
+let pmHost = null;
+export function setSdkPmHost(host) {
+    pmHost = host;
+}
+export function resetSdkPmHost() {
+    pmHost = null;
+}
+function requirePmHost(method) {
+    if (!pmHost) {
+        throw new SdkMethodError('INTERNAL', `'${method}' host is not wired — the WebSocket handler installs it at startup`);
+    }
+    return pmHost;
+}
+function idFromPlanPath(planPath) {
+    const file = planPath.split('/').pop() ?? planPath;
+    return file.replace(/\.md$/, '');
+}
+function toIssueRef(summary) {
+    return { id: summary.id, title: summary.title, priority: summary.priority };
+}
+function toSnapshotIssue(issue, idByPath) {
+    const resolveRef = (planPath) => idByPath.get(planPath) ?? idFromPlanPath(planPath);
+    return {
+        id: issue.id,
+        title: issue.title,
+        type: issue.type,
+        status: issue.status,
+        priority: issue.priority,
+        estimate: issue.estimate,
+        labels: [...issue.labels],
+        epicId: issue.epic ? resolveRef(issue.epic) : null,
+        blockedBy: issue.blockedBy.map(resolveRef),
+        blocks: issue.blocks.map(resolveRef),
+        description: issue.description,
+        acceptanceCriteria: issue.acceptanceCriteria.map(({ text, checked }) => ({ text, checked })),
+        created: issue.created,
+        updated: issue.updated,
+    };
+}
+export function toBoardSnapshot(full) {
+    const idByPath = new Map(full.issues.map((issue) => [issue.path, issue.id]));
+    return {
+        board: {
+            id: full.board.id,
+            title: full.board.title,
+            status: full.board.status,
+            goal: full.board.goal,
+            created: full.board.created,
+            completedAt: full.board.completedAt,
+        },
+        state: {
+            paused: full.state.paused,
+            readyToWork: full.state.readyToWork.map(toIssueRef),
+            inProgress: full.state.inProgress.map(toIssueRef),
+            blocked: full.state.blocked.map(toIssueRef),
+            recentlyCompleted: full.state.recentlyCompleted.map(toIssueRef),
+            warnings: [...full.state.warnings],
+        },
+        issues: full.issues.map((issue) => toSnapshotIssue(issue, idByPath)),
+    };
+}
+export function readBoardSnapshot(workingDir, boardId) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return null;
+    const full = parseBoardDirectory(pmDir, boardId);
+    if (!full)
+        return null;
+    return toBoardSnapshot(full);
+}
+function toBoardSummary(board) {
+    return {
+        id: board.id,
+        title: board.title,
+        status: board.status,
+        goal: board.goal,
+        created: board.created,
+        completedAt: board.completedAt,
+    };
+}
+export function listBoardSummaries(workingDir) {
+    const full = parsePlanDirectory(workingDir);
+    if (!full)
+        return [];
+    return full.boards.map(toBoardSummary);
+}
+function paramsObject(params) {
+    return typeof params === 'object' && params !== null && !Array.isArray(params)
+        ? params
+        : {};
+}
+function parseBoardIdParams(params, method) {
+    const raw = paramsObject(params);
+    if (typeof raw.boardId !== 'string' || raw.boardId.trim() === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${method} requires params { boardId }`);
+    }
+    return raw.boardId;
+}
+const MAX_RUN_INPUT_DATA_BYTES = 1024 * 1024;
+const MAX_GATHER_PROMPT_CHARS = 4000;
+const VARIABLE_NAME_PATTERN = /^\w+$/;
+function parseRunInputVariables(raw, method) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new SdkMethodError('BAD_REQUEST', `${method} input.variables must be a plain object`);
+    }
+    const variables = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (!VARIABLE_NAME_PATTERN.test(name)) {
+            throw new SdkMethodError('BAD_REQUEST', `${method} input.variables key '${name}' must match /^\\w+$/`);
+        }
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            throw new SdkMethodError('BAD_REQUEST', `${method} input.variables.${name} must be a string, number, or boolean`);
+        }
+        variables[name] = value;
+    }
+    return variables;
+}
+function parseRunInputData(raw, method) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(raw);
+    }
+    catch {
+        throw new SdkMethodError('BAD_REQUEST', `${method} input.data must be JSON-serializable`);
+    }
+    if (serialized === undefined) {
+        throw new SdkMethodError('BAD_REQUEST', `${method} input.data must be JSON-serializable`);
+    }
+    if (Buffer.byteLength(serialized, 'utf-8') > MAX_RUN_INPUT_DATA_BYTES) {
+        throw new SdkMethodError('BAD_REQUEST', `${method} input.data must serialize to 1 MiB or less`);
+    }
+    return raw;
+}
+function parseRunInputGatherPrompt(raw, method) {
+    if (typeof raw !== 'string' || raw.trim() === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${method} input.gatherPrompt must be a non-empty string`);
+    }
+    if (raw.trim().length > MAX_GATHER_PROMPT_CHARS) {
+        throw new SdkMethodError('BAD_REQUEST', `${method} input.gatherPrompt must be ${MAX_GATHER_PROMPT_CHARS} characters or fewer after trim`);
+    }
+    return raw;
+}
+export function parseBoardRunInput(raw, method = 'pm.createBoard') {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new SdkMethodError('BAD_REQUEST', `${method} input must be an object`);
+    }
+    const obj = raw;
+    const input = {};
+    if (obj.variables !== undefined)
+        input.variables = parseRunInputVariables(obj.variables, method);
+    if (obj.data !== undefined)
+        input.data = parseRunInputData(obj.data, method);
+    if (obj.gatherPrompt !== undefined)
+        input.gatherPrompt = parseRunInputGatherPrompt(obj.gatherPrompt, method);
+    return input;
+}
+function parseCreateBoardParams(params) {
+    const raw = paramsObject(params);
+    if (typeof raw.prompt !== 'string' || raw.prompt.trim() === '') {
+        throw new SdkMethodError('BAD_REQUEST', 'pm.createBoard requires params { prompt, autoImplement? } with a non-empty prompt');
+    }
+    if (raw.autoImplement !== undefined && typeof raw.autoImplement !== 'boolean') {
+        throw new SdkMethodError('BAD_REQUEST', 'pm.createBoard autoImplement must be a boolean when present');
+    }
+    const input = raw.input !== undefined ? parseBoardRunInput(raw.input) : undefined;
+    return { prompt: raw.prompt, autoImplement: raw.autoImplement === true, ...(input ? { input } : {}) };
+}
+function boardNotFound(boardId) {
+    return new SdkMethodError('BAD_REQUEST', `board '${boardId}' not found in this Space`);
+}
+export async function pmCreateBoardHandler(args) {
+    const host = requirePmHost(args.method);
+    const { prompt, autoImplement, input } = parseCreateBoardParams(args.params);
+    let created;
+    try {
+        created = await host.createBoard({ workingDir: args.workingDir, prompt, autoImplement, ...(input ? { input } : {}) });
+    }
+    catch (error) {
+        throw new SdkMethodError('INTERNAL', `board creation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    logAppAudit({
+        appId: args.appId,
+        origin: args.origin,
+        method: 'pm.createBoard.created',
+        decision: 'allow',
+        requestId: args.requestId,
+        spaceKey: args.spaceKey,
+        reason: `board ${created.boardId} created via chatToBoard (autoImplement=${autoImplement})`,
+    });
+    return created;
+}
+export function pmGetBoardHandler(args) {
+    const boardId = parseBoardIdParams(args.params, args.method);
+    const snapshot = readBoardSnapshot(args.workingDir, boardId);
+    if (!snapshot)
+        throw boardNotFound(boardId);
+    return snapshot;
+}
+export function pmListBoardsHandler(args) {
+    return listBoardSummaries(args.workingDir);
+}
+export function pmOnBoardUpdateHandler(args) {
+    const host = requirePmHost(args.method);
+    const boardId = parseBoardIdParams(args.params, args.method);
+    const initial = readBoardSnapshot(args.workingDir, boardId);
+    if (!initial)
+        throw boardNotFound(boardId);
+    if (listLiveSubscriptions().some((sub) => sub.requestId === args.requestId)) {
+        throw new SdkMethodError('BAD_REQUEST', `requestId '${args.requestId}' already holds a live subscription`);
+    }
+    let lastSerialized = JSON.stringify(initial);
+    let active = true;
+    const unsubscribe = host.subscribeBoardUpdates(args.workingDir, () => {
+        if (!active)
+            return;
+        const snapshot = readBoardSnapshot(args.workingDir, boardId);
+        if (!snapshot)
+            return;
+        const serialized = JSON.stringify(snapshot);
+        if (serialized === lastSerialized)
+            return;
+        lastSerialized = serialized;
+        args.emit('boardUpdate', snapshot);
+    });
+    registerLiveSubscription({
+        requestId: args.requestId,
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        kind: 'pm.subscribeBoard',
+        viewerId: getGrant(args.appId, args.spaceKey) ? undefined : args.viewerId,
+        teardown: () => {
+            active = false;
+            unsubscribe();
+        },
+    });
+    return { subscribed: true, boardId };
+}
+const DEFAULT_ID_PREFIXES = {
+    issue: 'IS',
+    epic: 'EP',
+    bug: 'BG',
+    task: 'TASK',
+};
+const ISSUE_TYPES = ['issue', 'epic', 'bug', 'task'];
+const PRIORITIES = ['P0', 'P1', 'P2', 'P3'];
+const ISSUE_ID_ALLOCATION_ATTEMPTS = 25;
+function issueNotFound(boardId, issueId) {
+    return new SdkMethodError('BAD_REQUEST', `issue '${issueId}' not found on board '${boardId}'`);
+}
+function badRequest(message) {
+    return new SdkMethodError('BAD_REQUEST', message);
+}
+function assertYamlSafe(value, field, method, listItem = false) {
+    if (/[\r\n]/.test(value))
+        throw badRequest(`${method} ${field} must not contain line breaks`);
+    if (listItem && value.includes(','))
+        throw badRequest(`${method} ${field} must not contain commas`);
+    return value;
+}
+function requiredStringParam(raw, name, method) {
+    const value = raw[name];
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw badRequest(`${method} requires a non-empty ${name}`);
+    }
+    return value;
+}
+function optionalStringParam(raw, name, method) {
+    if (raw[name] === undefined)
+        return undefined;
+    if (typeof raw[name] !== 'string')
+        throw badRequest(`${method} ${name} must be a string`);
+    return raw[name];
+}
+function optionalStringListParam(raw, name, method) {
+    if (raw[name] === undefined)
+        return undefined;
+    const value = raw[name];
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string' || entry.trim() === '')) {
+        throw badRequest(`${method} ${name} must be an array of non-empty strings`);
+    }
+    return value;
+}
+function optionalEnumParam(raw, name, method, allowed) {
+    if (raw[name] === undefined)
+        return undefined;
+    const value = raw[name];
+    if (typeof value !== 'string' || !allowed.includes(value)) {
+        throw badRequest(`${method} ${name} must be one of ${allowed.join(', ')}`);
+    }
+    return value;
+}
+function optionalEstimateParam(raw, method) {
+    if (!('estimate' in raw))
+        return undefined;
+    const value = raw.estimate;
+    if (value === null)
+        return null;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '')
+        return assertYamlSafe(value, 'estimate', method);
+    throw badRequest(`${method} estimate must be a number, a non-empty string, or null`);
+}
+function optionalTextParam(raw, name, method) {
+    const value = optionalStringParam(raw, name, method);
+    if (value === undefined)
+        return undefined;
+    if (value.trim() === '')
+        throw badRequest(`${method} ${name} must be a non-empty string`);
+    return assertYamlSafe(value, name, method);
+}
+function parseIssueRefFields(raw, method, patch) {
+    if ('epicId' in raw) {
+        if (raw.epicId !== null && (typeof raw.epicId !== 'string' || raw.epicId.trim() === '')) {
+            throw badRequest(`${method} epicId must be an issue id or null`);
+        }
+        patch.epicId = raw.epicId;
+    }
+    const blockedBy = optionalStringListParam(raw, 'blockedBy', method);
+    if (blockedBy !== undefined)
+        patch.blockedBy = blockedBy;
+    const blocks = optionalStringListParam(raw, 'blocks', method);
+    if (blocks !== undefined)
+        patch.blocks = blocks;
+}
+function parseIssueFieldPatch(raw, method) {
+    const patch = {};
+    const title = optionalTextParam(raw, 'title', method);
+    if (title !== undefined)
+        patch.title = title;
+    const status = optionalTextParam(raw, 'status', method);
+    if (status !== undefined)
+        patch.status = status;
+    const priority = optionalEnumParam(raw, 'priority', method, PRIORITIES);
+    if (priority !== undefined)
+        patch.priority = priority;
+    const estimate = optionalEstimateParam(raw, method);
+    if (estimate !== undefined)
+        patch.estimate = estimate;
+    const labels = optionalStringListParam(raw, 'labels', method);
+    if (labels !== undefined)
+        patch.labels = labels.map((label) => assertYamlSafe(label, 'labels', method, true));
+    parseIssueRefFields(raw, method, patch);
+    return patch;
+}
+function parseCreateIssueParams(params) {
+    const method = 'pm.createIssue';
+    const raw = paramsObject(params);
+    const boardId = requiredStringParam(raw, 'boardId', method);
+    const title = assertYamlSafe(requiredStringParam(raw, 'title', method), 'title', method);
+    const patch = parseIssueFieldPatch({ ...raw, title }, method);
+    const description = optionalStringParam(raw, 'description', method);
+    const acceptanceCriteria = optionalStringListParam(raw, 'acceptanceCriteria', method);
+    return {
+        ...patch,
+        boardId,
+        title,
+        type: optionalEnumParam(raw, 'type', method, ISSUE_TYPES) ?? 'issue',
+        ...(description !== undefined ? { description } : {}),
+        ...(acceptanceCriteria !== undefined ? { acceptanceCriteria } : {}),
+    };
+}
+function parseIssueTargetParams(params, method) {
+    const raw = paramsObject(params);
+    return {
+        boardId: requiredStringParam(raw, 'boardId', method),
+        issueId: requiredStringParam(raw, 'issueId', method),
+    };
+}
+function parseUpdateIssueParams(params) {
+    const method = 'pm.updateIssue';
+    const raw = paramsObject(params);
+    const { boardId, issueId } = parseIssueTargetParams(params, method);
+    if (typeof raw.fields !== 'object' || raw.fields === null || Array.isArray(raw.fields)) {
+        throw badRequest(`${method} requires params { boardId, issueId, fields }`);
+    }
+    const fields = parseIssueFieldPatch(raw.fields, method);
+    if (Object.keys(fields).length === 0) {
+        throw badRequest(`${method} fields must name at least one of title, status, priority, estimate, labels, epicId, blockedBy, blocks`);
+    }
+    return { boardId, issueId, fields };
+}
+function parseBoardExecutionFields(rawFields, method, fields) {
+    if (rawFields.maxParallelAgents !== undefined) {
+        const value = rawFields.maxParallelAgents;
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 10) {
+            throw badRequest(`${method} maxParallelAgents must be an integer between 1 and 10`);
+        }
+        fields.maxParallelAgents = value;
+    }
+    if (rawFields.autoImplement !== undefined) {
+        if (typeof rawFields.autoImplement !== 'boolean')
+            throw badRequest(`${method} autoImplement must be a boolean`);
+        fields.autoImplement = rawFields.autoImplement;
+    }
+}
+function parseBoardFieldPatch(rawFields, method) {
+    const fields = {};
+    const title = optionalTextParam(rawFields, 'title', method);
+    if (title !== undefined)
+        fields.title = title;
+    const status = optionalEnumParam(rawFields, 'status', method, ['draft', 'active', 'completed']);
+    if (status !== undefined)
+        fields.status = status;
+    const goal = optionalStringParam(rawFields, 'goal', method);
+    if (goal !== undefined)
+        fields.goal = assertYamlSafe(goal, 'goal', method);
+    parseBoardExecutionFields(rawFields, method, fields);
+    return fields;
+}
+function parseUpdateBoardParams(params) {
+    const method = 'pm.updateBoard';
+    const raw = paramsObject(params);
+    const boardId = requiredStringParam(raw, 'boardId', method);
+    if (typeof raw.fields !== 'object' || raw.fields === null || Array.isArray(raw.fields)) {
+        throw badRequest(`${method} requires params { boardId, fields }`);
+    }
+    const fields = parseBoardFieldPatch(raw.fields, method);
+    if (Object.keys(fields).length === 0) {
+        throw badRequest(`${method} fields must name at least one of title, status, goal, maxParallelAgents, autoImplement`);
+    }
+    return { boardId, fields };
+}
+function requireBoard(workingDir, boardId) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        throw boardNotFound(boardId);
+    const full = parseBoardDirectory(pmDir, boardId);
+    if (!full)
+        throw boardNotFound(boardId);
+    return { pmDir, full };
+}
+function boardRelativePath(issuePath, boardId) {
+    const prefix = `boards/${boardId}/`;
+    return issuePath.startsWith(prefix) ? issuePath.slice(prefix.length) : issuePath;
+}
+function boardIssuePaths(full, boardId) {
+    const paths = {};
+    for (const issue of full.issues)
+        paths[issue.id] = boardRelativePath(issue.path, boardId);
+    return paths;
+}
+function refPath(full, boardId, issueId, field) {
+    const issue = full.issues.find((candidate) => candidate.id === issueId);
+    if (!issue)
+        throw badRequest(`${field} names unknown issue '${issueId}' on board '${boardId}'`);
+    return boardRelativePath(issue.path, boardId);
+}
+function toIssueFrontMatterFields(full, boardId, fields) {
+    const writable = {};
+    if (fields.title !== undefined)
+        writable.title = fields.title;
+    if (fields.status !== undefined)
+        writable.status = fields.status;
+    if (fields.priority !== undefined)
+        writable.priority = fields.priority;
+    if (fields.estimate !== undefined)
+        writable.estimate = fields.estimate;
+    if (fields.labels !== undefined)
+        writable.labels = fields.labels;
+    if (fields.epicId !== undefined) {
+        writable.epic = fields.epicId === null ? null : refPath(full, boardId, fields.epicId, 'epicId');
+    }
+    if (fields.blockedBy !== undefined) {
+        writable.blockedBy = fields.blockedBy.map((id) => refPath(full, boardId, id, 'blockedBy'));
+    }
+    if (fields.blocks !== undefined) {
+        writable.blocks = fields.blocks.map((id) => refPath(full, boardId, id, 'blocks'));
+    }
+    return writable;
+}
+function toTemplateIssue(id, params) {
+    return {
+        id,
+        type: params.type,
+        title: params.title,
+        priority: params.priority ?? 'P2',
+        estimate: params.estimate ?? null,
+        labels: params.labels ?? [],
+        epic: params.epicId ?? null,
+        blocked_by: params.blockedBy ?? [],
+        blocks: params.blocks ?? [],
+        description: params.description ?? '',
+        acceptance_criteria: params.acceptanceCriteria ?? [],
+    };
+}
+function resolveIdPrefix(workingDir, type) {
+    const configured = parsePlanDirectory(workingDir)?.project.idPrefixes?.[type];
+    return typeof configured === 'string' && configured.trim() !== '' ? configured : DEFAULT_ID_PREFIXES[type];
+}
+function nextFreeIssueId(backlogDir, issues, prefix) {
+    let candidate = getNextId(issues, prefix);
+    while (existsSync(join(backlogDir, `${candidate}.md`))) {
+        const current = Number.parseInt(candidate.slice(prefix.length + 1), 10);
+        candidate = `${prefix}-${String(current + 1).padStart(3, '0')}`;
+    }
+    return candidate;
+}
+function readIssueSnapshot(pmDir, boardId, issueId) {
+    const full = parseBoardDirectory(pmDir, boardId);
+    if (!full)
+        return null;
+    const idByPath = new Map(full.issues.map((issue) => [issue.path, issue.id]));
+    const issue = full.issues.find((candidate) => candidate.id === issueId);
+    return issue ? toSnapshotIssue(issue, idByPath) : null;
+}
+function notifyPlanUpdate(workingDir) {
+    pmHost?.broadcastPlanUpdate(workingDir);
+}
+function auditMutation(args, method, reason) {
+    logAppAudit({
+        appId: args.appId,
+        origin: args.origin,
+        method,
+        decision: 'allow',
+        requestId: args.requestId,
+        spaceKey: args.spaceKey,
+        reason,
+    });
+}
+function assertIssueRefsResolve(full, params) {
+    if (params.epicId != null)
+        refPath(full, params.boardId, params.epicId, 'epicId');
+    for (const id of params.blockedBy ?? [])
+        refPath(full, params.boardId, id, 'blockedBy');
+    for (const id of params.blocks ?? [])
+        refPath(full, params.boardId, id, 'blocks');
+}
+function writeNewIssueFile(pmDir, backlogDir, params, prefix) {
+    const created = new Date().toISOString().split('T')[0];
+    for (let attempt = 0; attempt < ISSUE_ID_ALLOCATION_ATTEMPTS; attempt++) {
+        const full = parseBoardDirectory(pmDir, params.boardId);
+        if (!full)
+            throw boardNotFound(params.boardId);
+        assertIssueRefsResolve(full, params);
+        const candidate = nextFreeIssueId(backlogDir, full.issues, prefix);
+        const issuePaths = boardIssuePaths(full, params.boardId);
+        issuePaths[candidate] = `backlog/${candidate}.md`;
+        const markdown = renderIssueMarkdown(toTemplateIssue(candidate, params), {}, issuePaths, created);
+        try {
+            writeFileSync(join(backlogDir, `${candidate}.md`), markdown, { encoding: 'utf-8', flag: 'wx' });
+            return candidate;
+        }
+        catch (error) {
+            if (error?.code !== 'EEXIST') {
+                throw new SdkMethodError('INTERNAL', `failed to write issue on board '${params.boardId}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    throw new SdkMethodError('INTERNAL', `could not allocate a free issue id on board '${params.boardId}'`);
+}
+export function pmCreateIssueHandler(args) {
+    const params = parseCreateIssueParams(args.params);
+    const { pmDir } = requireBoard(args.workingDir, params.boardId);
+    const backlogDir = join(pmDir, 'boards', params.boardId, 'backlog');
+    mkdirSync(backlogDir, { recursive: true });
+    const issueId = writeNewIssueFile(pmDir, backlogDir, params, resolveIdPrefix(args.workingDir, params.type));
+    if (params.status !== undefined && params.status !== 'todo') {
+        const issuePath = `boards/${params.boardId}/backlog/${issueId}.md`;
+        const fullPath = resolvePlanPath(args.workingDir, issuePath);
+        if (fullPath)
+            applyIssueFieldUpdates(fullPath, { status: params.status });
+    }
+    const snapshot = readIssueSnapshot(pmDir, params.boardId, issueId);
+    if (!snapshot)
+        throw issueNotFound(params.boardId, issueId);
+    auditMutation(args, 'pm.createIssue.created', `issue ${issueId} created on board ${params.boardId}`);
+    notifyPlanUpdate(args.workingDir);
+    return snapshot;
+}
+export function pmUpdateIssueHandler(args) {
+    const { boardId, issueId, fields } = parseUpdateIssueParams(args.params);
+    const { pmDir, full } = requireBoard(args.workingDir, boardId);
+    const issue = full.issues.find((candidate) => candidate.id === issueId);
+    if (!issue)
+        throw issueNotFound(boardId, issueId);
+    const fullPath = resolvePlanPath(args.workingDir, issue.path);
+    if (!fullPath || !existsSync(fullPath))
+        throw issueNotFound(boardId, issueId);
+    if (!applyIssueFieldUpdates(fullPath, toIssueFrontMatterFields(full, boardId, fields))) {
+        throw new SdkMethodError('INTERNAL', `issue '${issueId}' is not front-matter shaped`);
+    }
+    const updated = parseSingleIssue(args.workingDir, issue.path);
+    if (updated)
+        tryCompleteParentEpic(args.workingDir, updated);
+    const snapshot = readIssueSnapshot(pmDir, boardId, issueId);
+    if (!snapshot)
+        throw issueNotFound(boardId, issueId);
+    auditMutation(args, 'pm.updateIssue.updated', `issue ${issueId} on board ${boardId} updated (${Object.keys(fields).join(', ')})`);
+    notifyPlanUpdate(args.workingDir);
+    return snapshot;
+}
+export function pmDeleteIssueHandler(args) {
+    const { boardId, issueId } = parseIssueTargetParams(args.params, 'pm.deleteIssue');
+    const { full } = requireBoard(args.workingDir, boardId);
+    const issue = full.issues.find((candidate) => candidate.id === issueId);
+    if (!issue)
+        throw issueNotFound(boardId, issueId);
+    const fullPath = resolvePlanPath(args.workingDir, issue.path);
+    if (!fullPath || !deleteIssueFile(fullPath))
+        throw issueNotFound(boardId, issueId);
+    auditMutation(args, 'pm.deleteIssue.deleted', `issue ${issueId} deleted from board ${boardId}`);
+    notifyPlanUpdate(args.workingDir);
+    return { deleted: true, issueId };
+}
+export function pmUpdateBoardHandler(args) {
+    const { boardId, fields } = parseUpdateBoardParams(args.params);
+    const { pmDir } = requireBoard(args.workingDir, boardId);
+    const boardMdPath = join(pmDir, 'boards', boardId, 'board.md');
+    if (!existsSync(boardMdPath))
+        throw boardNotFound(boardId);
+    applyBoardFieldUpdates(boardMdPath, fields);
+    const updated = parseBoardDirectory(pmDir, boardId);
+    if (!updated)
+        throw boardNotFound(boardId);
+    auditMutation(args, 'pm.updateBoard.updated', `board ${boardId} updated (${Object.keys(fields).join(', ')})`);
+    notifyPlanUpdate(args.workingDir);
+    return toBoardSummary(updated.board);
+}

package/dist/server/services/sdk/quality-change-notify.js

@@ -0,0 +1,20 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const listeners = new Set();
+export function registerQualityChangeListener(spaceKey, cb) {
+    const listener = { spaceKey, cb };
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+export function notifyQualityChanged(spaceKey, change) {
+    for (const listener of listeners) {
+        if (listener.spaceKey !== spaceKey)
+            continue;
+        listener.cb(change);
+    }
+}
+export function resetQualityChangeListeners() {
+    listeners.clear();
+}