@planu/cli 4.11.1 → 4.11.2

package/dist/server/openapi-spec.d.ts

@@ -4,50 +4,50 @@
  * SPEC-610: Planu HTTP API — OpenAPI document for LLM function calling
  */
 export declare const OPENAPI_SPEC: {
-    readonly openapi: "3.1.0";
+    readonly openapi: '3.1.0';
     readonly info: {
-        readonly title: "Planu HTTP API";
-        readonly version: "1.0.0";
-        readonly description: "Planu Spec Driven Development HTTP API — transport-agnostic access to Planu engine";
+        readonly title: 'Planu HTTP API';
+        readonly version: '1.0.0';
+        readonly description: 'Planu Spec Driven Development HTTP API — transport-agnostic access to Planu engine';
     };
     readonly servers: readonly [{
-        readonly url: "http://localhost:3000";
-        readonly description: "Local development server";
+        readonly url: 'http://localhost:3000';
+        readonly description: 'Local development server';
     }];
     readonly paths: {
         readonly '/api/health': {
             readonly get: {
-                readonly operationId: "getHealth";
-                readonly summary: "Health check";
-                readonly description: "Returns server status and version information";
+                readonly operationId: 'getHealth';
+                readonly summary: 'Health check';
+                readonly description: 'Returns server status and version information';
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Server is healthy";
+                        readonly description: 'Server is healthy';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly type: "object";
+                                            readonly type: 'object';
                                             readonly properties: {
                                                 readonly status: {
-                                                    readonly type: "string";
-                                                    readonly example: "ok";
+                                                    readonly type: 'string';
+                                                    readonly example: 'ok';
                                                 };
                                                 readonly version: {
-                                                    readonly type: "string";
-                                                    readonly example: "1.0.0";
+                                                    readonly type: 'string';
+                                                    readonly example: '1.0.0';
                                                 };
                                                 readonly uptime: {
-                                                    readonly type: "number";
-                                                    readonly description: "Process uptime in seconds";
+                                                    readonly type: 'number';
+                                                    readonly description: 'Process uptime in seconds';
                                                 };
                                             };
-                                            readonly required: readonly ["status", "version", "uptime"];
+                                            readonly required: readonly ['status', 'version', 'uptime'];
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -59,35 +59,35 @@ export declare const OPENAPI_SPEC: {
         };
         readonly '/api/specs': {
             readonly get: {
-                readonly operationId: "listSpecs";
-                readonly summary: "List specs";
-                readonly description: "Returns all specs, optionally filtered by status";
+                readonly operationId: 'listSpecs';
+                readonly summary: 'List specs';
+                readonly description: 'Returns all specs, optionally filtered by status';
                 readonly parameters: readonly [{
-                    readonly name: "status";
-                    readonly in: "query";
-                    readonly description: "Filter by spec status. Valid values: draft, review, approved, implementing, done, discarded";
+                    readonly name: 'status';
+                    readonly in: 'query';
+                    readonly description: 'Filter by spec status. Valid values: draft, review, approved, implementing, done, discarded';
                     readonly required: false;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly enum: readonly ["draft", "review", "approved", "implementing", "done", "discarded"];
+                        readonly type: 'string';
+                        readonly enum: readonly ['draft', 'review', 'approved', 'implementing', 'done', 'discarded'];
                     };
                 }];
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "List of specs";
+                        readonly description: 'List of specs';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly type: "array";
+                                            readonly type: 'array';
                                             readonly items: {
-                                                readonly $ref: "#/components/schemas/Spec";
+                                                readonly $ref: '#/components/schemas/Spec';
                                             };
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -97,43 +97,43 @@ export declare const OPENAPI_SPEC: {
                 };
             };
             readonly post: {
-                readonly operationId: "createSpec";
-                readonly summary: "Create a spec";
-                readonly description: "Creates a new spec with the given title and description";
+                readonly operationId: 'createSpec';
+                readonly summary: 'Create a spec';
+                readonly description: 'Creates a new spec with the given title and description';
                 readonly requestBody: {
                     readonly required: true;
                     readonly content: {
                         readonly 'application/json': {
                             readonly schema: {
-                                readonly type: "object";
+                                readonly type: 'object';
                                 readonly properties: {
                                     readonly title: {
-                                        readonly type: "string";
-                                        readonly description: "Spec title";
+                                        readonly type: 'string';
+                                        readonly description: 'Spec title';
                                     };
                                     readonly description: {
-                                        readonly type: "string";
-                                        readonly description: "Spec description / requirements";
+                                        readonly type: 'string';
+                                        readonly description: 'Spec description / requirements';
                                     };
                                 };
-                                readonly required: readonly ["title", "description"];
+                                readonly required: readonly ['title', 'description'];
                             };
                         };
                     };
                 };
                 readonly responses: {
                     readonly '201': {
-                        readonly description: "Spec created";
+                        readonly description: 'Spec created';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly $ref: "#/components/schemas/Spec";
+                                            readonly $ref: '#/components/schemas/Spec';
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -141,38 +141,38 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '400': {
-                        readonly $ref: "#/components/responses/BadRequest";
+                        readonly $ref: '#/components/responses/BadRequest';
                     };
                 };
             };
         };
         readonly '/api/specs/{id}': {
             readonly get: {
-                readonly operationId: "getSpec";
-                readonly summary: "Get spec details";
-                readonly description: "Returns a single spec by ID";
+                readonly operationId: 'getSpec';
+                readonly summary: 'Get spec details';
+                readonly description: 'Returns a single spec by ID';
                 readonly parameters: readonly [{
-                    readonly name: "id";
-                    readonly in: "path";
+                    readonly name: 'id';
+                    readonly in: 'path';
                     readonly required: true;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                 }];
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Spec details";
+                        readonly description: 'Spec details';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly $ref: "#/components/schemas/Spec";
+                                            readonly $ref: '#/components/schemas/Spec';
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -180,23 +180,23 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '404': {
-                        readonly $ref: "#/components/responses/NotFound";
+                        readonly $ref: '#/components/responses/NotFound';
                     };
                 };
             };
         };
         readonly '/api/specs/{id}/status': {
             readonly patch: {
-                readonly operationId: "updateSpecStatus";
-                readonly summary: "Update spec status";
-                readonly description: "Transitions a spec to a new status";
+                readonly operationId: 'updateSpecStatus';
+                readonly summary: 'Update spec status';
+                readonly description: 'Transitions a spec to a new status';
                 readonly parameters: readonly [{
-                    readonly name: "id";
-                    readonly in: "path";
+                    readonly name: 'id';
+                    readonly in: 'path';
                     readonly required: true;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                 }];
                 readonly requestBody: {
@@ -204,32 +204,32 @@ export declare const OPENAPI_SPEC: {
                     readonly content: {
                         readonly 'application/json': {
                             readonly schema: {
-                                readonly type: "object";
+                                readonly type: 'object';
                                 readonly properties: {
                                     readonly status: {
-                                        readonly type: "string";
-                                        readonly enum: readonly ["draft", "review", "approved", "implementing", "done", "discarded"];
-                                        readonly description: "New status. Valid values: draft, review, approved, implementing, done, discarded";
+                                        readonly type: 'string';
+                                        readonly enum: readonly ['draft', 'review', 'approved', 'implementing', 'done', 'discarded'];
+                                        readonly description: 'New status. Valid values: draft, review, approved, implementing, done, discarded';
                                     };
                                 };
-                                readonly required: readonly ["status"];
+                                readonly required: readonly ['status'];
                             };
                         };
                     };
                 };
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Spec status updated";
+                        readonly description: 'Spec status updated';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly $ref: "#/components/schemas/Spec";
+                                            readonly $ref: '#/components/schemas/Spec';
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -237,58 +237,58 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '400': {
-                        readonly $ref: "#/components/responses/BadRequest";
+                        readonly $ref: '#/components/responses/BadRequest';
                     };
                     readonly '404': {
-                        readonly $ref: "#/components/responses/NotFound";
+                        readonly $ref: '#/components/responses/NotFound';
                     };
                 };
             };
         };
         readonly '/api/specs/{id}/validate': {
             readonly post: {
-                readonly operationId: "validateSpec";
-                readonly summary: "Validate a spec";
-                readonly description: "Runs readiness and quality checks on a spec";
+                readonly operationId: 'validateSpec';
+                readonly summary: 'Validate a spec';
+                readonly description: 'Runs readiness and quality checks on a spec';
                 readonly parameters: readonly [{
-                    readonly name: "id";
-                    readonly in: "path";
+                    readonly name: 'id';
+                    readonly in: 'path';
                     readonly required: true;
                     readonly schema: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                 }];
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "Validation results";
+                        readonly description: 'Validation results';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                     readonly properties: {
                                         readonly data: {
-                                            readonly type: "object";
+                                            readonly type: 'object';
                                             readonly properties: {
                                                 readonly specId: {
-                                                    readonly type: "string";
+                                                    readonly type: 'string';
                                                 };
                                                 readonly ready: {
-                                                    readonly type: "boolean";
+                                                    readonly type: 'boolean';
                                                 };
                                                 readonly score: {
-                                                    readonly type: "number";
+                                                    readonly type: 'number';
                                                 };
                                                 readonly issues: {
-                                                    readonly type: "array";
+                                                    readonly type: 'array';
                                                     readonly items: {
-                                                        readonly type: "string";
+                                                        readonly type: 'string';
                                                     };
                                                 };
                                             };
                                         };
                                         readonly error: {
-                                            readonly type: "null";
+                                            readonly type: 'null';
                                         };
                                     };
                                 };
@@ -296,23 +296,23 @@ export declare const OPENAPI_SPEC: {
                         };
                     };
                     readonly '404': {
-                        readonly $ref: "#/components/responses/NotFound";
+                        readonly $ref: '#/components/responses/NotFound';
                     };
                 };
             };
         };
         readonly '/api/openapi.json': {
             readonly get: {
-                readonly operationId: "getOpenApiSpec";
-                readonly summary: "OpenAPI specification";
-                readonly description: "Returns this OpenAPI document for LLM function calling";
+                readonly operationId: 'getOpenApiSpec';
+                readonly summary: 'OpenAPI specification';
+                readonly description: 'Returns this OpenAPI document for LLM function calling';
                 readonly responses: {
                     readonly '200': {
-                        readonly description: "OpenAPI spec";
+                        readonly description: 'OpenAPI spec';
                         readonly content: {
                             readonly 'application/json': {
                                 readonly schema: {
-                                    readonly type: "object";
+                                    readonly type: 'object';
                                 };
                             };
                         };
@@ -324,74 +324,74 @@ export declare const OPENAPI_SPEC: {
     readonly components: {
         readonly schemas: {
             readonly Spec: {
-                readonly type: "object";
+                readonly type: 'object';
                 readonly properties: {
                     readonly id: {
-                        readonly type: "string";
-                        readonly example: "SPEC-001";
+                        readonly type: 'string';
+                        readonly example: 'SPEC-001';
                     };
                     readonly title: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly status: {
-                        readonly type: "string";
-                        readonly enum: readonly ["draft", "review", "approved", "implementing", "done", "discarded"];
+                        readonly type: 'string';
+                        readonly enum: readonly ['draft', 'review', 'approved', 'implementing', 'done', 'discarded'];
                     };
                     readonly type: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly scope: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly difficulty: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly risk: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly tags: {
-                        readonly type: "array";
+                        readonly type: 'array';
                         readonly items: {
-                            readonly type: "string";
+                            readonly type: 'string';
                         };
                     };
                     readonly createdAt: {
-                        readonly type: "string";
-                        readonly format: "date-time";
+                        readonly type: 'string';
+                        readonly format: 'date-time';
                     };
                     readonly updatedAt: {
-                        readonly type: "string";
-                        readonly format: "date-time";
+                        readonly type: 'string';
+                        readonly format: 'date-time';
                     };
                 };
-                readonly required: readonly ["id", "title", "status"];
+                readonly required: readonly ['id', 'title', 'status'];
             };
             readonly ApiError: {
-                readonly type: "object";
+                readonly type: 'object';
                 readonly properties: {
                     readonly message: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                     readonly code: {
-                        readonly type: "string";
+                        readonly type: 'string';
                     };
                 };
-                readonly required: readonly ["message", "code"];
+                readonly required: readonly ['message', 'code'];
             };
         };
         readonly responses: {
             readonly BadRequest: {
-                readonly description: "Bad request — validation error";
+                readonly description: 'Bad request — validation error';
                 readonly content: {
                     readonly 'application/json': {
                         readonly schema: {
-                            readonly type: "object";
+                            readonly type: 'object';
                             readonly properties: {
                                 readonly data: {
-                                    readonly type: "null";
+                                    readonly type: 'null';
                                 };
                                 readonly error: {
-                                    readonly $ref: "#/components/schemas/ApiError";
+                                    readonly $ref: '#/components/schemas/ApiError';
                                 };
                             };
                         };
@@ -399,17 +399,17 @@ export declare const OPENAPI_SPEC: {
                 };
             };
             readonly NotFound: {
-                readonly description: "Resource not found";
+                readonly description: 'Resource not found';
                 readonly content: {
                     readonly 'application/json': {
                         readonly schema: {
-                            readonly type: "object";
+                            readonly type: 'object';
                             readonly properties: {
                                 readonly data: {
-                                    readonly type: "null";
+                                    readonly type: 'null';
                                 };
                                 readonly error: {
-                                    readonly $ref: "#/components/schemas/ApiError";
+                                    readonly $ref: '#/components/schemas/ApiError';
                                 };
                             };
                         };
@@ -417,17 +417,17 @@ export declare const OPENAPI_SPEC: {
                 };
             };
             readonly InternalError: {
-                readonly description: "Internal server error";
+                readonly description: 'Internal server error';
                 readonly content: {
                     readonly 'application/json': {
                         readonly schema: {
-                            readonly type: "object";
+                            readonly type: 'object';
                             readonly properties: {
                                 readonly data: {
-                                    readonly type: "null";
+                                    readonly type: 'null';
                                 };
                                 readonly error: {
-                                    readonly $ref: "#/components/schemas/ApiError";
+                                    readonly $ref: '#/components/schemas/ApiError';
                                 };
                             };
                         };

package/dist/tools/challenge-spec/event-challenge-scenarios.js

@@ -2,30 +2,13 @@
 // Generates backward-compatibility contract and idempotence challenges
 // for specs that produce or consume events.
 import { detectBrokers, getBrokerConfig, requiresIdempotence, } from '../../engine/event-detector.js';
+import { detectChallengeCapabilities } from './scenarios-utils.js';
 /**
  * Returns true when the spec or project has event-driven characteristics.
  */
 export function isEventDrivenSpec(spec, specContent, knowledge) {
-    const lower = `${spec.title} ${spec.tags.join(' ')} ${specContent}`.toLowerCase();
-    const specSignals = lower.includes('event') ||
-        lower.includes('kafka') ||
-        lower.includes('rabbitmq') ||
-        lower.includes('pubsub') ||
-        lower.includes('nats') ||
-        lower.includes('eventbridge') ||
-        lower.includes('sqs') ||
-        lower.includes('sns') ||
-        lower.includes('message') ||
-        lower.includes('consumer') ||
-        lower.includes('producer');
-    if (spec.target === 'frontend' && !specSignals) {
-        return false;
-    }
-    const brokers = detectBrokers(knowledge.stack);
-    if (specSignals) {
-        return true;
-    }
-    return brokers.length > 0 && brokers[0] !== 'unknown' && spec.target !== 'frontend';
+    void knowledge;
+    return detectChallengeCapabilities(spec, specContent).events;
 }
 /**
  * Generate event-driven failure scenarios for challenge_spec.
@@ -50,7 +33,7 @@ export function generateEventChallengeScenarios(spec, specContent, knowledge) {
         impact: 'critical',
         currentHandling: 'Schema change may not have a formal contract review — consumers may fail silently with unrecognized fields or crash on missing ones.',
         requiredHandling: 'Classify the change: additive (new optional field — safe), breaking (removed/type-changed field — requires dual-version emission), or deprecation (field marked deprecated with a sunset date). ' +
-            'For breaking changes: emit both old and new versions during the transition period (recommended: 2-4 weeks). ' +
+            'For breaking changes: emit both old and new versions during the transition period defined by the rollout plan. ' +
             'Update the event contract in event-contracts/ before merging.',
         dataConsistency: 'If the change is breaking and dual-version is not implemented, consumers will receive invalid events and may write corrupt state.',
         userExperience: 'Invisible to end users, but breaking event changes cause downstream service failures that eventually surface as user-facing errors.',
@@ -62,9 +45,7 @@ export function generateEventChallengeScenarios(spec, specContent, knowledge) {
             probability: 'high',
             impact: 'high',
             currentHandling: 'Consumer may lack a deduplication check — processing the same event twice could double-charge, double-ship, or create duplicate records.',
-            requiredHandling: 'Store the event ID (or a derived idempotency key) in a durable store (DB, Redis with TTL) before processing. ' +
-                'Check at the start of each consumer handler: if ID already processed, acknowledge and skip. ' +
-                'Choose the deduplication window based on expected redelivery window (typically 24h–7d).',
+            requiredHandling: 'Define the deduplication identifier, durable boundary, atomicity rule, and retention window from the event contract.',
             dataConsistency: 'The idempotency record must be written atomically with the side-effect (same DB transaction or two-phase commit) to avoid the "processed but not recorded" gap.',
             userExperience: 'Idempotence failure is invisible until users report duplicates (duplicate orders, double payments, etc.) — prevent, do not detect.',
         });
@@ -72,13 +53,13 @@ export function generateEventChallengeScenarios(spec, specContent, knowledge) {
     // 3. DLQ poisoned message challenge
     if (brokerConfig?.dlqSupport && brokerConfig.dlqSupport !== '') {
         scenarios.push({
-            scenario: `[${spec.id}] DLQ Poisoned Message: a consumer receives an event with a malformed payload (missing required field, wrong type, corrupt JSON). Does the consumer retry forever and block the queue? How many retries before the message goes to the DLQ?`,
+            scenario: `[${spec.id}] DLQ Poisoned Message: a consumer receives an event with a malformed payload. Does the consumer retry indefinitely and block the queue? Which declared failure condition moves the message to the DLQ?`,
             probability: 'medium',
             impact: 'high',
             currentHandling: 'Consumer may retry indefinitely on schema validation errors, blocking queue processing for all subsequent events.',
-            requiredHandling: 'Implement retry with exponential backoff (e.g., 1s, 2s, 4s, 8s, 16s). After max retries (e.g., 5), route to DLQ with original payload + error context. ' +
+            requiredHandling: 'Use the retry limit and delay policy declared by the event contract, then route terminal failures with enough diagnostic context. ' +
                 `DLQ support: ${brokerConfig.dlqSupport}. ` +
-                'Set an alert when DLQ depth exceeds threshold. Document the re-injection procedure for manual recovery.',
+                'Define the alert threshold and re-injection procedure from the operations contract.',
             dataConsistency: 'Messages in the DLQ must be investigated and re-injected only after the root cause is fixed — re-injecting without fix will loop back to DLQ.',
             userExperience: 'DLQ accumulation means events are not processed — monitor and alert before SLA is breached.',
         });