@planu/cli 4.11.7 → 4.11.9

package/dist/tools/approval-handler.js

@@ -1,14 +1,15 @@
 // tools/approval-handler.ts — Handlers for approval workflow tools (SPEC-283, SPEC-722)
 import { hashProjectPath, projectDataDir } from '../storage/base-store.js';
 import * as approvalStore from '../storage/approval-store.js';
-// eslint-disable-next-line no-restricted-imports -- approval-handler is a SPEC-722 migration bridge; __internalSetStatus use is intentional
-import { getSpec, __internalSetStatus } from '../storage/spec-store.js';
+import { getSpec } from '../storage/spec-store.js';
 import { buildApprovalStatus } from '../engine/approval-workflow.js';
 import { appendEvent } from '../engine/audit-trail/index.js';
 import { join } from 'node:path';
 import { issueReviewerToken, verifyReviewerToken } from '../engine/reviewer-tokens/index.js';
 import { readPlanuConfig } from '../engine/planu-config-writer.js';
 import { readFile } from 'node:fs/promises';
+import { handleUpdateStatus } from './update-status/index.js';
+import { withApprovalSpecLock } from '../storage/approval-operation-lock.js';
 // ---------------------------------------------------------------------------
 // Path helpers
 // ---------------------------------------------------------------------------
@@ -46,6 +47,13 @@ function buildTokenRejectionMessage(reason) {
         '  (c) Legacy mode (deprecated, v2.x only): set `legacyReviewMode: true` in planu.json. ' +
         'This flag will be removed in v3. [DEPRECATION WARNING]');
 }
+function operationError(action, specId, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        content: [{ type: 'text', text: `Failed to ${action} ${specId}: ${message}` }],
+        isError: true,
+    };
+}
 // ---------------------------------------------------------------------------
 // configure_approval_policy
 // ---------------------------------------------------------------------------
