@planu/cli 4.14.1 → 5.0.0

package/dist/tools/git/branch-ops.d.ts

@@ -1,5 +1,5 @@
 import type { ToolResult, GitConfig } from '../../types/index.js';
-export declare function handleCreateBranch(projectId: string, specId: string | undefined, config?: GitConfig): Promise<ToolResult>;
+export declare function handleCreateBranch(projectId: string, specId: string | undefined, config?: GitConfig, resolvedProjectPath?: string): Promise<ToolResult>;
 export declare function handleCheckBranch(projectId: string, _specId: string | undefined, config?: GitConfig): Promise<ToolResult>;
 /**
  * Auto-setup: detect git workflow, sync base branch, create feature branch.

package/dist/tools/git/branch-ops.js

@@ -19,11 +19,12 @@ function randomSuffix() {
         .toString(16)
         .padStart(8, '0');
 }
-export async function handleCreateBranch(projectId, specId, config) {
+export async function handleCreateBranch(projectId, specId, config, resolvedProjectPath) {
     if (!specId) {
         return compactError('❌ Error: specId is required for create-branch action');
     }
-    const projectPath = await resolveProjectPath(projectId);
+    const suppliedPath = resolvedProjectPath?.trim();
+    const projectPath = suppliedPath && suppliedPath.length > 0 ? suppliedPath : await resolveProjectPath(projectId);
     const spec = await specStore.getSpec(projectId, specId);
     if (!spec) {
         return compactError(`❌ Error: Spec '${specId}' not found`);

package/dist/tools/init-project/handler.js

@@ -2,13 +2,11 @@ import { technologyValue } from '../../engine/technology-registry.js';
 import { elicitOrFallback, questionsToFormSchema } from '../../engine/elicitation/elicit-helper.js';
 import { ti } from '../../i18n/index.js';
 import { AutopilotSummaryCollector } from '../../engine/autopilot/summary-collector.js';
-import { knowledgeStore, globalStore, licenseStore, technologySelectionStore, projectDataDir, } from '../../storage/index.js';
+import { knowledgeStore, globalStore, technologySelectionStore, projectDataDir, } from '../../storage/index.js';
 import { migrateCanonicalStorage } from '../../storage/migrations/canonical-storage.js';
 import { deriveWorkspaceKey, ensureProjectIdentity } from '../../storage/project-identity.js';
 import { resolveStorageLayout } from '../../storage/storage-layout.js';
 import { addProject } from '../../storage/global-projects-store.js';
-import { getCurrentTier } from '../license-gate.js';
-import { checkLimits } from '../../engine/license-validator.js';
 import { analyzeProject, checkProjectCompleteness } from '../../engine/analyzer.js';
 import { parseProjectQualityRules } from '../../engine/auditor-claude-md.js';
 import { detectMissingAreas, buildRequestPrompt } from '../../engine/context-merger.js';
@@ -22,6 +20,7 @@ import { regeneratePages } from '../../engine/doc-generator/portal/index.js';
 import { detectStackPatterns } from './stack-detector.js';
 import { buildProjectConfig } from './config-builder.js';
 import { runSpecMigrations, listProjectSpecs } from './migration-runner.js';
+import { reconcilePortableSpecIndex } from './portable-index-reconciler.js';
 import { runScaffoldWriter } from './scaffold-writer.js';
 import { readAutoInstallFlag, orchestrateSkillInstalls, runHealthCheckWithBaseline, runConventionScanSafe, fireTelemetry, } from './lifecycle-helpers.js';
 import { injectProactiveRules } from '../../engine/claude-md-injector/index.js';
@@ -195,20 +194,26 @@ export async function handleInitProject(params, server) {
             const isUpdate = hadProjectIdentity || existing !== null;
             const authorizedMigrations = params.authorizedMigrations ?? [];
             if (isUpdate && authorizedMigrations.length === 0) {
+                const reconciliation = await reconcilePortableSpecIndex(projectPath, projectId);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: 'Project already initialized. Safe update completed without changing repository files.',
+                            text: reconciliation.failures.length === 0
+                                ? 'Project already initialized. Safe update reconciled the portable spec index without changing repository files.'
+                                : `Portable spec index reconciliation failed for ${String(reconciliation.failures.length)} contract(s).`,
                         },
                     ],
                     structuredContent: {
                         projectId,
-                        projectPath,
+                        ...(reconciliation.failures.length === 0 ? { projectPath } : {}),
                         isUpdate: true,
                         repositoryFilesChanged: [],
                         authorizedMigrations: [],
+                        importedSpecIds: reconciliation.importedSpecIds,
+                        failures: reconciliation.failures,
                     },
+                    ...(reconciliation.failures.length > 0 ? { isError: true } : {}),
                 };
             }
             if (isUpdate) {
@@ -247,13 +252,6 @@ export async function handleInitProject(params, server) {
                     ...(migrationResult.criticalMigrationFailures.length > 0 ? { isError: true } : {}),
                 };
             }
-            // The update branches returned above; only new projects reach the limit gate.
-            const tier = await getCurrentTier();
-            const projectCount = await licenseStore.countActiveProjects();
-            const limitCheck = checkLimits(tier, projectCount, 'maxProjects');
-            if (!limitCheck.allowed) {
-                return { content: [{ type: 'text', text: limitCheck.message }], isError: true };
-            }
             // Get global config for defaults
             const globalConfig = await globalStore.getGlobalConfig();
             const effectiveLocale = locale ?? globalConfig.defaultLocale;

package/dist/tools/init-project/host-assets-writer.js

@@ -99,6 +99,28 @@ async function readCoreSkillTemplate(fileName) {
         return null;
     }
 }
+function coreSkillPath(projectPath, host, name) {
+    if (host === 'codex') {
+        return join(projectPath, 'AGENTS.md');
+    }
+    if (host === 'gemini') {
+        return join(projectPath, '.gemini', 'skills', `${name}.md`);
+    }
+    return join(projectPath, '.claude', 'skills', name, 'SKILL.md');
+}
+async function canRefreshCoreSkill(projectPath, host, name) {
+    try {
+        const existing = await readFile(coreSkillPath(projectPath, host, name), 'utf-8');
+        if (host === 'codex') {
+            return (existing.includes(`<!-- planu:skills:${name} -->`) ||
+                !existing.includes(`## Skill: ${name}`));
+        }
+        return existing.includes(`name: ${name}`) && existing.includes(`# /${name}`);
+    }
+    catch {
+        return true;
+    }
+}
 async function installCoreSkillsForHost(projectPath, host) {
     const installed = [];
     for (const fileName of CORE_SKILL_TEMPLATES) {
@@ -106,13 +128,16 @@ async function installCoreSkillsForHost(projectPath, host) {
         if (template === null) {
             continue;
         }
+        if (!(await canRefreshCoreSkill(projectPath, host, template.name))) {
+            continue;
+        }
         const result = await handleCreateSkill({
             projectPath,
             host,
             name: template.name,
             description: template.description,
             content: template.content,
-            overwriteExisting: false,
+            overwriteExisting: true,
         });
         if (result.isError === true) {
             continue;

package/dist/tools/init-project/lint-scaffolder.d.ts

@@ -1,5 +1,5 @@
 import type { ProjectKnowledge } from '../../types/project/core.js';
-import type { ScaffoldResult } from '../../types/project/lint-scaffolder.js';
-export type { ScaffoldResult };
-export declare function scaffoldLintConfig(projectPath: string, knowledge: ProjectKnowledge): Promise<ScaffoldResult>;
+import type { LintScaffoldResult } from '../../types/project/lint-scaffolder.js';
+export type { LintScaffoldResult as ScaffoldResult };
+export declare function scaffoldLintConfig(projectPath: string, knowledge: ProjectKnowledge): Promise<LintScaffoldResult>;
 //# sourceMappingURL=lint-scaffolder.d.ts.map

package/dist/tools/init-project/migration-runner.d.ts

@@ -1,3 +1,4 @@
+import { reconcilePortableSpecIndex } from './portable-index-reconciler.js';
 import type { ProjectKnowledge, Spec } from '../../types/index.js';
 export interface MigrationRunIssue {
     phase: string;
@@ -11,10 +12,7 @@ export interface MigrationRunResult {
         renamedCount: number;
         errors: string[];
     } | null;
-    filesystemImportResult: {
-        importedCount: number;
-        errors: string[];
-    } | null;
+    filesystemImportResult: Awaited<ReturnType<typeof reconcilePortableSpecIndex>> | null;
     migrationResult: {
         migratedCount: number;
         errors: string[];

package/dist/tools/init-project/migration-runner.js

@@ -1,7 +1,8 @@
 // tools/init-project/migration-runner.ts — Spec migration orchestration during init_project
 import { specStore, knowledgeStore } from '../../storage/index.js';
 import { projectDataDir, writeJson } from '../../storage/base-store.js';
-import { filterLegacySpecs, migrateSpecs, filterUnprefixedSpecs, migrateSpecFolderNames, discoverAndFlattenSpecs, reconcileSpecPaths, migrateAllSpecsToLean, importFilesystemSpecs, } from '../../engine/spec-migrator.js';
+import { filterLegacySpecs, migrateSpecs, filterUnprefixedSpecs, migrateSpecFolderNames, discoverAndFlattenSpecs, reconcileSpecPaths, migrateAllSpecsToLean, } from '../../engine/spec-migrator.js';
+import { reconcilePortableSpecIndex } from './portable-index-reconciler.js';
 import { createHash } from 'node:crypto';
 import { lstat, readFile, readdir, readlink } from 'node:fs/promises';
 import { join, relative } from 'node:path';
@@ -78,7 +79,7 @@ export async function runSpecMigrations(projectPath, projectId, knowledge, optio
     // This is required after a storage-root migration or a clean-machine import.
     let filesystemImportResult = null;
     try {
-        filesystemImportResult = await importFilesystemSpecs(projectPath, { listSpecs: specStore.listSpecs, createSpec: specStore.createSpec }, projectId);
+        filesystemImportResult = await reconcilePortableSpecIndex(projectPath, projectId);
         criticalMigrationFailures.push(...issuesFromMessages('filesystem-spec-import', 'critical', filesystemImportResult.errors));
     }
     catch (err) {

package/dist/tools/init-project/portable-index-reconciler.d.ts

@@ -0,0 +1,4 @@
+import type { FilesystemImportDeps, PortableIndexReconciliationResult } from '../../types/index.js';
+/** Rebuild the mutable external index from the repository-owned portable contracts. */
+export declare function reconcilePortableSpecIndex(projectPath: string, projectId: string, deps?: FilesystemImportDeps): Promise<PortableIndexReconciliationResult>;
+//# sourceMappingURL=portable-index-reconciler.d.ts.map

