@planu/cli 4.13.0 → 4.14.1

package/dist/types/crash-shield-framework-rules.d.ts

@@ -0,0 +1,24 @@
+import type { CrashRisk } from './safety-scanner.js';
+export type FrameworkRuleActivationMode = 'content' | 'file-and-content' | 'file-or-content';
+export type FrameworkRuleGuardScope = 'file' | 'line' | 'window';
+export interface FrameworkRuleGuard {
+    scope: FrameworkRuleGuardScope;
+    patterns: string[];
+    before?: number;
+    after?: number;
+}
+export interface CrashShieldFrameworkRule {
+    id: string;
+    framework: string;
+    fileExtensions: string[];
+    contentAny: string[];
+    contentAll?: string[];
+    activationMode: FrameworkRuleActivationMode;
+    finding: string;
+    guard?: FrameworkRuleGuard;
+    pattern: string;
+    severity: CrashRisk['severity'];
+    description: string;
+    suggestedFix: string;
+}
+//# sourceMappingURL=crash-shield-framework-rules.d.ts.map

package/dist/types/crash-shield-framework-rules.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=crash-shield-framework-rules.js.map

package/dist/types/data-gc.d.ts

@@ -29,6 +29,18 @@ export interface GcRunOptions extends GcScanOptions {
     dataProjectsDir: string;
     /** When true, actually delete candidates; when false (default), dry-run only */
     apply?: boolean;
+    /** Canonical recoverable trash root. Required when apply=true. */
+    trashDir?: string;
+    /** Days until a recoverable trash entry becomes eligible for purge. */
+    trashTtlDays?: number;
+}
+export interface GcTrashMetadata {
+    schemaVersion: 1;
+    originalPath: string;
+    trashedPath: string;
+    trashedAt: string;
+    expiresAt: string;
+    reason: GcReason;
 }
 export interface GcRunResult {
     /** True when no deletions were performed */
@@ -41,6 +53,10 @@ export interface GcRunResult {
     candidateCount: number;
     /** Names of dirs actually deleted (empty in dry-run) */
     deleted: string[];
+    /** Recoverable destination paths for applied candidates. */
+    trashed: string[];
+    /** Expired recoverable entries permanently purged during an applied run. */
+    purgedExpired: string[];
     /** Any errors encountered during deletion */
     errors: string[];
     /** inactiveDays setting used for this run */

package/dist/types/deploy.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // types/deploy.ts — SPEC-478: Deploy integration types
 export {};
 //# sourceMappingURL=deploy.js.map

package/dist/types/durable-job.d.ts

@@ -0,0 +1,78 @@
+import type { DurableJobRecord } from '../storage/runtime-db.js';
+import type { NativeWorkerCall, NativeWorkerOperation } from './native-worker.js';
+import type { ValidationArtifactDigests } from './validation-receipt.js';
+import type { ValidationFreshnessLease } from '../engine/validation/validation-freshness.js';
+export interface DurableJobIdentity {
+    readonly operationId: string;
+    readonly projectId: string;
+    readonly workspaceId?: string;
+}
+export interface WatchJobInput extends DurableJobIdentity {
+    readonly afterCursor?: string;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface DurableJobRuntimeOptions {
+    readonly databasePath?: string;
+}
+export interface NativeDurableJobPayload {
+    readonly kind: 'native-worker';
+    readonly operation: NativeWorkerOperation;
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly deadlineAt: number;
+    readonly cancellationId?: string;
+}
+export interface ValidateDurableJobPayload {
+    readonly kind: 'validate';
+    readonly schemaVersion: 1;
+    readonly input: {
+        readonly specId: string;
+        readonly projectId: string;
+        readonly projectPath?: string;
+    };
+    readonly bindings?: {
+        readonly projectId: string;
+        readonly specId: string;
+        readonly sourceTreeHash: string;
+        readonly specHash: string;
+        readonly policyHash: string;
+        readonly toolchainHash: string;
+    };
+    readonly deadlineAt?: number;
+    readonly artifactDigests?: ValidationArtifactDigests;
+    readonly freshnessLease?: ValidationFreshnessLease;
+    readonly specPath?: string;
+}
+export type NativeWorkerRunner = (call: NativeWorkerCall) => Promise<unknown>;
+export interface DurableJobExecutorOptions {
+    readonly runtime: {
+        list(projectId: string, workspaceId?: string): readonly DurableJobRecord[];
+        claim(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly leaseMs: number;
+        }): DurableJobRecord | undefined;
+        renew(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly leaseMs: number;
+            readonly fencingToken: number;
+        }): boolean;
+        get(input: DurableJobIdentity): DurableJobRecord;
+        complete(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly fencingToken: number;
+            readonly result: unknown;
+        }): DurableJobRecord;
+        fail(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly fencingToken: number;
+            readonly error: string;
+        }): DurableJobRecord;
+    };
+    readonly workerId: string;
+    readonly leaseMs?: number;
+    readonly heartbeatMs?: number;
+    readonly maxConcurrency?: number;
+    readonly runNative?: NativeWorkerRunner;
+}
+//# sourceMappingURL=durable-job.d.ts.map