@@ -103,8 +111,8 @@ export async function handleIssueReviewerToken(args) {
 // ---------------------------------------------------------------------------
 export async function handleApproveSpec(args) {
     const projectId = hashProjectPath(args.projectPath);
-    const spec = await getSpec(projectId, args.specId);
-    if (spec === null) {
+    const initialSpec = await getSpec(projectId, args.specId);
+    if (initialSpec === null) {
         return {
             content: [{ type: 'text', text: `Spec ${args.specId} not found.` }],
             isError: true,
@@ -155,9 +163,6 @@ export async function handleApproveSpec(args) {
         // Legacy mode: accept the string reviewer but warn loudly.
         reviewerIdentity = legacyIdentity(args.reviewer);
     }
-    // -------------------------------------------------------------------------
-    // Persist the approval record
-    // -------------------------------------------------------------------------
     const record = {
         specId: args.specId,
         reviewer: args.reviewer,
@@ -167,56 +172,81 @@ export async function handleApproveSpec(args) {
         ...(args.role !== undefined ? { role: args.role } : {}),
         ...(args.comment !== undefined ? { comment: args.comment } : {}),
     };
-    const records = await approvalStore.appendRecord(projectId, args.specId, record);
-    const policy = await approvalStore.getPolicy(projectId);
-    const status = buildApprovalStatus(args.specId, records, policy, undefined);
-    // Audit trail — fire-and-forget
-    appendEvent(auditLogPath(projectId), {
-        eventType: 'spec.approved',
-        specId: args.specId,
-        userId: args.reviewer,
-        action: 'approve_spec',
-        details: {
-            reviewer: args.reviewer,
-            reviewerIdentity,
-            role: args.role ?? null,
-            comment: args.comment ?? null,
-            approvalCount: status.approvalCount,
-            gateOpen: status.gateOpen,
-            tokenVerified: reviewerIdentity.verified,
-            legacyMode: reviewerIdentity.legacy,
-        },
-    }).catch(() => {
-        // audit failure must never block the tool
-    });
-    const gateMsg = status.gateOpen
-        ? ` Approval gate is now OPEN (${String(status.approvalCount)}/${String(policy?.requiredApprovals ?? status.approvalCount)}).`
-        : ` Gate still needs ${String(status.approvalsNeeded)} more approval(s).`;
-    const legacyWarning = reviewerIdentity.legacy
-        ? '\n\n⚠ [DEPRECATION] legacyReviewMode is active. Token-based review will be mandatory in v3.'
-        : '';
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `${args.reviewer} approved ${args.specId}.${gateMsg}${legacyWarning}`,
-            },
-        ],
-        structuredContent: { record, status },
-    };
+    try {
+        return await withApprovalSpecLock(args.projectPath, args.specId, async () => {
+            const spec = await getSpec(projectId, args.specId);
+            if (spec === null) {
+                return {
+                    content: [{ type: 'text', text: `Spec ${args.specId} not found.` }],
+                    isError: true,
+                };
+            }
+            if (spec.status !== 'review') {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Cannot approve ${args.specId} while status is "${spec.status}". Move it to review first.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const records = await approvalStore.appendRecord(projectId, args.specId, record);
+            const policy = await approvalStore.getPolicy(projectId);
+            const status = buildApprovalStatus(args.specId, records, policy, spec.updatedAt);
+            let auditWarning;
+            try {
+                await appendEvent(auditLogPath(projectId), {
+                    eventType: 'spec.approved',
+                    specId: args.specId,
+                    userId: args.reviewer,
+                    action: 'approve_spec',
+                    details: {
+                        reviewer: args.reviewer,
+                        reviewerIdentity,
+                        role: args.role ?? null,
+                        comment: args.comment ?? null,
+                        approvalCount: status.approvalCount,
+                        gateOpen: status.gateOpen,
+                        tokenVerified: reviewerIdentity.verified,
+                        legacyMode: reviewerIdentity.legacy,
+                    },
+                });
+            }
+            catch (error) {
+                auditWarning = `Audit event could not be persisted: ${error instanceof Error ? error.message : String(error)}`;
+            }
+            const gateMsg = status.gateOpen
+                ? ` Approval gate is now OPEN (${String(status.approvalCount)}/${String(policy?.requiredApprovals ?? status.approvalCount)}).`
+                : ` Gate still needs ${String(status.approvalsNeeded)} more approval(s).`;
+            const legacyWarning = reviewerIdentity.legacy
+                ? '\n\n⚠ [DEPRECATION] legacyReviewMode is active. Token-based review will be mandatory in v3.'
+                : '';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${args.reviewer} approved ${args.specId}.${gateMsg}${legacyWarning}`,
+                    },
+                ],
+                structuredContent: {
+                    record,
+                    status,
+                    ...(auditWarning ? { auditWarning } : {}),
+                },
+            };
+        });
+    }
+    catch (error) {
+        return operationError('approve', args.specId, error);
+    }
 }
 // ---------------------------------------------------------------------------
 // request_changes
 // ---------------------------------------------------------------------------
 export async function handleRequestChanges(args) {
     const projectId = hashProjectPath(args.projectPath);
-    const spec = await getSpec(projectId, args.specId);
-    if (spec === null) {
-        return {
-            content: [{ type: 'text', text: `Spec ${args.specId} not found.` }],
-            isError: true,
-        };
-    }
     const record = {
         specId: args.specId,
         reviewer: args.reviewer,
@@ -226,87 +256,188 @@ export async function handleRequestChanges(args) {
         comment: args.comment,
         ...(args.role !== undefined ? { role: args.role } : {}),
     };
-    // Append the changes_requested record and clear prior approvals for this spec
-    await approvalStore.appendRecord(projectId, args.specId, record);
-    await approvalStore.clearRecords(projectId, args.specId);
-    // Re-append only the changes_requested record so the history is preserved
-    const records = await approvalStore.appendRecord(projectId, args.specId, record);
-    // Move spec back to draft
-    // TODO(SPEC-722): Migrate to handleUpdateStatus with reviewer identity token.
-    // Using __internalSetStatus as a temporary bridge until SPEC-722 lands.
-    await __internalSetStatus(projectId, args.specId, 'draft');
-    // Audit trail — fire-and-forget
-    appendEvent(auditLogPath(projectId), {
-        eventType: 'spec.status_changed',
-        specId: args.specId,
-        userId: args.reviewer,
-        action: 'request_changes',
-        details: {
-            reviewer: args.reviewer,
-            role: args.role ?? null,
-            comment: args.comment,
-            changesRequested: true,
-        },
-    }).catch(() => {
-        // audit failure must never block the tool
-    });
-    void records;
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `${args.reviewer} requested changes on ${args.specId}. ` +
-                    `Spec moved back to draft. Comment: "${args.comment}"`,
-            },
-        ],
-        structuredContent: { record, specStatus: 'draft' },
-    };
+    try {
+        return await withApprovalSpecLock(args.projectPath, args.specId, async () => {
+            const spec = await getSpec(projectId, args.specId);
+            if (spec === null) {
+                return {
+                    content: [{ type: 'text', text: `Spec ${args.specId} not found.` }],
+                    isError: true,
+                };
+            }
+            const previousRecords = await approvalStore.getRecords(projectId, args.specId);
+            const statusResult = await handleUpdateStatus({
+                projectPath: args.projectPath,
+                specId: args.specId,
+                status: 'draft',
+                reviewNotes: `Changes requested by ${args.reviewer}: ${args.comment}`,
+            });
+            if (statusResult.isError) {
+                return statusResult;
+            }
+            let records;
+            try {
+                records = await approvalStore.replaceRecords(projectId, args.specId, [record]);
+            }
+            catch (replacementError) {
+                let approvalRecordsRestored;
+                let lifecycleRestored;
+                try {
+                    await approvalStore.replaceRecords(projectId, args.specId, previousRecords);
+                    approvalRecordsRestored = true;
+                }
+                catch {
+                    approvalRecordsRestored = false;
+                }
+                try {
+                    const rollbackResult = await handleUpdateStatus({
+                        projectPath: args.projectPath,
+                        specId: args.specId,
+                        status: spec.status,
+                        reviewNotes: `Automatic rollback after request_changes persistence failure for ${args.reviewer}.`,
+                    });
+                    lifecycleRestored = rollbackResult.isError !== true;
+                }
+                catch {
+                    lifecycleRestored = false;
+                }
+                const replacementMessage = replacementError instanceof Error ? replacementError.message : String(replacementError);
+                let auditWarning;
+                try {
+                    await appendEvent(auditLogPath(projectId), {
+                        eventType: 'spec.status_changed',
+                        specId: args.specId,
+                        userId: args.reviewer,
+                        action: 'request_changes_rolled_back',
+                        details: {
+                            reviewer: args.reviewer,
+                            reviewerIdentity: record.reviewerIdentity,
+                            role: args.role ?? null,
+                            comment: args.comment,
+                            changesRequested: true,
+                            persistenceError: replacementMessage,
+                            previousStatus: spec.status,
+                            approvalRecordsRestored,
+                            lifecycleRestored,
+                        },
+                    });
+                }
+                catch (auditError) {
+                    auditWarning = `Audit event could not be persisted: ${auditError instanceof Error ? auditError.message : String(auditError)}`;
+                }
+                const fullyRestored = approvalRecordsRestored && lifecycleRestored;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: fullyRestored
+                                ? `Request changes was not committed for ${args.specId}: ${replacementMessage}. Approval history and lifecycle were restored to "${spec.status}"; retry safely.`
+                                : `Request changes failed for ${args.specId}: ${replacementMessage}. Automatic recovery was incomplete (approval records: ${approvalRecordsRestored ? 'restored' : 'not restored'}, lifecycle: ${lifecycleRestored ? 'restored' : 'not restored'}).`,
+                        },
+                    ],
+                    isError: true,
+                    structuredContent: {
+                        record,
+                        previousStatus: spec.status,
+                        approvalRecordsRestored,
+                        lifecycleRestored,
+                        ...(auditWarning ? { auditWarning } : {}),
+                    },
+                };
+            }
+            let auditWarning;
+            try {
+                await appendEvent(auditLogPath(projectId), {
+                    eventType: 'spec.status_changed',
+                    specId: args.specId,
+                    userId: args.reviewer,
+                    action: 'request_changes',
+                    details: {
+                        reviewer: args.reviewer,
+                        reviewerIdentity: record.reviewerIdentity,
+                        role: args.role ?? null,
+                        comment: args.comment,
+                        changesRequested: true,
+                        previousStatus: spec.status,
+                        resultingStatus: 'draft',
+                    },
+                });
+            }
+            catch (error) {
+                auditWarning = `Audit event could not be persisted: ${error instanceof Error ? error.message : String(error)}`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${args.reviewer} requested changes on ${args.specId}. ` +
+                            `Spec moved back to draft. Comment: "${args.comment}"`,
+                    },
+                ],
+                structuredContent: {
+                    record,
+                    records,
+                    specStatus: 'draft',
+                    ...(auditWarning ? { auditWarning } : {}),
+                },
+            };
+        });
+    }
+    catch (error) {
+        return operationError('request changes on', args.specId, error);
+    }
 }
 // ---------------------------------------------------------------------------
 // approval_status
 // ---------------------------------------------------------------------------
 export async function handleApprovalStatus(args) {
     const projectId = hashProjectPath(args.projectPath);
-    const [spec, records, policy] = await Promise.all([
-        getSpec(projectId, args.specId),
-        approvalStore.getRecords(projectId, args.specId),
-        approvalStore.getPolicy(projectId),
-    ]);
-    if (spec === null) {
-        return {
-            content: [{ type: 'text', text: `Spec ${args.specId} not found.` }],
-            isError: true,
-        };
-    }
-    // Determine when spec entered review (use updatedAt as proxy if in review)
-    const reviewStartedAt = spec.status === 'review' ? spec.updatedAt : undefined;
-    const status = buildApprovalStatus(args.specId, records, policy, reviewStartedAt);
-    const lines = [
-        `Approval Status — ${args.specId}`,
-        `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-        `Approvals: ${String(status.approvalCount)} / ${String(policy?.requiredApprovals ?? '(no policy)')}`,
-        `Gate: ${status.gateOpen ? 'OPEN' : `BLOCKED — needs ${String(status.approvalsNeeded)} more`}`,
-    ];
-    if (status.approvers.length > 0) {
-        lines.push(`Approved by: ${status.approvers.join(', ')}`);
-    }
-    if (policy !== null) {
-        lines.push(`SLA: ${String(policy.reviewSLAHours)}h`);
-        if (spec.status === 'review') {
-            lines.push(`In review: ${String(status.hoursInReview)}h`);
-            if (status.slaBreached) {
-                lines.push(`⚠ SLA BREACHED by ${String(status.slaBreachHours)}h` +
-                    (policy.escalateTo !== undefined ? ` — escalate to ${policy.escalateTo}` : ''));
+    try {
+        return await withApprovalSpecLock(args.projectPath, args.specId, async () => {
+            const [spec, records, policy] = await Promise.all([
+                getSpec(projectId, args.specId),
+                approvalStore.getRecords(projectId, args.specId),
+                approvalStore.getPolicy(projectId),
+            ]);
+            if (spec === null) {
+                return {
+                    content: [{ type: 'text', text: `Spec ${args.specId} not found.` }],
+                    isError: true,
+                };
             }
-        }
+            const reviewStartedAt = spec.status === 'review' ? spec.updatedAt : undefined;
+            const status = buildApprovalStatus(args.specId, records, policy, reviewStartedAt);
+            const lines = [
+                `Approval Status — ${args.specId}`,
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+                `Approvals: ${String(status.approvalCount)} / ${String(policy?.requiredApprovals ?? '(no policy)')}`,
+                `Gate: ${status.gateOpen ? 'OPEN' : `BLOCKED — needs ${String(status.approvalsNeeded)} more`}`,
+            ];
+            if (status.approvers.length > 0) {
+                lines.push(`Approved by: ${status.approvers.join(', ')}`);
+            }
+            if (policy !== null) {
+                lines.push(`SLA: ${String(policy.reviewSLAHours)}h`);
+                if (spec.status === 'review') {
+                    lines.push(`In review: ${String(status.hoursInReview)}h`);
+                    if (status.slaBreached) {
+                        lines.push(`⚠ SLA BREACHED by ${String(status.slaBreachHours)}h` +
+                            (policy.escalateTo !== undefined ? ` — escalate to ${policy.escalateTo}` : ''));
+                    }
+                }
+            }
+            const changeRequests = records.filter((record) => record.action === 'changes_requested');
+            if (changeRequests.length > 0) {
+                lines.push(`Change requests: ${String(changeRequests.length)}`);
+            }
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }],
+                structuredContent: { status },
+            };
+        });
     }
-    const changeRequests = records.filter((r) => r.action === 'changes_requested');
-    if (changeRequests.length > 0) {
-        lines.push(`Change requests: ${String(changeRequests.length)}`);
+    catch (error) {
+        return operationError('read approval status for', args.specId, error);
     }
-    return {
-        content: [{ type: 'text', text: lines.join('\n') }],
-        structuredContent: { status },
-    };
 }
 //# sourceMappingURL=approval-handler.js.map

package/dist/tools/browser-validate-handler.js

@@ -35,8 +35,13 @@ async function runPlaywrightTests(testFilePath) {
         return parsePlaywrightOutput(stdout + stderr);
     }
     catch (err) {
-        const output = err instanceof Error ? err.message : String(err);
-        return parsePlaywrightOutput(output);
+        const processError = err;
+        const output = [processError.stdout, processError.stderr, processError.message]
+            .filter((value) => typeof value === 'string' && value.length > 0)
+            .join('\n')
+            .slice(0, 4_000);
+        const parsed = parsePlaywrightOutput(output);
+        return { ...parsed, failed: Math.max(1, parsed.failed) };
     }
 }
 export async function handleValidateBrowser(args) {
@@ -58,6 +63,10 @@ export async function handleValidateBrowser(args) {
         specContent = `- [ ] ${spec.title}`;
     }
     const assertions = extractUIAssertions(specContent);
+    const manualAssertionCount = assertions.filter((a) => a.type === 'generic' ||
+        ((a.type === 'visibility' || a.type === 'form') && a.locator === undefined) ||
+        (a.type === 'text' && a.locator === undefined) ||
+        (a.type === 'navigation' && a.expected === undefined)).length;
     const playwrightVersion = await checkPlaywrightAvailable();
     const testContent = generatePlaywrightTest(assertions, specId, baseUrl);
     const result = {
@@ -65,6 +74,7 @@ export async function handleValidateBrowser(args) {
         baseUrl,
         playwrightVersion,
         assertions,
+        manualAssertionCount,
     };
     if (playwrightVersion) {
         // Playwright is available — save temp file and run
@@ -80,12 +90,15 @@ export async function handleValidateBrowser(args) {
             `Base URL: ${baseUrl}`,
             `Playwright: ${playwrightVersion}`,
             `Assertions extracted: ${String(assertions.length)}`,
+            `Assertions requiring manual grounding: ${String(manualAssertionCount)}`,
             ``,
             `**Test Results:** ${summary}`,
             ``,
             `Test file: \`${testFilePath}\``,
         ];
-        return toolResult(formatSuccess('Browser Validation Complete', lines.join('\n')), result);
+        return toolResult(testResults.failed === 0
+            ? formatSuccess('Browser Validation Complete', lines.join('\n'))
+            : formatWarning('Browser Validation Failed', lines.join('\n')), result, testResults.failed > 0);
     }
     // Playwright not available — save test file and return instructions
     const testFilePath = await saveTestFile(projectPath, specId, testContent);