package/dist/tools/init-project/portable-index-reconciler.js

@@ -0,0 +1,14 @@
+import { specStore } from '../../storage/index.js';
+import { importFilesystemSpecs } from '../../engine/spec-migrator/filesystem-import.js';
+/** Rebuild the mutable external index from the repository-owned portable contracts. */
+export async function reconcilePortableSpecIndex(projectPath, projectId, deps = {
+    listSpecs: specStore.listSpecs,
+    createSpec: specStore.createSpec,
+    getSpecFresh: specStore.getSpecFresh,
+}) {
+    const result = await importFilesystemSpecs(projectPath, deps, projectId, {
+        strictPortableContract: true,
+    });
+    return { ...result, repositoryFilesChanged: [] };
+}
+//# sourceMappingURL=portable-index-reconciler.js.map

package/dist/tools/init-project/result-builder.js

@@ -193,9 +193,8 @@ export function buildInitProjectResult(input) {
     const framework = result.framework ?? 'no framework detected';
     const action = isUpdate ? 'updated' : 'initialized';
     const telemetryNote = input.telemetryOptInPrompt
-        ? `\n\n---\n💡 **Help improve Planu** — run \`configure_telemetry\` with action=enable to share anonymous usage stats (no paths, no emails, no personal data). You can opt out anytime.`
+        ? `\n\n---\n💡 **Help improve Planu** — run \`configure_telemetry\` with action=enable, then set a valid \`PLANU_TELEMETRY_ENDPOINT\` and secret \`PLANU_TELEMETRY_TOKEN\` to share anonymous usage stats (no paths, no emails, no personal data). You can opt out anytime.`
         : '';
-    const trialNote = '';
     const tokenTip = `\n\n💡 Token tip: Add CLAUDE_CODE_SUBAGENT_MODEL=haiku to your .env — makes all read-only subagents ` +
         `(search, grep, file reads) use Haiku instead of your session model (4–18x cheaper for those tasks).`;
     const narrative = ti('tools.init_project.success', { projectPath: result.projectPath }) +
@@ -206,7 +205,6 @@ export function buildInitProjectResult(input) {
                 `See migrationReportPath in structuredContent${input.migrationReportPath ? ` (${input.migrationReportPath})` : ''}.`
             : '') +
         telemetryNote +
-        trialNote +
         tokenTip;
     // SPEC-491: Build interactiveQuestions for decisions that require user input
     const interactiveQuestions = [];

package/dist/tools/jobs/handlers.js

@@ -50,20 +50,44 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { durableJobCursor, DurableJobRuntime } from '../../engine/execution/job-runtime.js';
+import { DurableJobRuntime, publicJobCursor } from '../../engine/execution/job-runtime.js';
 import { scheduleValidateJobExecution } from '../../engine/execution/validate-job-executor.js';
+import { isValidationReceiptPendingIntent, parseValidationReceiptPendingCheckpoint, } from '../../types/durable-validation.js';
+import { redactText } from '../../security/redactor.js';
+import { getRuntimePolicy } from '../../engine/runtime-policy.js';
 function result(payload) {
     return {
         content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
         structuredContent: payload,
     };
 }
+function publicJob(runtime, job) {
+    const sanitized = runtime.observe(job);
+    if (job.state === 'completed') {
+        const { checkpoint: _checkpoint, error: _error, ...completed } = sanitized;
+        return completed;
+    }
+    if (!parseValidationReceiptPendingCheckpoint(job.checkpoint, checkpointLimits())) {
+        return sanitized;
+    }
+    const errorMessage = job.error === undefined ? RECEIPT_PENDING_MESSAGE : redactText(job.error);
+    return { ...sanitized, error: errorMessage, errorMessage };
+}
+const RECEIPT_PENDING_MESSAGE = '[Planu] VALIDATION_RECEIPT_PENDING action=restart_job';
+function checkpointLimits() {
+    const policy = getRuntimePolicy().validation;
+    return {
+        logMaxBytes: policy.receiptCheckpointLogMaxBytes,
+        resultMaxBytes: policy.receiptCheckpointResultMaxBytes,
+    };
+}
 export function handleGetJob(input) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const runtime = __addDisposableResource(env_1, new DurableJobRuntime(), false);
         const job = runtime.get(input);
-        return Promise.resolve(result({ schemaVersion: 1, job, cursor: durableJobCursor(job) }));
+        const observation = publicJob(runtime, job);
+        return Promise.resolve(result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) }));
     }
     catch (e_1) {
         env_1.error = e_1;
@@ -78,7 +102,8 @@ export async function handleWatchJob(input) {
     try {
         const runtime = __addDisposableResource(env_2, new DurableJobRuntime(), false);
         const job = await runtime.watch(input);
-        return result({ schemaVersion: 1, job, cursor: durableJobCursor(job) });
+        const observation = publicJob(runtime, job);
+        return result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) });
     }
     catch (e_2) {
         env_2.error = e_2;
@@ -93,7 +118,8 @@ export function handleCancelJob(input) {
     try {
         const runtime = __addDisposableResource(env_3, new DurableJobRuntime(), false);
         const job = runtime.cancel(input);
-        return Promise.resolve(result({ schemaVersion: 1, job, cursor: durableJobCursor(job) }));
+        const observation = publicJob(runtime, job);
+        return Promise.resolve(result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) }));
     }
     catch (e_3) {
         env_3.error = e_3;
@@ -107,13 +133,19 @@ export function handleRestartJob(input) {
     const env_4 = { stack: [], error: void 0, hasError: false };
     try {
         const runtime = __addDisposableResource(env_4, new DurableJobRuntime(), false);
-        const job = runtime.restart(input);
+        const current = runtime.get(input);
+        const pending = parseValidationReceiptPendingCheckpoint(current.checkpoint, checkpointLimits());
+        if (!pending && isValidationReceiptPendingIntent(current.checkpoint)) {
+            throw new Error('[Planu] Invalid validation receipt checkpoint');
+        }
+        const job = pending ? runtime.restartReceiptPublication(input) : runtime.restart(input);
         if (job.payload &&
             typeof job.payload === 'object' &&
             job.payload.kind === 'validate') {
             scheduleValidateJobExecution(job.projectId, job.workspaceId);
         }
-        return Promise.resolve(result({ schemaVersion: 1, job, cursor: durableJobCursor(job) }));
+        const observation = publicJob(runtime, job);
+        return Promise.resolve(result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) }));
     }
     catch (e_4) {
         env_4.error = e_4;

package/dist/tools/list-specs.js

@@ -1,15 +1,13 @@
 import { ti } from '../i18n/index.js';
 import { specStore, knowledgeStore } from '../storage/index.js';
 import { buildListSpecsSummary } from '../engine/human-summary.js';
-import { dirname } from 'node:path';
 import { checkBundledVersionGap } from '../engine/version-detector/bundled-version-checker.js';
-import { readLastModifiedTimestamp, formatRelativeDate } from '../engine/spec-changelog/index.js';
+import { formatRelativeDate } from '../engine/time/relative-date.js';
 import { scanForAmbiguousCriteria } from '../engine/spec-migrator.js';
 import { detectDrift, formatDriftMessage } from '../engine/spec-migrator/drift-detector.js';
 import { AutopilotSummaryCollector } from '../engine/autopilot/summary-collector.js';
 import { trackCost } from '../engine/cost-tracking/operation-tracker.js';
 import { resolveProjectIdOrAutoDetect } from './resolve-project-id.js';
-import { isNativeActive, fastScanSpecs } from '../engine/core-bridge.js';
 /** Track which projects have been auto-discovered this session (once per project). */
 const discoveredProjects = new Set();
 const MAX_STRUCTURED_SPECS = 50;
@@ -94,11 +92,6 @@ export async function handleListSpecs(params) {
                     isError: true,
                 };
             }