package/dist/types/durable-job.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=durable-job.js.map

package/dist/types/durable-validation.d.ts

@@ -0,0 +1,60 @@
+import type { ToolResult } from './index.js';
+import type { ValidateWorkerCall } from './validate-worker.js';
+import type { DurableJobRecord } from '../storage/runtime-db.js';
+export interface DurableValidationBindings {
+    readonly projectId: string;
+    readonly specId: string;
+    readonly sourceTreeHash: string;
+    readonly specHash: string;
+    readonly policyHash: string;
+    readonly toolchainHash: string;
+}
+export interface ValidationPhaseProgress {
+    readonly phase: string;
+    readonly command: string;
+    readonly durationMs: number;
+    readonly filesScanned?: number;
+    readonly status: 'running' | 'passed' | 'failed' | 'cancelled';
+    readonly remediation?: string;
+}
+export interface ValidationPhase {
+    readonly id: string;
+    readonly command: {
+        readonly executable: string;
+        readonly args?: readonly string[];
+    };
+    readonly timeoutMs?: number;
+    readonly filesScanned?: number;
+    readonly remediation?: string;
+    readonly onStarted?: () => void;
+    readonly onSettled?: () => void;
+}
+export interface ValidationPhaseResult {
+    readonly id: string;
+    readonly status: 'passed' | 'failed' | 'cancelled';
+    readonly durationMs: number;
+    readonly exitCode: number | null;
+    readonly logDigest: string;
+}
+export interface ValidationPhaseGraphResult {
+    readonly status: 'passed' | 'failed' | 'cancelled';
+    readonly gates: readonly ValidationPhaseResult[];
+    readonly log: string;
+}
+export interface ValidateJobExecutorOptions {
+    readonly runWorker?: (call: ValidateWorkerCall) => Promise<ToolResult>;
+}
+export interface ValidateJobRecoveryOptions {
+    readonly runtimeFactory?: () => {
+        listRunnableScopes(): readonly {
+            projectId: string;
+            workspaceId: string;
+        }[];
+        list(projectId: string, workspaceId: string): readonly DurableJobRecord[];
+        close(): void;
+    };
+    readonly schedule?: (projectId: string, workspaceId: string) => void;
+    readonly scheduleLater?: (callback: () => void, delayMs: number) => void;
+    readonly now?: () => number;
+}
+//# sourceMappingURL=durable-validation.d.ts.map

package/dist/types/durable-validation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=durable-validation.js.map

package/dist/types/estimation.d.ts