@@ -100,6 +113,7 @@ export async function handleValidateBrowser(args) {
         `Base URL: ${baseUrl}`,
         `Playwright: not found`,
         `Assertions extracted: ${String(assertions.length)}`,
+        `Assertions requiring manual grounding: ${String(manualAssertionCount)}`,
         ``,
         `**Test file saved:** \`${testFilePath}\``,
         ``,

package/dist/tools/dogfood-watch.d.ts

@@ -0,0 +1,6 @@
+import type { ToolResult } from '../types/index.js';
+export interface DogfoodWatchInput {
+    projectPath: string;
+}
+export declare function handleDogfoodWatch(input: DogfoodWatchInput): Promise<ToolResult>;
+//# sourceMappingURL=dogfood-watch.d.ts.map

package/dist/tools/dogfood-watch.js

@@ -0,0 +1,48 @@
+import { analyzeRuntimeDogfooding } from '../engine/dogfooding/runtime-gap-detector.js';
+export async function handleDogfoodWatch(input) {
+    const report = await analyzeRuntimeDogfooding(input.projectPath);
+    if (report.status === 'insufficient_evidence') {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        'Insufficient local evidence to assess dogfooding gaps.',
+                        '',
+                        `Sources checked: ${report.analyzedSources.join(', ') || 'none'}`,
+                        `Sources unavailable: ${report.unavailableSources.join(', ') || 'none'}`,
+                    ].join('\n'),
+                },
+            ],
+            structuredContent: report,
+        };
+    }
+    if (report.status === 'no_actionable_gaps') {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        'No actionable dogfooding gaps detected.',
+                        '',
+                        `Sources checked: ${report.analyzedSources.join(', ') || 'none'}`,
+                    ].join('\n'),
+                },
+            ],
+            structuredContent: report,
+        };
+    }
+    const lines = ['Dogfooding findings', ''];
+    for (const finding of report.findings) {
+        lines.push(`- [${finding.severity}] ${finding.title} (${String(finding.occurrences)} occurrence${finding.occurrences === 1 ? '' : 's'})`, `  Next action: ${finding.nextAction}`);
+        for (const evidence of finding.evidence) {
+            lines.push(`  Evidence: ${evidence}`);
+        }
+    }
+    lines.push('', `Sources checked: ${report.analyzedSources.join(', ') || 'none'}`);
+    return {
+        content: [{ type: 'text', text: lines.join('\n') }],
+        structuredContent: report,
+    };
+}
+//# sourceMappingURL=dogfood-watch.js.map