-            // ─── Native optimized scan (SPEC-1004) ──────────────────────────────────
-            let nativeBriefs = null;
-            if (detail === 'full' && isNativeActive() && knowledge.projectPath) {
-                nativeBriefs = fastScanSpecs(knowledge.projectPath);
-            }
             // Read-only project signals only. Mutating discovery/migration/repair belongs
             // to init, validate, housekeeping, or explicit migration tools.
             if (detail === 'full' && knowledge.projectPath) {
@@ -129,27 +122,13 @@ export async function handleListSpecs(params) {
             const totalDevHours = safeSpecs.reduce((sum, s) => sum + (s.estimation?.devHours ?? 0), 0);
             const totalReviewHours = safeSpecs.reduce((sum, s) => sum + (s.estimation?.reviewHours ?? 0), 0);
             const totalCostUsd = safeSpecs.reduce((sum, s) => sum + (s.estimation?.totalCostUsd ?? 0), 0);
-            // Fetch last modified timestamps from changelogs (AC-09)
+            // Render canonical spec metadata without reading spec-local sidecars.
             const lastModifiedMap = new Map();
-            if (nativeBriefs) {
-                for (const b of nativeBriefs) {
-                    if (b.lastModified) {
-                        lastModifiedMap.set(b.id, formatRelativeDate(b.lastModified));
-                    }
+            for (const spec of safeSpecs) {
+                if (spec.updatedAt) {
+                    lastModifiedMap.set(spec.id, formatRelativeDate(spec.updatedAt));
                 }
             }
-            else {
-                await Promise.all(safeSpecs.map(async (s) => {
-                    if (!s.specPath) {
-                        return;
-                    }
-                    const specDir = dirname(s.specPath);
-                    const timestamp = await readLastModifiedTimestamp(specDir);
-                    if (timestamp) {
-                        lastModifiedMap.set(s.id, formatRelativeDate(timestamp));
-                    }
-                }));
-            }
             // SPEC-091: Auto-suggest Agent Teams when 3+ approved specs exist
             const approvedSpecs = allSpecs.filter((s) => s.status === 'approved');
             let teamSuggestion = null;

package/dist/tools/merge-risk-handler.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { safeLicensed } from './safe-handler.js';
+import { safeGoverned } from './safe-handler.js';
 import { assessMergeRisk } from '../engine/merge-risk-assessor/index.js';
 // ── Zod schema ────────────────────────────────────────────────────────────────
 const AssessMergeRiskInputSchema = {
@@ -75,6 +75,6 @@ export function registerMergeRiskTools(server) {
             destructiveHint: false,
             openWorldHint: false,
         },
-    }, safeLicensed('assess_merge_risk', async (args) => handleAssessMergeRisk(args)));
+    }, safeGoverned('assess_merge_risk', async (args) => handleAssessMergeRisk(args)));
 }
 //# sourceMappingURL=merge-risk-handler.js.map

