@specforge/canary-cli 0.2.1 → 0.2.3

package/node_modules/@specforge/spec-types/dist/schema/ticket.d.ts

@@ -0,0 +1,444 @@
+import { z } from 'zod';
+export declare const TicketTypeEnum: z.ZodEnum<["implementation", "verification"]>;
+export type TicketType = z.infer<typeof TicketTypeEnum>;
+export declare const TicketComplexityEnum: z.ZodEnum<["small", "medium", "large", "xlarge"]>;
+export type TicketComplexity = z.infer<typeof TicketComplexityEnum>;
+export declare const TicketStatusEnum: z.ZodEnum<["pending", "ready", "active", "done", "blocked"]>;
+export type TicketStatus = z.infer<typeof TicketStatusEnum>;
+export declare const TicketSchema: z.ZodObject<{
+    id: z.ZodString;
+    epicId: z.ZodString;
+    ticketNumber: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    ticketType: z.ZodEnum<["implementation", "verification"]>;
+    complexity: z.ZodEnum<["small", "medium", "large", "xlarge"]>;
+    estimatedMinutes: z.ZodNumber;
+    order: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    acceptanceCriteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        given: z.ZodString;
+        when: z.ZodString;
+        then: z.ZodString;
+        order: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        given: string;
+        when: string;
+        then: string;
+        order: number;
+    }, {
+        id: string;
+        given: string;
+        when: string;
+        then: string;
+        order: number;
+    }>, "many">;
+    implementationSteps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        order: z.ZodNumber;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            role: z.ZodString;
+            symbol: z.ZodOptional<z.ZodString>;
+            why: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            role: string;
+            symbol?: string | undefined;
+            why?: string | undefined;
+        }, {
+            path: string;
+            role: string;
+            symbol?: string | undefined;
+            why?: string | undefined;
+        }>, "many">>;
+        linkedFileIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        linkedCodeSnippetIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        linkedTypeSnippetIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        order: number;
+        text: string;
+        files?: {
+            path: string;
+            role: string;
+            symbol?: string | undefined;
+            why?: string | undefined;
+        }[] | undefined;
+        linkedFileIds?: string[] | undefined;
+        linkedCodeSnippetIds?: string[] | undefined;
+        linkedTypeSnippetIds?: string[] | undefined;
+    }, {
+        id: string;
+        order: number;
+        text: string;
+        files?: {
+            path: string;
+            role: string;
+            symbol?: string | undefined;
+            why?: string | undefined;
+        }[] | undefined;
+        linkedFileIds?: string[] | undefined;
+        linkedCodeSnippetIds?: string[] | undefined;
+        linkedTypeSnippetIds?: string[] | undefined;
+    }>, "many">;
+    filesToBeCreated: z.ZodArray<z.ZodString, "many">;
+    filesToBeModified: z.ZodArray<z.ZodString, "many">;
+    filesToBeDeleted: z.ZodArray<z.ZodString, "many">;
+    filesToBeReferenced: z.ZodArray<z.ZodString, "many">;
+    testSpecification: z.ZodOptional<z.ZodObject<{
+        testTypes: z.ZodArray<z.ZodEnum<["unit", "integration", "e2e", "typecheck", "lint", "build", "contract", "structural", "layout", "a11y", "performance"]>, "many">;
+        qualityGates: z.ZodArray<z.ZodString, "many">;
+        testCommands: z.ZodArray<z.ZodString, "many">;
+        coverageTarget: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        testTypes: ("unit" | "integration" | "e2e" | "typecheck" | "lint" | "build" | "contract" | "structural" | "layout" | "a11y" | "performance")[];
+        qualityGates: string[];
+        testCommands: string[];
+        coverageTarget?: number | null | undefined;
+    }, {
+        testTypes: ("unit" | "integration" | "e2e" | "typecheck" | "lint" | "build" | "contract" | "structural" | "layout" | "a11y" | "performance")[];
+        qualityGates: string[];
+        testCommands: string[];
+        coverageTarget?: number | null | undefined;
+    }>>;
+    guardrails: z.ZodArray<z.ZodString, "many">;
+    codeReferences: z.ZodArray<z.ZodObject<{
+        filePath: z.ZodString;
+        symbol: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        filePath: string;
+        symbol?: string | undefined;
+        description?: string | undefined;
+    }, {
+        filePath: string;
+        symbol?: string | undefined;
+        description?: string | undefined;
+    }>, "many">;
+    typeReferences: z.ZodArray<z.ZodObject<{
+        filePath: z.ZodString;
+        typeName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        filePath: string;
+        typeName: string;
+        description?: string | undefined;
+    }, {
+        filePath: string;
+        typeName: string;
+        description?: string | undefined;
+    }>, "many">;
+    codeSnippets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        language: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        order: z.ZodOptional<z.ZodNumber>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }, {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }>, "many">>;
+    typeSnippets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        language: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        order: z.ZodOptional<z.ZodNumber>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }, {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }>, "many">>;
+    blueprintReferences: z.ZodArray<z.ZodObject<{
+        blueprintId: z.ZodString;
+        context: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        section: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        blueprintId: string;
+        context?: string | null | undefined;
+        section?: string | null | undefined;
+    }, {
+        blueprintId: string;
+        context?: string | null | undefined;
+        section?: string | null | undefined;
+    }>, "many">;
+    dependencies: z.ZodArray<z.ZodObject<{
+        ticketId: z.ZodString;
+        type: z.ZodEnum<["requires", "blocks"]>;
+        origin: z.ZodOptional<z.ZodObject<{
+            provenance: z.ZodOptional<z.ZodBoolean>;
+            scaffold: z.ZodOptional<z.ZodBoolean>;
+            semantic: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            provenance?: boolean | undefined;
+            scaffold?: boolean | undefined;
+            semantic?: boolean | undefined;
+        }, {
+            provenance?: boolean | undefined;
+            scaffold?: boolean | undefined;
+            semantic?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "requires" | "blocks";
+        ticketId: string;
+        origin?: {
+            provenance?: boolean | undefined;
+            scaffold?: boolean | undefined;
+            semantic?: boolean | undefined;
+        } | undefined;
+    }, {
+        type: "requires" | "blocks";
+        ticketId: string;
+        origin?: {
+            provenance?: boolean | undefined;
+            scaffold?: boolean | undefined;
+            semantic?: boolean | undefined;
+        } | undefined;
+    }>, "many">;
+    fieldDeclarations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: z.ZodLiteral<"N/A">;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: "N/A";
+        reason: string;
+    }, {
+        value: "N/A";
+        reason: string;
+    }>>>;
+    fileChangeRefs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        kind: z.ZodString;
+        symbol: z.ZodOptional<z.ZodString>;
+        why: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        id: string;
+        kind: string;
+        symbol?: string | undefined;
+        why?: string | undefined;
+    }, {
+        path: string;
+        id: string;
+        kind: string;
+        symbol?: string | undefined;
+        why?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    epicId: string;
+    ticketType: "implementation" | "verification";
+    complexity: "small" | "medium" | "large" | "xlarge";
+    estimatedMinutes: number;
+    acceptanceCriteria: {
+        id: string;
+        given: string;
+        when: string;
+        then: string;
+        order: number;
+    }[];
+    implementationSteps: {
+        id: string;
+        order: number;
+        text: string;
+        files?: {
+            path: string;
+            role: string;
+            symbol?: string | undefined;
+            why?: string | undefined;
+        }[] | undefined;
+        linkedFileIds?: string[] | undefined;
+        linkedCodeSnippetIds?: string[] | undefined;
+        linkedTypeSnippetIds?: string[] | undefined;
+    }[];
+    filesToBeCreated: string[];
+    filesToBeModified: string[];
+    filesToBeDeleted: string[];
+    filesToBeReferenced: string[];
+    guardrails: string[];
+    codeReferences: {
+        filePath: string;
+        symbol?: string | undefined;
+        description?: string | undefined;
+    }[];
+    typeReferences: {
+        filePath: string;
+        typeName: string;
+        description?: string | undefined;
+    }[];
+    blueprintReferences: {
+        blueprintId: string;
+        context?: string | null | undefined;
+        section?: string | null | undefined;
+    }[];
+    dependencies: {
+        type: "requires" | "blocks";
+        ticketId: string;
+        origin?: {
+            provenance?: boolean | undefined;
+            scaffold?: boolean | undefined;
+            semantic?: boolean | undefined;
+        } | undefined;
+    }[];
+    order?: number | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    ticketNumber?: number | undefined;
+    testSpecification?: {
+        testTypes: ("unit" | "integration" | "e2e" | "typecheck" | "lint" | "build" | "contract" | "structural" | "layout" | "a11y" | "performance")[];
+        qualityGates: string[];
+        testCommands: string[];
+        coverageTarget?: number | null | undefined;
+    } | undefined;
+    codeSnippets?: {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }[] | undefined;
+    typeSnippets?: {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }[] | undefined;
+    fieldDeclarations?: Record<string, {
+        value: "N/A";
+        reason: string;
+    }> | undefined;
+    fileChangeRefs?: {
+        path: string;
+        id: string;
+        kind: string;
+        symbol?: string | undefined;
+        why?: string | undefined;
+    }[] | undefined;
+}, {
+    id: string;
+    title: string;
+    epicId: string;
+    ticketType: "implementation" | "verification";
+    complexity: "small" | "medium" | "large" | "xlarge";
+    estimatedMinutes: number;
+    acceptanceCriteria: {
+        id: string;
+        given: string;
+        when: string;
+        then: string;
+        order: number;
+    }[];
+    implementationSteps: {
+        id: string;
+        order: number;
+        text: string;
+        files?: {
+            path: string;
+            role: string;
+            symbol?: string | undefined;
+            why?: string | undefined;
+        }[] | undefined;
+        linkedFileIds?: string[] | undefined;
+        linkedCodeSnippetIds?: string[] | undefined;
+        linkedTypeSnippetIds?: string[] | undefined;
+    }[];
+    filesToBeCreated: string[];
+    filesToBeModified: string[];
+    filesToBeDeleted: string[];
+    filesToBeReferenced: string[];
+    guardrails: string[];
+    codeReferences: {
+        filePath: string;
+        symbol?: string | undefined;
+        description?: string | undefined;
+    }[];
+    typeReferences: {
+        filePath: string;
+        typeName: string;
+        description?: string | undefined;
+    }[];
+    blueprintReferences: {
+        blueprintId: string;
+        context?: string | null | undefined;
+        section?: string | null | undefined;
+    }[];
+    dependencies: {
+        type: "requires" | "blocks";
+        ticketId: string;
+        origin?: {
+            provenance?: boolean | undefined;
+            scaffold?: boolean | undefined;
+            semantic?: boolean | undefined;
+        } | undefined;
+    }[];
+    order?: number | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    ticketNumber?: number | undefined;
+    testSpecification?: {
+        testTypes: ("unit" | "integration" | "e2e" | "typecheck" | "lint" | "build" | "contract" | "structural" | "layout" | "a11y" | "performance")[];
+        qualityGates: string[];
+        testCommands: string[];
+        coverageTarget?: number | null | undefined;
+    } | undefined;
+    codeSnippets?: {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }[] | undefined;
+    typeSnippets?: {
+        id: string;
+        language: string;
+        content: string;
+        order?: number | undefined;
+        description?: string | undefined;
+        sourcePath?: string | undefined;
+    }[] | undefined;
+    fieldDeclarations?: Record<string, {
+        value: "N/A";
+        reason: string;
+    }> | undefined;
+    fileChangeRefs?: {
+        path: string;
+        id: string;
+        kind: string;
+        symbol?: string | undefined;
+        why?: string | undefined;
+    }[] | undefined;
+}>;
+export type Ticket = z.infer<typeof TicketSchema>;
+//# sourceMappingURL=ticket.d.ts.map