package/dist/tools/figma/visual-qa.js

@@ -22,7 +22,8 @@ export async function handleFigmaVisualDiffReport(input) {
     for (const nodeId of spec.nodeIds) {
         const figmaImageUrl = await exportFigmaFrameImage(parsed.fileKey, nodeId, config.accessToken);
         const diffs = buildPlaceholderDiff('', figmaImageUrl);
-        const result = createVisualQAResult(spec.specId, nodeId, figmaImageUrl, '', diffs);
+        const comparisonMode = diffs.length === 0 ? 'evidence-only' : 'pixel-diff';
+        const result = createVisualQAResult(spec.specId, nodeId, figmaImageUrl, '', diffs, comparisonMode);
         results.push(result);
     }
     await saveFigmaVisualQA(input.projectPath, results);

package/dist/tools/tool-registry/core-tools.js

@@ -38,6 +38,7 @@ import { IdeTargetEnum, IdeConfigScopeEnum } from '../schemas/ide-config.js';
 import { handleReconcileSpecLiving } from '../reconcile-spec-living-handler.js';
 import { handleSecurityReport } from '../security-report-handler.js';
 import { handleFeedbackStatus, handleResolveFeedback, handleSubmitFeedback, handleSyncFeedback, handleTriageFeedback, } from '../feedback-handler.js';
+import { handleDogfoodWatch } from '../dogfood-watch.js';
 import { SecurityReportTimeRangeEnum, SecurityReportFormatEnum, } from '../schemas/runtime-security.js';
 import { RenderSpecForProviderInputSchema, handleRenderSpecForProvider, } from '../render-spec-for-provider.js';
 import { handleTriageRequest, TriageRequestInputSchema } from '../triage-request.js';
@@ -847,6 +848,17 @@ const coreToolsRegistry = [
         wrap: 'tracked',
         group: 'feedback',
     },
+    {
+        name: 'dogfood_watch',
+        description: 'Analyze recent local Planu runtime evidence and surface actionable dogfooding gaps such as repeated tool failures, persisted version drift, guard fallback leakage, and stale local compatibility mirrors.',
+        schema: {
+            projectPath: z.string().min(1).max(4096).describe('Absolute path to the project root'),
+        },
+        handler: async (args) => handleDogfoodWatch(args),
+        annotations: { title: 'Dogfood Watch', readOnlyHint: true },
+        wrap: 'tracked',
+        group: 'feedback',
+    },
 ];
 export default coreToolsRegistry;
 //# sourceMappingURL=core-tools.js.map