package/dist/tools/package-handoff.js

@@ -383,6 +383,7 @@ export async function handlePackageHandoff(args) {
         /* best-effort — handoff rendering should not fail because telemetry failed */
     });
     const topBlockers = topItems(pkgWithScore.blockers, 3);
+    const ownershipBlockers = pkgWithScore.blockers.filter((blocker) => blocker.startsWith('handoff_ownership_invalid'));
     const topRisks = topItems(pkgWithScore.risks, 5);
     const minimalitySummary = summarizeMinimality(minimalityReport);
     const tokenWasteSummary = summarizeTokenWaste(tokenWasteReport);
@@ -406,6 +407,7 @@ export async function handlePackageHandoff(args) {
             readinessScore: pkgWithScore.readinessScore,
             blockersCount: pkgWithScore.blockers.length,
             blockersTop3: topBlockers,
+            ownershipBlockers,
             risksTop5: topRisks,
             criteriaTop5: topItems(pkgWithScore.criteria, 5),
             constraintsTop5: topItems(pkgWithScore.constraints, 5),

package/dist/tools/reconcile-spec.js

@@ -5,10 +5,8 @@ import { specStore, knowledgeStore } from '../storage/index.js';
 import { createVersion } from '../engine/spec-versioner.js';
 import { readFile } from 'node:fs/promises';
 import { atomicWriteFile } from '../engine/safety/atomic-write-file.js';
-import { dirname } from 'node:path';
 import { replaceSectionInSpec } from '../engine/spec-format/replace-section.js';
 import { extractSectionBody } from '../engine/spec-format/read-technical-section.js';
-import { appendChangelogEntry } from '../engine/spec-changelog/index.js';
 import { stripFrontmatter } from '../engine/frontmatter-parser.js';
 import { analyzeLivingSpec } from '../engine/living-spec-analyzer.js';
 import { notifyStoreChange } from '../engine/doc-generator/portal/regen-hook.js';
@@ -347,27 +345,6 @@ export async function handleReconcileSpec(params, server) {
                 : 'No changes to apply',
             reconciledAt: new Date().toISOString(),
         };
-        // Generate changelog entry if there were approved changes (AC-02, AC-08)
-        let changelogUpdated = false;
-        if (approvedChanges.length > 0 && spec.specPath) {
-            const specDir = dirname(spec.specPath);
-            changelogUpdated = await appendChangelogEntry({
-                specDir,
-                specId,
-                entry: {
-                    timestamp: new Date().toISOString(),
-                    type: 'reconciled',
-                    description: `Se reconcilio la spec. ${approvedChanges.length} cambio(s) aplicado(s): ${approvedChanges.map((c) => c.section).join(', ')}.`,
-                    triggeredBy: 'reconcile_spec',
-                    before: { criteriaCount: allChanges.length, completedCount: 0, status: spec.status },
-                    after: {
-                        criteriaCount: allChanges.length,
-                        completedCount: 0,
-                        status: hasStatusChange ? hasStatusChange.newValue : spec.status,
-                    },
-                },
-            });
-        }
         // Living spec analysis: compare criteria against codebase
         let livingSpecReport = null;
         if (livingSpec) {
@@ -379,7 +356,6 @@ export async function handleReconcileSpec(params, server) {
         const result = {
             ...report,
             versionCreated: createdVersion,
-            changelogUpdated,
             specBodyWritten,
             ...(bodySkippedChanges.length > 0 ? { skippedTextChanges: bodySkippedChanges } : {}),
             ...(livingSpecReport ? { livingSpec: livingSpecReport } : {}),
@@ -410,9 +386,6 @@ export async function handleReconcileSpec(params, server) {
         if (result.versionCreated !== null) {
             summaryLines.push(`**${t('tools.reconcileSpec.versionCreated')}:** v${String(result.versionCreated)}`);
         }
-        if (result.changelogUpdated) {
-            summaryLines.push(`**${t('tools.reconcileSpec.changelogUpdated')}:** ${t('tools.reconcileSpec.yes')}`);
-        }
         if (result.livingSpec) {
             summaryLines.push(`**${t('tools.reconcileSpec.livingSpec')}:** ${String(result.livingSpec.completionPercent)}% ${t('tools.reconcileSpec.coverage')}`);
         }

package/dist/tools/register-agent-squad-tools.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { safeLicensed, safeTracked } from './safe-handler.js';
+import { safeGoverned, safeTracked } from './safe-handler.js';
 import { SpecIdSchema } from './schemas/index.js';
 import { onAutopilotEvent } from '../engine/autopilot/event-bus.js';
 import { dispatchSquadForPhase } from '../engine/agent-squad/dispatcher.js';
@@ -83,7 +83,7 @@ export function registerAgentSquadTools(server) {
                 .boolean()
                 .describe('Set to true to enable the agent, false to disable it for this project.'),
         },
-    }, safeLicensed('configure_squad', async (args) => {
+    }, safeGoverned('configure_squad', async (args) => {
         const { projectPath, agentId, enabled } = args;
         const projectId = hashProjectPath(projectPath);
         await setAgentEnabled(projectId, agentId, enabled);

package/dist/tools/register-platform-tools/design-stack-tools.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { t } from '../../i18n/index.js';
-import { safeTracked, safeLicensed } from '../safe-handler.js';
+import { safeTracked, safeGoverned } from '../safe-handler.js';
 import { AgentPlatformEnum, SubAgentFrameworkEnum, ChallengeSpecFocusEnum, SpecIdSchema, } from '../schemas/index.js';
 import { handleGenerateADR } from '../generate-adr.js';
 import { handleDesignSchema } from '../design-schema.js';
@@ -33,7 +33,7 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('Specific decisions to document'),
         },
-    }, safeLicensed('generate_adr', async (args) => handleGenerateADR(args)));
+    }, safeGoverned('generate_adr', async (args) => handleGenerateADR(args)));
     // 21. design_schema
     server.registerTool('design_schema', {
         description: t('tools.design_schema.description'),
@@ -47,7 +47,7 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('Additional schema context or requirements'),
         },
-    }, safeLicensed('design_schema', async (args) => handleDesignSchema(args)));
+    }, safeGoverned('design_schema', async (args) => handleDesignSchema(args)));
     // 22. define_ui_contract
     server.registerTool('define_ui_contract', {
         description: t('tools.define_ui_contract.description'),
@@ -61,7 +61,7 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('Specific screens to define contracts for'),
         },
-    }, safeLicensed('define_ui_contract', async (args) => handleDefineUIContract(args)));
+    }, safeGoverned('define_ui_contract', async (args) => handleDefineUIContract(args)));
     // 23. challenge_spec
     server.registerTool('challenge_spec', {
         description: t('tools.challenge_spec.description'),
@@ -84,7 +84,7 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('Focus areas for the challenge'),
         },
-    }, safeLicensed('challenge_spec', async (args) => handleChallengeSpec(args)));
+    }, safeGoverned('challenge_spec', async (args) => handleChallengeSpec(args)));
     // 24. generate_execution_plan
     server.registerTool('generate_execution_plan', {
         description: t('tools.generate_execution_plan.description'),
@@ -147,7 +147,7 @@ export function registerDesignStackTools(server) {
             description: z.string().max(10_000).describe('Skill description'),
             specId: SpecIdSchema.optional().describe('Spec ID for context'),
         },
-    }, safeLicensed('generate_skill', async (args) => handleGenerateSkill(args)));
+    }, safeGoverned('generate_skill', async (args) => handleGenerateSkill(args)));
     // 28. detect_agent
     server.registerTool('detect_agent', {
         description: t('tools.detect_agent.description'),
@@ -155,7 +155,7 @@ export function registerDesignStackTools(server) {
         inputSchema: {
             projectId: z.string().max(500).describe('Project ID'),
         },
-    }, safeLicensed('detect_agent', async (args) => handleDetectAgent(args)));
+    }, safeGoverned('detect_agent', async (args) => handleDetectAgent(args)));
     // 29. generate_sub_agent
     server.registerTool('generate_sub_agent', {
         description: t('tools.generate_sub_agent.description'),
@@ -177,7 +177,7 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('When true, adds autoMemory: true to the agent frontmatter and includes memory path info in the response'),
         },
-    }, safeLicensed('generate_sub_agent', async (args) => handleGenerateSubAgent(args)));
+    }, safeGoverned('generate_sub_agent', async (args) => handleGenerateSubAgent(args)));
     // 30. generate_rules
     server.registerTool('generate_rules', {
         description: t('tools.generate_rules.description'),
@@ -201,7 +201,7 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('Additional custom rules'),
         },
-    }, safeLicensed('generate_rules', async (args) => handleGenerateRules(args)));
+    }, safeGoverned('generate_rules', async (args) => handleGenerateRules(args)));
     // 31. generate_orchestration_script
     server.registerTool('generate_orchestration_script', {
         description: t('tools.generate_orchestration_script.description'),
@@ -220,7 +220,7 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('Base branch for worktrees (default: develop)'),
         },
-    }, safeLicensed('generate_orchestration_script', (args) => Promise.resolve(handleGenerateOrchestrationScript(args))));
+    }, safeGoverned('generate_orchestration_script', (args) => Promise.resolve(handleGenerateOrchestrationScript(args))));
     // 32. red_team
     server.registerTool('red_team', {
         description: 'Adversarial review — argues against the spec from first principles before approval. Runs pre-mortem, surfaces hidden assumptions, proposes alternatives.',
@@ -233,6 +233,6 @@ export function registerDesignStackTools(server) {
                 .optional()
                 .describe('light: top objections only (default). full: exhaustive analysis across all 6 lenses'),
         },
-    }, safeLicensed('red_team', async (args) => handleRedTeam(args)));
+    }, safeGoverned('red_team', async (args) => handleRedTeam(args)));
 }
 //# sourceMappingURL=design-stack-tools.js.map