package/node_modules/@specforge/spec-types/dist/schema/ticket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticket.d.ts","sourceRoot":"","sources":["../../src/schema/ticket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmBxB,eAAO,MAAM,cAAc,+CAA6C,CAAC;AACzE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,eAAO,MAAM,oBAAoB,mDAAiD,CAAC;AACnF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAOpE,eAAO,MAAM,gBAAgB,8DAA4D,CAAC;AAC1F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE5D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/node_modules/@specforge/spec-types/dist/schema/ticket.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { AcceptanceCriterionSchema, ImplementationStepSchema, TestSpecificationSchema, CodeReferenceSchema, TypeReferenceSchema, CodeSnippetSchema, TypeSnippetSchema, BlueprintReferenceSchema, DependencyLinkSchema, FieldDeclarationSchema, FileChangeRefSchema, } from './auxiliary.js';
+// Ticket enum vocabularies — extracted to named enums so the ME.14.2 APS enum
+// write-guard + the validator enum-parity guard share one source with the model.
+// `ticketType`/`complexity` are OpenSpec content (referenced by TicketSchema below);
+// `status` is runtime/model-only (the Ticket `status` column, not a schema field).
+export const TicketTypeEnum = z.enum(['implementation', 'verification']);
+export const TicketComplexityEnum = z.enum(['small', 'medium', 'large', 'xlarge']);
+// `blocked` is a first-class work-runtime TicketStatus (M15.5a clean break, Gabriel
+// 2026-06): set during implementation via a `blocking` discovery
+// (Ticket.status='blocked' + WorkSession.blockReason), 0 during planning, unblocked by
+// the human's resolve_discovery (blocked→pending). MB.15 (2026-07-24) converges the
+// canonical enum with the live model/api-types/aggregators that already carry it.
+export const TicketStatusEnum = z.enum(['pending', 'ready', 'active', 'done', 'blocked']);
+export const TicketSchema = z.object({
+    id: z.string(),
+    epicId: z.string(),
+    ticketNumber: z.number().int().positive().optional(),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    ticketType: TicketTypeEnum,
+    complexity: TicketComplexityEnum,
+    estimatedMinutes: z.number().int().min(0),
+    order: z.number().int().nonnegative().optional(),
+    // Categorization tags — real Ticket column (a.string().array()); persisted on create.
+    tags: z.array(z.string()).optional(),
+    acceptanceCriteria: z.array(AcceptanceCriterionSchema),
+    implementationSteps: z.array(ImplementationStepSchema),
+    filesToBeCreated: z.array(z.string()),
+    filesToBeModified: z.array(z.string()),
+    filesToBeDeleted: z.array(z.string()),
+    filesToBeReferenced: z.array(z.string()),
+    testSpecification: TestSpecificationSchema.optional(),
+    guardrails: z.array(z.string()),
+    codeReferences: z.array(CodeReferenceSchema),
+    typeReferences: z.array(TypeReferenceSchema),
+    codeSnippets: z.array(CodeSnippetSchema).optional(),
+    typeSnippets: z.array(TypeSnippetSchema).optional(),
+    blueprintReferences: z.array(BlueprintReferenceSchema),
+    dependencies: z.array(DependencyLinkSchema),
+    fieldDeclarations: z.record(z.string(), FieldDeclarationSchema).optional(),
+    // MB.14.1 — id-bearing file-change SIDECAR (parallel to the path-only
+    // `filesToBe*` arrays). Hydrated from `TicketFileChange` rows; the MB.14.2
+    // `orphan-file` FK check matches each declared file's `id` against the steps'
+    // `linkedFileIds`. INTERNAL recompose field (not published openspec.tech), so
+    // additive + optional keeps the openspec-parity enum guard untouched.
+    fileChangeRefs: z.array(FileChangeRefSchema).optional(),
+});
+//# sourceMappingURL=ticket.js.map