package/dist/tools/tool-registry/group-quality-compliance.js

@@ -1056,12 +1056,23 @@ export function registerQualityComplianceGroupTools(s) {
                 .describe('Spec ID to request changes on (e.g. SPEC-042).'),
             reviewer: z
                 .string()
+                .trim()
+                .min(1)
+                .max(500)
                 .describe('Name, email, or username of the reviewer requesting changes.'),
             comment: z
                 .string()
+                .trim()
                 .min(1)
+                .max(10_000)
                 .describe('Required explanation of what needs to change before re-approval.'),
-            role: z.string().optional().describe('Role of the reviewer (e.g. "tech-lead", "qa").'),
+            role: z
+                .string()
+                .trim()
+                .min(1)
+                .max(500)
+                .optional()
+                .describe('Role of the reviewer (e.g. "tech-lead", "qa").'),
         },
         annotations: { title: 'Request Changes', destructiveHint: true },
     }, safeLicensed('request_changes', (args) => handleRequestChanges(args)));

package/dist/tools/update-status/file-sync.js

@@ -3,10 +3,11 @@ import { metricsStore } from '../../storage/index.js';
 import { addLesson, getLessons } from '../../storage/lessons-store.js';
 import { dispatchFeedbackEvent } from '../learn.js';
 import { autoReconcileOnDone } from '../update-status-reconcile.js';