package/dist/tools/register-platform-tools/lifecycle-infra-tools.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { t } from '../../i18n/index.js';
-import { safeTracked, safeLicensed } from '../safe-handler.js';
+import { safeTracked, safeGoverned } from '../safe-handler.js';
 import { DocumentationTypeEnum, GitActionEnum, DevLifecycleCategoryEnum, PMPlatformEnum, PMActionEnum, OrchestrateActionEnum, ManageContextActionEnum, ContextBudgetActionEnum, SpecIdSchema, } from '../schemas/index.js';
 import { handleSuggestTooling } from '../suggest-tooling.js';
 import { handleGenerateTests } from '../generate-tests.js';
@@ -27,7 +27,7 @@ export function registerLifecycleInfraTools(server) {
                 .optional()
                 .describe('Specific categories to assess'),
         },
-    }, safeLicensed('suggest_tooling', async (args) => handleSuggestTooling(args)));
+    }, safeGoverned('suggest_tooling', async (args) => handleSuggestTooling(args)));
     // 32. generate_tests
     server.registerTool('generate_tests', {
         description: t('tools.generate_tests.description'),
@@ -80,7 +80,7 @@ export function registerLifecycleInfraTools(server) {
                 .describe('Content to save (required for save action)'),
             ttlDays: z.number().optional().describe('Time-to-live in days (optional for save)'),
         },
-    }, safeLicensed('manage_context', async (args) => handleManageContext(args)));
+    }, safeGoverned('manage_context', async (args) => handleManageContext(args)));
     // 35. manage_git
     server.registerTool('manage_git', {
         description: t('tools.manage_git.description'),
@@ -154,7 +154,7 @@ export function registerLifecycleInfraTools(server) {
             eventType: z.string().max(500).optional().describe('Journal event type for emit action'),
             commitHash: z.string().max(500).optional().describe('Commit hash to record in journal'),
         },
-    }, safeLicensed('orchestrate', async (args) => handleOrchestrate(args)));
+    }, safeGoverned('orchestrate', async (args) => handleOrchestrate(args)));
     // 37. integrate_pm
     server.registerTool('integrate_pm', {
         description: t('tools.integrate_pm.description'),
@@ -169,7 +169,7 @@ export function registerLifecycleInfraTools(server) {
                 .optional()
                 .describe('Platform-specific configuration'),
         },
-    }, safeLicensed('integrate_pm', async (args) => handleIntegratePM(args)));
+    }, safeGoverned('integrate_pm', async (args) => handleIntegratePM(args)));
     // 38. paradigm_report
     server.registerTool('paradigm_report', {
         description: t('tools.paradigm_report.description'),
@@ -177,7 +177,7 @@ export function registerLifecycleInfraTools(server) {
             projectId: z.string().max(500).describe('Project ID to analyse for paradigms'),
         },
         annotations: { readOnlyHint: true },
-    }, safeLicensed('paradigm_report', async (args) => handleParadigmReport(args)));
+    }, safeGoverned('paradigm_report', async (args) => handleParadigmReport(args)));
     // 39. context_budget
     server.registerTool('context_budget', {
         description: t('tools.context_budget.description'),
@@ -232,6 +232,6 @@ export function registerLifecycleInfraTools(server) {
                 .optional()
                 .describe('Pending work items'),
         },
-    }, safeLicensed('context_budget', async (args) => handleContextBudget(args)));
+    }, safeGoverned('context_budget', async (args) => handleContextBudget(args)));
 }
 //# sourceMappingURL=lifecycle-infra-tools.js.map