package/node_modules/@specforge/spec-types/dist/schema/ticket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticket.js","sourceRoot":"","sources":["../../src/schema/ticket.ts"],"names":[],"mappings":"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"}

package/node_modules/@specforge/spec-types/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@specforge/spec-types",
+  "version": "0.4.7",
+  "description": "Public OpenSpec v1.1 schema — types, Zod schemas, JSON Schema. Future OSS as @openspec/types.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "registry": "https://specforge-316884453263.d.codeartifact.us-east-1.amazonaws.com/npm/npm-packages/"
+  },
+  "scripts": {
+    "prebuild": "tsx scripts/generate-json-schema.ts",
+    "openspec:fetch": "tsx scripts/fetch-published-schema.ts",
+    "build": "tsc",
+    "postbuild": "[ -d src/json-schema ] && cp -r src/json-schema dist/ || true",
+    "clean": "rm -rf dist",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@vitest/coverage-v8": "4.0.18",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "4.0.18",
+    "zod-to-json-schema": "^3.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specforge/canary-cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "MCP server for SpecForge - AI agent integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,8 +17,11 @@
     "inquirer": "^9.3.8",
     "minimatch": "^10.1.1",
     "ora": "^8.2.0",
-    "@specforge/session-types": "0.4.3",
-    "@specforge/types": "1.0.2"
+    "zod": "^3.22.0",
+    "@specforge/api-types": "0.4.8",
+    "@specforge/spec-types": "0.4.7",
+    "@specforge/session-types": "0.4.7",
+    "@specforge/report-types": "0.4.3"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
@@ -30,7 +33,7 @@
     "tsx": "^4.7.0",
     "typescript": "^5.0.0",
     "vitest": "4.0.18",
-    "@specforge/lifecycle": "0.3.3"
+    "@specforge/lifecycle": "0.3.7"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -53,10 +56,12 @@
     "access": "public"
   },
   "bundleDependencies": [
-    "@specforge/types",
-    "@specforge/session-types"
+    "@specforge/spec-types",
+    "@specforge/api-types",
+    "@specforge/session-types",
+    "@specforge/report-types"
   ],