-import { readFile, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { parseFrontmatter } from '../../engine/frontmatter-parser.js';
 import { computeFrontmatterSha } from '../../engine/frontmatter-sha/index.js';
 import { appendTransitionEvent } from '../../storage/transition-log.js';
+import { atomicWriteFile } from '../../engine/safety/atomic-write-file.js';
 export async function recordDoneMetrics(projectId, specId, spec, actuals, projectPath) {
     if (actuals.devHours + actuals.reviewHours === 0) {
         return;
@@ -110,7 +111,7 @@ export async function syncSpecFiles(updatedSpec, _currentStatus, newStatus, proj
                 newStatus,
                 specId: updatedSpec.id,
             });
-            await writeFile(updatedSpec.specPath, updatedContent, 'utf-8');
+            await atomicWriteFile(updatedSpec.specPath, updatedContent);
             // SPEC-544: Auto-stage spec.md after writing so it's included in the user's next commit
             // SPEC-575: Auto-commit staged planu/ docs (idempotent, safe-fail)
             // Commit message must reflect the actual transition — 'mark-done' is only

package/dist/tools/update-status/index.d.ts

@@ -1,4 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { UpdateStatusInput, ToolResult } from '../../types/index.js';
+/** Recover durable post-commit work for every registered project after server startup. */
+export declare function recoverPendingPostCommitTasksAtStartup(): Promise<void>;
 export declare function handleUpdateStatus(params: UpdateStatusInput, server?: McpServer): Promise<ToolResult>;
 //# sourceMappingURL=index.d.ts.map