@@ -58,6 +58,8 @@ export interface ValidateInput {
     specId: string;
     projectId?: string;
     projectPath?: string;
+    /** Durable submission is the only public MCP execution mode. */
+    mode?: 'submit';
 }
 export interface EstimateResult {
     difficulty: Difficulty;

package/dist/types/evidence-gates.d.ts

@@ -1,6 +1,8 @@
+import type { ValidationArtifactProvenance, ValidationReceipt } from './validation-receipt.js';
 export type EvidenceGateTransition = 'approved' | 'implementing' | 'done';
 export interface DiscoveryEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     rules: string[];
     examples: {
         rule: string;
@@ -19,6 +21,7 @@ export interface DiscoveryEvidence {
 }
 export interface TaskPlanEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     tasks: {
         id: string;
         title: string;
@@ -28,6 +31,7 @@ export interface TaskPlanEvidence {
 }
 export interface TraceabilityMatrixEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     rows: {
         acceptanceCriterion: string;
         scenario?: string;
@@ -41,6 +45,7 @@ export interface TraceabilityMatrixEvidence {
 }
 export interface ContractValidationEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     kind: 'api' | 'graphql' | 'event' | 'ui' | 'mcp';
     passed: boolean;
     reportPath?: string;
@@ -53,8 +58,11 @@ export interface EvidenceArtifacts {
     contractValidations: ContractValidationEvidence[];
     invalidArtifacts: string[];
 }
+export interface EvidenceReceiptContext {
+    receipt: ValidationReceipt;
+}
 export interface EvidenceGateIssue {
-    code: 'discovery_missing' | 'discovery_unresolved_questions' | 'task_plan_missing' | 'task_plan_uncovered_criteria' | 'traceability_missing' | 'traceability_uncovered_criteria' | 'traceability_incomplete_rows' | 'contract_validation_missing' | 'contract_validation_failed' | 'done_drift_uncovered_criteria' | 'done_drift_stale_evidence' | 'done_drift_unapproved_scope' | 'evidence_artifact_invalid';
+    code: 'discovery_missing' | 'discovery_unresolved_questions' | 'task_plan_missing' | 'task_plan_uncovered_criteria' | 'traceability_missing' | 'traceability_uncovered_criteria' | 'traceability_incomplete_rows' | 'contract_validation_missing' | 'contract_validation_failed' | 'evidence_provenance_invalid' | 'done_drift_uncovered_criteria' | 'done_drift_stale_evidence' | 'done_drift_unapproved_scope' | 'evidence_artifact_invalid';
     message: string;
 }
 export interface EvidenceGateResult {

package/dist/types/execution.d.ts

@@ -98,4 +98,47 @@ export interface ClaudeCommandOptions {
     allowedTools?: string[];
     nonInteractive?: boolean;
 }
+export type RequestExecutionPhase = 'running' | 'committed' | 'acknowledged' | 'cancelled';
+export interface RequestExecutionState {
+    phase: RequestExecutionPhase;
+}
+export interface RequestExecutionContext {
+    readonly requestId: string;
+    readonly idempotencyKey?: string;
+    readonly deadlineAt: number;
+    readonly signal: AbortSignal;
+    readonly phase: RequestExecutionPhase;
+    remainingMs(): number;
+    assertCanCommit(): void;
+    markCommitted(): void;
+}
+export interface RequestExecutionScope {
+    readonly context: RequestExecutionContext;
+    run<T>(fn: () => T): T;
+    cancel(reason?: unknown): void;
+    acknowledge(): void;
+    dispose: () => void;
+}
+export interface CreateExecutionScopeOptions {
+    deadlineAt: number;
+    upstreamSignal?: AbortSignal;
+    requestId?: string;
+    idempotencyKey?: string;
+}
+export interface CancellationScope {
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+    dispose: () => void;
+}
+export interface BudgetExecution<T> {
+    result: Promise<{
+        ok: true;
+        value: T;
+    } | {
+        ok: false;
+        error: Error;
+    }>;
+    timeoutMs: number;
+    dispose: () => void;
+}
 //# sourceMappingURL=execution.d.ts.map

package/dist/types/handoff-artifacts.d.ts

@@ -75,6 +75,8 @@ export interface ValidationReportV1 {
     minimalityReport?: MinimalImplementationReport;
     score?: number;
     completedAt: string;
+    receiptId?: string;
+    receiptKey?: string;
 }
 export interface ArtifactPayloadMap {
     intake: IntakeV1;

package/dist/types/index.d.ts

@@ -22,6 +22,7 @@ export * from './docs.js';
 export * from './git.js';
 export * from './orchestration/index.js';
 export * from './security.js';
+export * from './validation-receipt.js';
 export * from './lifecycle.js';
 export * from './migration/index.js';
 export * from './migration-advanced.js';
@@ -295,4 +296,5 @@ export * from './opencode.js';
 export * from './host-tool-filter.js';
 export * from './reconcile.js';
 export * from './release-pipeline.js';
+export * from './network-policy.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -23,6 +23,7 @@ export * from './docs.js';
 export * from './git.js';
 export * from './orchestration/index.js';
 export * from './security.js';
+export * from './validation-receipt.js';
 export * from './lifecycle.js';
 export * from './migration/index.js';
 export * from './migration-advanced.js';
@@ -306,4 +307,5 @@ export * from './host-tool-filter.js';
 export * from './reconcile.js';
 // SPEC-1012: Release spec closer types
 export * from './release-pipeline.js';
+export * from './network-policy.js';
 //# sourceMappingURL=index.js.map

package/dist/types/infrastructure.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
 // types/infrastructure.ts — Types for generate_infrastructure tool (SPEC-171)
 export {};
 //# sourceMappingURL=infrastructure.js.map

package/dist/types/lifecycle.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // types/lifecycle.ts — Dev lifecycle types (SPEC-026a)
 // CI/CD detection, deployment targets, observability stack, DX health scores
 export {};

package/dist/types/migration/canonical-storage.d.ts

@@ -0,0 +1,37 @@
+export type CanonicalMigrationStatus = 'noop' | 'planned' | 'migrated' | 'resumed' | 'rolled-back' | 'error';
+export interface CanonicalMigrationFile {
+    readonly relativePath: string;
+    readonly size: number;
+    readonly sha256: string;
+}
+export interface CanonicalMigrationInventory {
+    readonly root: string;
+    readonly files: readonly CanonicalMigrationFile[];
+    readonly totalBytes: number;
+    readonly digest: string;
+}
+export interface CanonicalMigrationCollision {
+    readonly relativePath: string;
+    readonly sourcePath: string;
+    readonly destinationPath: string;
+    readonly archivedPath?: string;
+    readonly resolution: 'destination-newer' | 'source-newer' | 'destination-preserved' | 'source-archived';
+}
+export interface CanonicalMigrationInput {
+    /** Explicit absolute legacy roots. No CWD discovery is performed. */
+    readonly legacyRoots: readonly string[];
+    /** Explicit absolute canonical project-data directory. */
+    readonly destinationRoot: string;
+    readonly dryRun?: boolean;
+}
+export interface CanonicalMigrationResult {
+    readonly status: CanonicalMigrationStatus;
+    readonly destinationRoot: string;
+    readonly journalPath: string;
+    readonly sourceInventories: readonly CanonicalMigrationInventory[];
+    readonly destinationInventory: CanonicalMigrationInventory | null;
+    readonly collisions: readonly CanonicalMigrationCollision[];
+    readonly resumed: boolean;
+    readonly reason?: string;
+}
+//# sourceMappingURL=canonical-storage.d.ts.map

package/dist/types/migration/canonical-storage.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=canonical-storage.js.map

package/dist/types/migration/index.d.ts

@@ -2,5 +2,5 @@ export type { MigrationStrategy, MigrationRisk, EquivalenceStatus, ComponentTemp
 export type { MigrationSpec, CircularDependency, MigrationPhase, MigrationPlan, StranglerFigProxy, ProxyRoutingRule, ParallelRunComparator, MigrationStrategyResult, ParityCheckItem, ContractTest, ParityValidationResult, EquivalenceEntry, SortResult, StrategyInput, } from './planning.js';
 export type { DbMigrationType, DbSchema, DbTableInfo, DbColumnInfo, DbTypeMapping, DbMigrationMap, DbMigrationPhase, DualWriteStrategy, DbMigrationPlan, TypeMappingEntry, } from './database.js';
 export type { MigrateTechAction, MigrateTechInput, MigrateTechResult } from './io.js';
-export type { CwdMigrationStatus, CwdMigrationResult } from './cwd-to-absolute.js';
+export type { CanonicalMigrationStatus, CanonicalMigrationFile, CanonicalMigrationInventory, CanonicalMigrationCollision, CanonicalMigrationInput, CanonicalMigrationResult, } from './canonical-storage.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/native-worker.d.ts

@@ -0,0 +1,48 @@
+import type { Worker } from 'node:worker_threads';
+export type NativeWorkerOperation = 'scan-and-hash-files' | 'scan-project-metadata' | 'scan-spec-annotations' | 'detect-drift' | 'scan-specs' | 'find-relevant-files' | 'scan-project-graph-sources';
+export interface NativeWorkerHandshake {
+    readonly kind: 'handshake';
+    readonly protocolAbi: number;
+    readonly capabilityAbi: number;
+    readonly storageSchema: number;
+    readonly schemaHash: string;
+    readonly capabilities: readonly NativeWorkerOperation[];
+    readonly engineVersion: string | null;
+    readonly target: string | null;
+    readonly artifactHash: string | null;
+    readonly compatible: boolean;
+}
+export interface NativeWorkerRequest {
+    readonly kind: 'request';
+    readonly secret: string;
+    readonly requestId: string;
+    readonly projectId: string;
+    readonly deadlineAt: number;
+    readonly cancellationId: string;
+    readonly operation: NativeWorkerOperation;
+    readonly payload: Readonly<Record<string, unknown>>;
+}
+export type NativeWorkerResponse = {
+    readonly kind: 'result';
+    readonly requestId: string;
+    readonly value: unknown;
+} | {
+    readonly kind: 'error';
+    readonly requestId: string;
+    readonly message: string;
+};
+export interface NativeWorkerCall {
+    readonly projectId: string;
+    readonly operation: NativeWorkerOperation;
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly deadlineAt: number;
+    readonly requestId?: string;
+    readonly cancellationId?: string;
+    readonly signal?: AbortSignal;
+}
+export type NativeWorkerFactory = (url: URL, options: {
+    workerData: {
+        secret: string;
+    };
+}) => Worker;
+//# sourceMappingURL=native-worker.d.ts.map

package/dist/types/native-worker.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=native-worker.js.map

package/dist/types/network-policy.d.ts

@@ -0,0 +1,12 @@
+export type NetworkPurpose = 'dependency-audit' | 'integration' | 'oauth' | 'registry' | 'telemetry' | 'updates';
+export type NetworkRequestPurpose = NetworkPurpose | 'unclassified';
+export interface NetworkConsentReceipt {
+    readonly purpose: NetworkPurpose;
+    readonly version: number;
+    readonly token: symbol;
+}
+export interface NetworkConsentScope {
+    readonly purposes: ReadonlySet<NetworkPurpose>;
+    readonly version: number;
+}
+//# sourceMappingURL=network-policy.d.ts.map

package/dist/types/network-policy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=network-policy.js.map

package/dist/types/oauth.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // src/types/oauth.ts — OAuth 2.1 Bearer token types (SPEC-161) + OAuth integration types (SPEC-440).
 export {};
 //# sourceMappingURL=oauth.js.map

package/dist/types/observability.d.ts

@@ -60,6 +60,38 @@ export interface SpanContext {
     status: SpanStatus;
     errorMessage?: string;
 }
+export interface LocalExecutionSpanEvent {
+    readonly kind: 'start' | 'complete' | 'timeout' | 'late-completion';
+    readonly occurredAt: string;
+    readonly requestId: string;
+    readonly operationId: string;
+    readonly operation: string;
+    readonly phase: string;
+    readonly deadlineAt: number;
+    readonly lockWaitMs: number;
+    readonly files: number;
+    readonly bytes: number;
+    readonly subprocess: boolean;
+    readonly cancelled: boolean;
+    readonly commitState: string;
+    readonly lateCompletion: boolean;
+}
+export interface LocalExecutionSpanInput {
+    readonly requestId: string;
+    readonly operationId: string;
+    readonly operation: string;
+    readonly deadlineAt: number;
+    readonly lockWaitMs?: number;
+    readonly files?: number;
+    readonly bytes?: number;
+    readonly subprocess?: boolean;
+}
+export interface LocalExecutionMeasurements {
+    readonly lockWaitMs: number;
+    readonly files: number;
+    readonly bytes: number;
+    readonly subprocess: boolean;
+}
 /** Handle for a started span. Implementations must be safe to call after end(). */
 export interface SpanHandle {
     /** Set an attribute on the span. No-op after end(). */

package/dist/types/outbox-worker.d.ts

@@ -0,0 +1,35 @@
+export interface OutboxDeliveryContext {
+    readonly deliveryKey: string;
+    readonly fencingToken: number;
+    readonly topic: string;
+    readonly payload: unknown;
+}
+export interface OutboxFenceRecord {
+    readonly schemaVersion: 1;
+    readonly workerId: string;
+    readonly fencingToken: number;
+    readonly leaseExpiresAt: string;
+    readonly state: 'leased' | 'failed' | 'dead-letter' | 'delivered';
+    readonly attempts?: number;
+    readonly lastError?: string;
+}
+export declare const SPEC_CREATED_POST_COMMIT_TASKS: readonly ['git-setup', 'analysis', 'quality-score', 'duplicate-detection', 'complexity-advice', 'prior-decisions', 'suggestions', 'challenge-readiness'];
+export type SpecCreatedPostCommitTask = (typeof SPEC_CREATED_POST_COMMIT_TASKS)[number];
+export interface SpecCreatedPayload {
+    readonly schemaVersion: 1;
+    readonly specId: string;
+    readonly projectId: string;
+    readonly projectPath: string;
+    readonly postCommitTasks: readonly SpecCreatedPostCommitTask[];
+}
+export interface SpecCreatedTaskContext {
+    readonly deliveryKey: string;
+    readonly payload: SpecCreatedPayload;
+}
+export interface SpecCreatedTaskOutcome {
+    readonly status?: 'completed' | 'skipped';
+    readonly reason?: string;
+}
+export type SpecCreatedTaskHandler = (context: SpecCreatedTaskContext) => Promise<SpecCreatedTaskOutcome | undefined>;
+export type SpecCreatedTaskHandlers = Readonly<Record<SpecCreatedPostCommitTask, SpecCreatedTaskHandler>>;
+//# sourceMappingURL=outbox-worker.d.ts.map

package/dist/types/outbox-worker.js

@@ -0,0 +1,11 @@
+export const SPEC_CREATED_POST_COMMIT_TASKS = [
+    'git-setup',
+    'analysis',
+    'quality-score',
+    'duplicate-detection',
+    'complexity-advice',
+    'prior-decisions',
+    'suggestions',
+    'challenge-readiness',
+];
+//# sourceMappingURL=outbox-worker.js.map

package/dist/types/permissions-config.d.ts

@@ -7,33 +7,6 @@ export interface DenyRulesRegistry {
         patterns: string[];
     }[];
 }
-/** Schema of src/config/detection-signals.json — loaded by stack-detectors. */
-export interface DetectionSignalsRegistry {
-    schemaVersion: number;
-    signals: {
-        frameworkId: string;
-        ecosystem: string;
-        type: string;
-        pattern: string;
-        manager?: string;
-    }[];
-    deployTargets: {
-        id: string;
-        type: string;
-        pattern: string;
-        additionalMatch?: string;
-    }[];
-    databases: {
-        id: string;
-        type: string;
-        pattern: string;
-        manager?: string;
-    }[];
-    aliases?: {
-        alias: string;
-        canonical: string;
-    }[];
-}
 /** Permission configuration mode:
  * - minimal: only mcp__planu__* + always-on deny rules
  * - recommended: above + family allowlists + stack-specific deny

package/dist/types/permissions-config.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // types/permissions-config.ts — Types for SPEC-594 + SPEC-597 (registry-driven discovery)
 export {};
 //# sourceMappingURL=permissions-config.js.map

package/dist/types/plugin-install.d.ts

@@ -107,17 +107,6 @@ export interface InstallOutcome {
 export interface PluginCatalog {
     plugins: PluginRecommendation[];
 }
-/** Schema of src/config/framework-registry/index.json — canonical framework catalog. */
-export interface FrameworkRegistryIndex {
-    frameworks: {
-        id: string;
-        displayName: string;
-        ecosystem: string;
-        frameworkVersion: string;
-        lastUpdated: string;
-        file: string;
-    }[];
-}
 /** Alias lookup map: raw-name-lowercased → canonical framework/target id. */
 export type StackMatcherAliasMap = Record<string, string>;
 //# sourceMappingURL=plugin-install.d.ts.map

package/dist/types/plugin-install.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // types/plugin-install.ts — Domain types for SPEC-596 plugin installation
 import { z } from 'zod';
 // ---------------------------------------------------------------------------