-  "gitHead": "907b03d7d527d1442ee474a9326395fe1e631846",
+  "gitHead": "916e9ade08a18c8acfb102fcb9848ef7757f5400",
   "scripts": {
     "build": "tsup && tsc --emitDeclarationOnly --outDir dist",
     "typecheck": "tsc --noEmit",

package/src/cli/templates/skills/specforge-orchestrator.md

@@ -411,4 +411,4 @@ When `.specforge.json` has monorepo configuration:
 - **Epic:** `todo` | `in_progress` | `completed`
 - **Specification:** `draft` | `planning` | `ready` | `in_progress` | `completed`
 
-Note: There is no `in_review` status. Tickets go directly from `active` to `done`.
+Note: There is no in-review status. Tickets go directly from `active` to `done`.

package/src/cli/templates/skills/specforge-worker.md

@@ -404,7 +404,7 @@ If you cannot complete the ticket after reasonable attempts:
 ## Status Values
 
 - **Ticket:** `pending` | `ready` | `active` | `done` | `blocked`
-- There is no `in_review` status. Tickets go directly from `active` to `done`.
+- There is no in-review status. Tickets go directly from `active` to `done`.
 - `pending` means dependencies are not met. `ready` means all dependencies satisfied.
 - `blocked` is a first-class status set by a `blocking` discovery; resolving it returns the ticket to `pending`.
 - `start_work_session` transitions `ready` → `active`.