@planu/cli 5.7.4 → 5.7.6

package/dist/tools/register-sdd-tools.js

@@ -9,7 +9,6 @@ import { registerDesignStackTools } from './register-platform-tools/design-stack
 import { registerQualityComplianceGroupTools } from './tool-registry/group-quality-compliance.js';
 import { registerInfraGroupTools } from './tool-registry/group-infra.js';
 import { safe } from './safe-handler.js';
-import { handleCreateRule } from './create-rule.js';
 import { handleCreateSkill } from './create-skill.js';
 import { handleReconcileUniversalRules } from './reconcile-universal-rules.js';
 import { registerBumpSpecVersionTool } from './bump-spec-version.js';
@@ -43,28 +42,6 @@ function registerOnly(server, names, register) {
     register(scopedServer);
 }
 function registerUniversalRulesTools(s) {
-    s.registerTool('create_rule', {
-        description: 'Create a host-aware rule file for a Planu project. For Claude Code, writes to `.claude/rules/{name}.md`. For Codex, inserts a delimited block in `AGENTS.md`. For Gemini, inserts a delimited block in `.gemini/conventions.md`. Use host: "auto" to detect the current host automatically.',
-        inputSchema: {
-            projectPath: z
-                .string()
-                .describe('Absolute path to the project root where the rule will be written'),
-            name: z
-                .string()
-                .min(1)
-                .describe('Rule identifier — kebab-case, no extension (e.g. "team-style").'),
-            content: z.string().min(1).describe('Markdown body of the rule (no frontmatter required)'),
-            host: z
-                .enum(['claude-code', 'codex', 'gemini', 'auto'])
-                .default('auto')
-                .describe('Target host or auto-detection.'),
-            overwriteExisting: z
-                .boolean()
-                .optional()
-                .describe('When true, overwrite an existing file with different content.'),
-        },
-        annotations: { readOnlyHint: false, destructiveHint: false, title: 'Create Rule' },
-    }, safe((args) => handleCreateRule(args)));
     s.registerTool('create_skill', {
         description: 'Create a host-aware skill for a Planu project. For Claude Code, writes to `.claude/skills/{name}/SKILL.md`. For Codex, inserts a skill block in `AGENTS.md`. For Gemini, writes to `.gemini/skills/{name}.md`. Use host: "auto" to detect the current host automatically.',
         inputSchema: {

package/dist/tools/register-spec-tools/core-spec-tools.js

@@ -7,7 +7,6 @@ import { handleSetLocale } from '../set-locale.js';
 import { handleInitProject } from '../init-project.js';
 import { handleSetWorkMode } from '../set-work-mode-handler.js';
 import { handleInitConstitution } from '../init-constitution.js';
-import { handleClarifyRequirements } from '../clarify-requirements.js';
 import { handleCreateSpec } from '../create-spec.js';
 import { handleListSpecs } from '../list-specs.js';
 import { handleUpdateStatus } from '../update-status.js';
@@ -159,32 +158,6 @@ export function registerCoreSpecTools(server) {
                 .describe('Manual principles to include'),
         },
     }, safeTracked('init_constitution', async (args) => handleInitConstitution(args)));
-    // 4. clarify_requirements
-    server.registerTool('clarify_requirements', {
-        description: t('tools.clarify_requirements.description'),
-        inputSchema: {
-            projectId: z.string().max(500).describe('Project ID'),
-            topic: z.string().max(500).describe('The topic or feature to clarify'),
-            context: z
-                .string()
-                .max(10_000)
-                .optional()
-                .describe('Additional context about the requirement'),
-            maxQuestions: z
-                .number()
-                .optional()
-                .describe('Maximum number of questions to generate (default: 5)'),
-            sessionId: z
-                .string()
-                .max(500)
-                .optional()
-                .describe('Existing clarification session to resume with user-confirmed answers.'),
-            answers: z
-                .record(z.string(), z.string())
-                .optional()
-                .describe('Explicit user-confirmed answers keyed by clarification question ID.'),
-        },
-    }, safeTracked('clarify_requirements', async (args) => handleClarifyRequirements(args, server)));
     // 5. create_spec
     server.registerTool('create_spec', {
         description: t('tools.create_spec.description'),
@@ -432,6 +405,24 @@ export function registerCoreSpecTools(server) {
                 .max(10_000)
                 .optional()
                 .describe('Optional notes for each transition.'),
+            evidence: z
+                .record(z.string(), z.object({
+                modelTierUsed: z
+                    .enum(['max', 'implementation', 'review'])
+                    .optional()
+                    .describe('Model tier used for this spec.'),
+                modelId: z.string().optional().describe('Model ID used for this spec.'),
+                contextHash: z.string().optional().describe('Context hash for this spec.'),
+                handoffPath: z.string().optional().describe('Handoff artifact path for this spec.'),
+                handoffArtifactId: z
+                    .string()
+                    .optional()
+                    .describe('Handoff artifact ID for this spec.'),
+                reviewedBy: z.string().optional().describe('Reviewer identity for this spec.'),
+                arbitratedBy: z.string().optional().describe('Arbitrator identity for this spec.'),
+            }))
+                .optional()
+                .describe('Per-spec model-routing evidence keyed by spec ID. Required for status approved or implementing: each entry supplies modelTierUsed, modelId, contextHash and handoffPath for that spec.'),
         },
     }, safeTracked('update_status_batch', async (args) => handleUpdateStatusBatch(args)));
     // 8. estimate

package/dist/tools/schemas/index.d.ts

@@ -16,7 +16,7 @@ export { TokenIntelligencePeriodEnum, TokenIntelligenceGroupByEnum, TokenIntelli
 export { ProjectGraphActionEnum, ProjectGraphQueryKindEnum } from './project-graph.js';
 export { ConfigureLLMProvidersActionEnum, LoadBalancingStrategyEnum, } from './llm-provider-schemas.js';
 export { PluginActionEnum } from './plugins-schemas.js';
-export { ListSpecsOutputSchema, EstimateOutputSchema, ValidateOutputSchema, CheckReadinessOutputSchema, } from './output-schemas.js';
+export { ListSpecsOutputSchema, EstimateOutputSchema, ValidateOutputSchema, CheckReadinessOutputSchema, PackageHandoffOutputSchema, } from './output-schemas.js';
 export { CreatePRFromSpecSchema, PRStatusSchema, ReviewPRSchema, CreateReleaseSchema, GenerateChangelogSchema, } from './github.js';
 export { SkillSearchInputSchema, SkillInstallInputSchema } from './skill-registry-schemas.js';
 export { EcosystemStatusInputSchema } from './ecosystem-schemas.js';

package/dist/tools/schemas/index.js

@@ -17,7 +17,7 @@ export { TokenIntelligencePeriodEnum, TokenIntelligenceGroupByEnum, TokenIntelli
 export { ProjectGraphActionEnum, ProjectGraphQueryKindEnum } from './project-graph.js';
 export { ConfigureLLMProvidersActionEnum, LoadBalancingStrategyEnum, } from './llm-provider-schemas.js';
 export { PluginActionEnum } from './plugins-schemas.js';
-export { ListSpecsOutputSchema, EstimateOutputSchema, ValidateOutputSchema, CheckReadinessOutputSchema, } from './output-schemas.js';
+export { ListSpecsOutputSchema, EstimateOutputSchema, ValidateOutputSchema, CheckReadinessOutputSchema, PackageHandoffOutputSchema, } from './output-schemas.js';
 export { CreatePRFromSpecSchema, PRStatusSchema, ReviewPRSchema, CreateReleaseSchema, GenerateChangelogSchema, } from './github.js';
 export { SkillSearchInputSchema, SkillInstallInputSchema } from './skill-registry-schemas.js';
 export { EcosystemStatusInputSchema } from './ecosystem-schemas.js';

package/dist/tools/schemas/output-schemas.d.ts

@@ -33,16 +33,7 @@ export declare const ListSpecsOutputSchema: {
         totalReviewHours: z.ZodNumber;
         totalCostUsd: z.ZodNumber;
     }, z.core.$strip>;
-    teamSuggestion: z.ZodNullable<z.ZodObject<{
-        recommended: z.ZodBoolean;
-        reason: z.ZodString;
-        templateId: z.ZodString;
-        teamSize: z.ZodNumber;
-        specs: z.ZodArray<z.ZodString>;
-        toolCalls: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
     message: z.ZodString;
-    teamDistributionHint: z.ZodOptional<z.ZodString>;
     humanSummary: z.ZodOptional<z.ZodString>;
     branchInfo: z.ZodOptional<z.ZodObject<{
         current: z.ZodString;
@@ -126,16 +117,7 @@ export declare const ListSpecsOutputObjectSchema: z.ZodObject<{
         totalReviewHours: z.ZodNumber;
         totalCostUsd: z.ZodNumber;
     }, z.core.$strip>;
-    teamSuggestion: z.ZodNullable<z.ZodObject<{
-        recommended: z.ZodBoolean;
-        reason: z.ZodString;
-        templateId: z.ZodString;
-        teamSize: z.ZodNumber;
-        specs: z.ZodArray<z.ZodString>;
-        toolCalls: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
     message: z.ZodString;
-    teamDistributionHint: z.ZodOptional<z.ZodString>;
     humanSummary: z.ZodOptional<z.ZodString>;
     branchInfo: z.ZodOptional<z.ZodObject<{
         current: z.ZodString;
@@ -217,6 +199,7 @@ export declare const EstimateOutputSchema: {
     calibrationApplied: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 };
 export { ValidateCompletionOutputSchema, ValidateOutputSchema } from './validate-output-schema.js';
+export { PackageHandoffOutputSchema } from './package-handoff-output-schema.js';
 export declare const CheckReadinessOutputSchema: {
     specId: z.ZodString;
     score: z.ZodNumber;

package/dist/tools/schemas/output-schemas.js

@@ -39,18 +39,7 @@ export const ListSpecsOutputSchema = {
         totalReviewHours: z.number(),
         totalCostUsd: z.number(),
     }),
-    teamSuggestion: z
-        .object({
-        recommended: z.boolean(),
-        reason: z.string(),
-        templateId: z.string(),
-        teamSize: z.number(),
-        specs: z.array(z.string()),
-        toolCalls: z.array(z.string()),
-    })
-        .nullable(),
     message: z.string(),
-    teamDistributionHint: z.string().optional(),
     humanSummary: z.string().optional(),
     branchInfo: z
         .object({
@@ -142,6 +131,7 @@ export const EstimateOutputSchema = {
 };
 // ── validate ────────────────────────────────────────────────────────────────
 export { ValidateCompletionOutputSchema, ValidateOutputSchema } from './validate-output-schema.js';
+export { PackageHandoffOutputSchema } from './package-handoff-output-schema.js';
 // ── check_readiness ─────────────────────────────────────────────────────────
 export const CheckReadinessOutputSchema = {
     specId: z.string(),

package/dist/tools/schemas/package-handoff-output-schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+/** Exact public structured-output contract for the package_handoff MCP tool submission ack. */
+export declare const PackageHandoffOutputSchema: {
+    schemaVersion: z.ZodLiteral<1>;
+    operationId: z.ZodString;
+    projectId: z.ZodString;
+    workspaceId: z.ZodString;
+    state: z.ZodEnum<{
+        accepted: "accepted";
+        cancelled: "cancelled";
+        checkpointed: "checkpointed";
+        completed: "completed";
+        "dead-letter": "dead-letter";
+        failed: "failed";
+        running: "running";
+    }>;
+    submittedAt: z.ZodISODateTime;
+    attachedAt: z.ZodISODateTime;
+    reused: z.ZodBoolean;
+    cursor: z.ZodString;
+    queue: z.ZodObject<{
+        status: z.ZodEnum<{
+            active: "active";
+            queued: "queued";
+            terminal: "terminal";
+        }>;
+        position: z.ZodNullable<z.ZodNumber>;
+        aheadCount: z.ZodNumber;
+        capacity: z.ZodNumber;
+        remainingBudgetMs: z.ZodNumber;
+    }, z.core.$strip>;
+    terminalStates: z.ZodTuple<[z.ZodLiteral<"completed">, z.ZodLiteral<"failed">, z.ZodLiteral<"cancelled">, z.ZodLiteral<"dead-letter">], null>;
+    resultSchema: z.ZodLiteral<"package-handoff-completion/v1">;
+    observation: z.ZodObject<{
+        get: z.ZodLiteral<"get_job">;
+        restart: z.ZodLiteral<"restart_job">;
+    }, z.core.$strip>;
+    recoveryAction: z.ZodOptional<z.ZodLiteral<"restart_job">>;
+};
+//# sourceMappingURL=package-handoff-output-schema.d.ts.map

package/dist/tools/schemas/package-handoff-output-schema.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+/** Exact public structured-output contract for the package_handoff MCP tool submission ack. */
+export const PackageHandoffOutputSchema = {
+    schemaVersion: z.literal(1).describe('Ack schema version.'),
+    operationId: z
+        .string()
+        .min(1)
+        .max(128)
+        .describe('Deterministic durable job id, form handoff-<sha256 hex>.'),
+    projectId: z.string().min(1).max(128).describe('Canonical project identity.'),
+    workspaceId: z.string().min(1).max(128).describe('Durable job workspace scope.'),
+    state: z
+        .enum([
+        'accepted',
+        'running',
+        'checkpointed',
+        'completed',
+        'failed',
+        'cancelled',
+        'dead-letter',
+    ])
+        .describe('Current durable job state at submission or reuse time.'),
+    submittedAt: z.iso.datetime().describe('When this job was first accepted.'),
+    attachedAt: z.iso.datetime().describe('When this request attached to the job.'),
+    reused: z
+        .boolean()
+        .describe('True when this request attached to an existing job instead of inserting a new one.'),
+    cursor: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/)
+        .describe('Content-derived observation cursor.'),
+    queue: z.object({
+        status: z.enum(['active', 'queued', 'terminal']).describe('Queue lifecycle bucket.'),
+        position: z
+            .number()
+            .int()
+            .positive()
+            .nullable()
+            .describe('1-based queue position, null once terminal.'),
+        aheadCount: z
+            .number()
+            .int()
+            .nonnegative()
+            .describe('Jobs ahead of this one in the same scope.'),
+        capacity: z.number().int().positive().describe('Worker concurrency capacity for this scope.'),
+        remainingBudgetMs: z.number().int().nonnegative().describe('Remaining execution budget in ms.'),
+    }),
+    terminalStates: z
+        .tuple([
+        z.literal('completed'),
+        z.literal('failed'),
+        z.literal('cancelled'),
+        z.literal('dead-letter'),
+    ])
+        .describe('The states get_job should treat as terminal.'),
+    resultSchema: z
+        .literal('package-handoff-completion/v1')
+        .describe('Result payload schema id once completed.'),
+    observation: z.object({
+        get: z.literal('get_job').describe('Tool to poll for job progress and result.'),
+        restart: z.literal('restart_job').describe('Tool to reactivate a terminal-failed job.'),
+    }),
+    recoveryAction: z
+        .literal('restart_job')
+        .optional()
+        .describe('Present when the reused job ended terminal-failed/cancelled/dead-letter and needs restart_job.'),
+};
+//# sourceMappingURL=package-handoff-output-schema.js.map

package/dist/tools/schemas/validate-output-schema.d.ts

@@ -252,6 +252,7 @@ export declare const ValidateOutputSchema: {
     }>;
     submittedAt: z.ZodISODateTime;
     attachedAt: z.ZodISODateTime;
+    reused: z.ZodBoolean;
     cursor: z.ZodString;
     queue: z.ZodObject<{
         status: z.ZodEnum<{
@@ -268,8 +269,6 @@ export declare const ValidateOutputSchema: {
     resultSchema: z.ZodLiteral<"validate-completion/v1">;
     observation: z.ZodObject<{
         get: z.ZodLiteral<"get_job">;
-        watch: z.ZodLiteral<"watch_job">;
-        cancel: z.ZodLiteral<"cancel_job">;
         restart: z.ZodLiteral<"restart_job">;
     }, z.core.$strip>;
 };

package/dist/tools/schemas/validate-output-schema.js

@@ -197,6 +197,9 @@ export const ValidateOutputSchema = {
     state: z.enum(['accepted', 'running', 'checkpointed']),
     submittedAt: z.iso.datetime(),
     attachedAt: z.iso.datetime(),
+    reused: z
+        .boolean()
+        .describe('True when this request attached to an already-running validation job instead of dispatching new work.'),
     cursor: z.string().regex(/^[a-f0-9]{64}$/),
     queue: z.object({
         status: z.enum(['active', 'queued', 'terminal']),
@@ -214,8 +217,6 @@ export const ValidateOutputSchema = {
     resultSchema: z.literal('validate-completion/v1'),
     observation: z.object({
         get: z.literal('get_job'),
-        watch: z.literal('watch_job'),
-        cancel: z.literal('cancel_job'),
         restart: z.literal('restart_job'),
     }),
 };

package/dist/tools/session-checkpoint.js

@@ -1,5 +1,5 @@
 // tools/session-checkpoint.ts — Manual trigger for session checkpoint (SPEC-563).
-import { sessionTracker } from '../engine/session/session-tracker.js';
+import { getSessionTracker } from '../engine/session/session-tracker.js';
 import { writeCheckpoint } from '../engine/session/checkpoint-writer.js';
 import { compactResult } from './output-formatter.js';
 /**
@@ -7,7 +7,7 @@ import { compactResult } from './output-formatter.js';
  * Writes a checkpoint immediately regardless of the call-count threshold.
  */
 export async function handleSessionCheckpoint(args) {
-    const snapshot = sessionTracker.getSnapshot();
+    const snapshot = getSessionTracker(args.projectPath).getSnapshot();
     await writeCheckpoint(args.projectPath, snapshot);
     return compactResult(`Session checkpoint written to ${args.projectPath}/planu/.runtime/session-context.md\n` +
         `Calls recorded: ${String(snapshot.callCount)}, ` +

package/dist/tools/skill-registry/index.d.ts

@@ -1,3 +1,2 @@
-export { handleSkillSearch } from './search.js';
 export { handleSkillInstall } from './install.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/skill-registry/index.js

@@ -1,4 +1,3 @@
 // tools/skill-registry/index.ts — Barrel for skill registry tool handlers (SPEC-150)
-export { handleSkillSearch } from './search.js';
 export { handleSkillInstall } from './install.js';
 //# sourceMappingURL=index.js.map

package/dist/tools/sync-spec-state-handler.d.ts

@@ -1,10 +1,10 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { SyncReport } from '../types/index.js';
+import type { SyncReport, SyncSpecStateOptions } from '../types/index.js';
 /**
  * Sync spec state for a single project.
  * Reads YAML frontmatter from spec.md files and reconciles divergences into the store.
  */
-export declare function syncSpecState(projectPath: string, projectId: string): Promise<SyncReport>;
+export declare function syncSpecState(projectPath: string, projectId: string, options?: SyncSpecStateOptions): Promise<SyncReport>;
 /**
  * Startup sync: iterates all registered projects and calls syncSpecState for each.
  * Non-blocking — errors are logged but not propagated.

package/dist/tools/sync-spec-state-handler.js

@@ -20,7 +20,8 @@ import { readFile, stat } from 'node:fs/promises';
  * Sync spec state for a single project.
  * Reads YAML frontmatter from spec.md files and reconciles divergences into the store.
  */
-export async function syncSpecState(projectPath, projectId) {
+export async function syncSpecState(projectPath, projectId, options = {}) {
+    const { applyTransitions = true } = options;
     let dataEntries;
     try {
         const specs = await listSpecs(projectId);
@@ -109,6 +110,14 @@ export async function syncSpecState(projectPath, projectId) {
             report.synced += 1;
             continue;
         }
+        if (!applyTransitions) {
+            report.rejected.push({ specId, reason: refusalReason });
+            const idx = report.divergences.findIndex((d) => d.specId === specId);
+            if (idx !== -1) {
+                report.divergences.splice(idx, 1);
+            }
+            continue;
+        }
         try {
             const result = await handleUpdateStatus({
                 specId,
@@ -205,13 +214,24 @@ export async function startupSync() {
     }
     await Promise.all(projects.map(async (project) => {
         try {
-            await syncSpecState(project.path, project.hash);
+            const report = await syncSpecState(project.path, project.hash, {
+                applyTransitions: false,
+            });
+            if (report.rejected.length > 0) {
+                console.error(`[Planu] startupSync: ${project.path} has ${report.rejected.length} spec status divergence(s) reported read-only:`, report.rejected);
+            }
         }
         catch (err) {
             console.error(`[Planu] startupSync: failed to sync project ${project.path}:`, err);
         }
         try {
-            await cleanEphemeralArtifacts({ projectPath: project.path, dryRun: false });
+            const cleanupResult = await cleanEphemeralArtifacts({
+                projectPath: project.path,
+                dryRun: true,
+            });
+            if (cleanupResult.wouldDelete.length > 0) {
+                console.error(`[Planu] startupSync: ${project.path} has ${cleanupResult.wouldDelete.length} ephemeral artifact(s) that would be deleted (run housekeeping-sweep to apply):`, cleanupResult.wouldDelete);
+            }
         }
         catch (err) {
             console.error(`[Planu] startupSync: failed to clean spec artifacts ${project.path}:`, err);

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

@@ -38,14 +38,13 @@ import { handleIdeConfig } from '../ide-config-handler.js';
 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';
 import { handleStoragePaths } from '../storage-paths-handler.js';
 import { handleStorageExport, handleStorageImport } from '../storage-bundle-handler.js';
-import { handleCancelJob, handleGetJob, handleRestartJob, handleWatchJob, } from '../jobs/handlers.js';
+import { handleGetJob, handleRestartJob } from '../jobs/handlers.js';
 // ── Registry ─────────────────────────────────────────────────────────────────
 const coreToolsRegistry = [
     {
@@ -81,48 +80,6 @@ const coreToolsRegistry = [
         wrap: 'safe',
         group: 'infrastructure',
     },
-    {
-        name: 'watch_job',
-        description: 'Wait up to 30 seconds for a durable Planu job to change or reach a terminal state.',
-        schema: {
-            operationId: z.string().trim().min(1).max(128),
-            projectId: z.string().trim().min(1).max(128),
-            workspaceId: z.string().trim().min(1).max(128).optional(),
-            afterCursor: z
-                .string()
-                .regex(/^[a-f0-9]{64}$/)
-                .optional(),
-            timeoutMs: z.number().int().min(0).max(30_000).optional(),
-        },
-        handler: handleWatchJob,
-        annotations: {
-            title: 'Watch Durable Job',
-            readOnlyHint: true,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-        wrap: 'safe',
-        group: 'infrastructure',
-    },
-    {
-        name: 'cancel_job',
-        description: 'Durably cancel a Planu job and fence any worker that still holds its former lease.',
-        schema: {
-            operationId: z.string().trim().min(1).max(128),
-            projectId: z.string().trim().min(1).max(128),
-            workspaceId: z.string().trim().min(1).max(128).optional(),
-        },
-        handler: handleCancelJob,
-        annotations: {
-            title: 'Cancel Durable Job',
-            readOnlyHint: false,
-            destructiveHint: true,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
-        wrap: 'safe',
-        group: 'infrastructure',
-    },
     {
         name: 'restart_job',
         description: 'Restart a cancelled or failed durable job and schedule its typed executor.',
@@ -899,102 +856,6 @@ const coreToolsRegistry = [
         wrap: 'tracked',
         group: 'core',
     },
-    // ── feedback hub (SPEC-188, SPEC-1100) ───────────────────────────────────
-    {
-        name: 'submit_feedback',
-        description: 'Submit user feedback or a bug report to Planu Feedback Hub. Always persists locally first, then attempts privacy-bounded remote registration with the central feedback intake.',
-        schema: {
-            type: z
-                .enum(['bug', 'feature', 'suggestion', 'dx'])
-                .describe('Feedback type: bug | feature | suggestion | dx'),
-            title: z.string().min(1).max(200).describe('Short feedback title'),
-            description: z.string().min(1).max(5000).describe('Detailed feedback description'),
-            context: z
-                .object({
-                projectPath: z.string().max(4096).optional(),
-                currentFile: z.string().max(4096).optional(),
-                errorMessage: z.string().max(2000).optional(),
-                stack: z.string().max(8000).optional(),
-            })
-                .optional()
-                .describe('Optional local-only context; sensitive path fields are not sent remotely.'),
-        },
-        handler: async (args) => handleSubmitFeedback(args),
-        annotations: {
-            title: 'Submit Feedback',
-            readOnlyHint: false,
-            destructiveHint: false,
-            openWorldHint: true,
-        },
-        wrap: 'tracked',
-        group: 'feedback',
-    },
-    {
-        name: 'triage_feedback',
-        description: 'Group pending local feedback by similarity so maintainers can decide whether to create specs, merge duplicates, or dismiss items.',
-        schema: {
-            filter: z
-                .enum(['bug', 'feature', 'suggestion', 'dx'])
-                .optional()
-                .describe('Optional feedback type filter'),
-        },
-        handler: async (args) => Promise.resolve(handleTriageFeedback(args)),
-        annotations: { title: 'Triage Feedback', readOnlyHint: true },
-        wrap: 'tracked',
-        group: 'feedback',
-    },
-    {
-        name: 'resolve_feedback',
-        description: 'Mark a local feedback item as resolved and optionally link it to a Planu spec, PR URL, and resolution notes.',
-        schema: {
-            feedbackId: z.string().min(1).max(50).describe('Local feedback ID, e.g. FB-001'),
-            specId: z.string().max(50).optional().describe('Optional linked Planu spec ID'),
-            prUrl: z.url().optional().describe('Optional pull request URL'),
-            notes: z.string().max(2000).optional().describe('Optional resolution notes'),
-        },
-        handler: async (args) => handleResolveFeedback(args),
-        annotations: { title: 'Resolve Feedback', readOnlyHint: false, destructiveHint: false },
-        wrap: 'tracked',
-        group: 'feedback',
-    },
-    {
-        name: 'sync_feedback',
-        description: 'Retry remote Supabase registration for local feedback entries whose delivery is pending or failed. Does not accept remote row IDs or perform direct SQL/Data API writes.',
-        schema: {
-            projectPath: z.string().max(4096).optional().describe('Absolute path to project root'),
-            includeSynced: z
-                .boolean()
-                .optional()
-                .describe('When true, also reprocess entries already marked synced. Default false.'),
-            limit: z
-                .number()
-                .int()
-                .positive()
-                .max(500)
-                .optional()
-                .describe('Maximum number of local entries to process.'),
-        },
-        handler: async (args) => handleSyncFeedback(args),
-        annotations: {
-            title: 'Sync Feedback',
-            readOnlyHint: false,
-            destructiveHint: false,
-            openWorldHint: true,
-        },
-        wrap: 'tracked',
-        group: 'feedback',
-    },
-    {
-        name: 'feedback_status',
-        description: 'Show aggregate local feedback totals and remote delivery health without exposing descriptions, file paths, user identifiers, or secrets.',
-        schema: {
-            projectPath: z.string().max(4096).optional().describe('Absolute path to project root'),
-        },
-        handler: async (args) => Promise.resolve(handleFeedbackStatus(args)),
-        annotations: { title: 'Feedback Status', readOnlyHint: true },
-        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.',