@specforge/cli 0.1.0 → 0.2.4

package/node_modules/@specforge/session-types/dist/runtime/implementation-config.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+/**
+ * Implementation (work) lifecycle config — the canonical contract type, resolved
+ * per-project/spec and persisted via the existing generic domain-keyed config models
+ * (`ProjectConfiguration` template + `SpecificationConfiguration` snapshot, domain
+ * `implementation-lifecycle`). Lives here in session-types (alongside the planning
+ * lifecycle config + the other work contracts) so every consumer shares ONE source —
+ * no new model, the imp lifecycle is just the `<future>` domain the generic config
+ * models already allow (M14.3a).
+ *
+ * Pattern-mirror of {@link ./planning-config.ts} (NOT a field-mirror): same structural
+ * shape (domain const + schema-version + `…Schema` + deep-partial `…OverridesSchema` +
+ * `…_DEFAULTS` literal), but the FIELDS are authored from scratch for the work lifecycle.
+ *
+ * This config holds work-lifecycle BEHAVIOUR knobs only. Numeric scoring thresholds /
+ * entity counts stay owned by the validator/assay config (see
+ * [[project_me10_config_reconciliation]]) — they are NOT duplicated here.
+ *
+ * Scope: type + schema + defaults ONLY (M14.3). The deepMerge resolution behaviour
+ * (`deepMerge(IMPLEMENTATION_LIFECYCLE_DEFAULTS, snapshot ?? {})`) stays in
+ * @specforge/lifecycle (M16.11); spec-create snapshot freeze is M15; the webapp config
+ * write surface is M24.
+ */
+export declare const IMPLEMENTATION_LIFECYCLE_CONFIG_DOMAIN: "implementation-lifecycle";
+export declare const IMPLEMENTATION_LIFECYCLE_CONFIG_SCHEMA_VERSION = 1;
+export declare const ImplementationLifecycleConfigSchema: z.ZodObject<{
+    maxRetries: z.ZodNumber;
+    skipStepsCheck: z.ZodBoolean;
+    validateFiles: z.ZodEnum<["agent", "local"]>;
+    gates: z.ZodObject<{
+        acceptance: z.ZodBoolean;
+        step: z.ZodBoolean;
+        file: z.ZodBoolean;
+        test: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        step: boolean;
+        file: boolean;
+        test: boolean;
+        acceptance: boolean;
+    }, {
+        step: boolean;
+        file: boolean;
+        test: boolean;
+        acceptance: boolean;
+    }>;
+    weights: z.ZodObject<{
+        steps: z.ZodNumber;
+        ac: z.ZodNumber;
+        tests: z.ZodNumber;
+        files: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        tests: number;
+        files: number;
+        ac: number;
+        steps: number;
+    }, {
+        tests: number;
+        files: number;
+        ac: number;
+        steps: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    maxRetries: number;
+    skipStepsCheck: boolean;
+    validateFiles: "agent" | "local";
+    gates: {
+        step: boolean;
+        file: boolean;
+        test: boolean;
+        acceptance: boolean;
+    };
+    weights: {
+        tests: number;
+        files: number;
+        ac: number;
+        steps: number;
+    };
+}, {
+    maxRetries: number;
+    skipStepsCheck: boolean;
+    validateFiles: "agent" | "local";
+    gates: {
+        step: boolean;
+        file: boolean;
+        test: boolean;
+        acceptance: boolean;
+    };
+    weights: {
+        tests: number;
+        files: number;
+        ac: number;
+        steps: number;
+    };
+}>;
+export type ImplementationLifecycleConfig = z.infer<typeof ImplementationLifecycleConfigSchema>;
+/**
+ * ImplementationLifecycleConfigOverridesSchema — a permissive DeepPartial of
+ * {@link ImplementationLifecycleConfigSchema}. A project/spec-level override is a sparse
+ * `DeepPartial<ImplementationLifecycleConfig>` (e.g. `{ gates: { test: false } }`).
+ *
+ * Like `PlanningLifecycleConfigSchema`, this is a plain `ZodObject` tree of objects +
+ * primitives with NO cross-field refinements, so `.deepPartial()` is safe (no `ZodEffects`
+ * to trip over). The full schema is still re-checked on the deepMerged result by the
+ * resolver in @specforge/lifecycle (M16.11).
+ */
+export declare const ImplementationLifecycleConfigOverridesSchema: z.ZodObject<{
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+    skipStepsCheck: z.ZodOptional<z.ZodBoolean>;
+    validateFiles: z.ZodOptional<z.ZodEnum<["agent", "local"]>>;
+    gates: z.ZodOptional<z.ZodObject<{
+        acceptance: z.ZodOptional<z.ZodBoolean>;
+        step: z.ZodOptional<z.ZodBoolean>;
+        file: z.ZodOptional<z.ZodBoolean>;
+        test: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        step?: boolean | undefined;
+        file?: boolean | undefined;
+        test?: boolean | undefined;
+        acceptance?: boolean | undefined;
+    }, {
+        step?: boolean | undefined;
+        file?: boolean | undefined;
+        test?: boolean | undefined;
+        acceptance?: boolean | undefined;
+    }>>;
+    weights: z.ZodOptional<z.ZodObject<{
+        steps: z.ZodOptional<z.ZodNumber>;
+        ac: z.ZodOptional<z.ZodNumber>;
+        tests: z.ZodOptional<z.ZodNumber>;
+        files: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        tests?: number | undefined;
+        files?: number | undefined;
+        ac?: number | undefined;
+        steps?: number | undefined;
+    }, {
+        tests?: number | undefined;
+        files?: number | undefined;
+        ac?: number | undefined;
+        steps?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    maxRetries?: number | undefined;
+    skipStepsCheck?: boolean | undefined;
+    validateFiles?: "agent" | "local" | undefined;
+    gates?: {
+        step?: boolean | undefined;
+        file?: boolean | undefined;
+        test?: boolean | undefined;
+        acceptance?: boolean | undefined;
+    } | undefined;
+    weights?: {
+        tests?: number | undefined;
+        files?: number | undefined;
+        ac?: number | undefined;
+        steps?: number | undefined;
+    } | undefined;
+}, {
+    maxRetries?: number | undefined;
+    skipStepsCheck?: boolean | undefined;
+    validateFiles?: "agent" | "local" | undefined;
+    gates?: {
+        step?: boolean | undefined;
+        file?: boolean | undefined;
+        test?: boolean | undefined;
+        acceptance?: boolean | undefined;
+    } | undefined;
+    weights?: {
+        tests?: number | undefined;
+        files?: number | undefined;
+        ac?: number | undefined;
+        steps?: number | undefined;
+    } | undefined;
+}>;
+export type ImplementationLifecycleConfigOverrides = z.infer<typeof ImplementationLifecycleConfigOverridesSchema>;
+export declare const IMPLEMENTATION_LIFECYCLE_DEFAULTS: ImplementationLifecycleConfig;
+//# sourceMappingURL=implementation-config.d.ts.map

package/node_modules/@specforge/session-types/dist/runtime/implementation-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation-config.d.ts","sourceRoot":"","sources":["../../src/runtime/implementation-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sCAAsC,EAAG,0BAAmC,CAAC;AAE1F,eAAO,MAAM,8CAA8C,IAAI,CAAC;AAEhE,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B9C,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEhG;;;;;;;;;GASG;AACH,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AAC9G,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4CAA4C,CAAC,CAAC;AAKlH,eAAO,MAAM,iCAAiC,EAAE,6BAsB/C,CAAC"}

package/node_modules/@specforge/session-types/dist/runtime/implementation-config.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+/**
+ * Implementation (work) lifecycle config — the canonical contract type, resolved
+ * per-project/spec and persisted via the existing generic domain-keyed config models
+ * (`ProjectConfiguration` template + `SpecificationConfiguration` snapshot, domain
+ * `implementation-lifecycle`). Lives here in session-types (alongside the planning
+ * lifecycle config + the other work contracts) so every consumer shares ONE source —
+ * no new model, the imp lifecycle is just the `<future>` domain the generic config
+ * models already allow (M14.3a).
+ *
+ * Pattern-mirror of {@link ./planning-config.ts} (NOT a field-mirror): same structural
+ * shape (domain const + schema-version + `…Schema` + deep-partial `…OverridesSchema` +
+ * `…_DEFAULTS` literal), but the FIELDS are authored from scratch for the work lifecycle.
+ *
+ * This config holds work-lifecycle BEHAVIOUR knobs only. Numeric scoring thresholds /
+ * entity counts stay owned by the validator/assay config (see
+ * [[project_me10_config_reconciliation]]) — they are NOT duplicated here.
+ *
+ * Scope: type + schema + defaults ONLY (M14.3). The deepMerge resolution behaviour
+ * (`deepMerge(IMPLEMENTATION_LIFECYCLE_DEFAULTS, snapshot ?? {})`) stays in
+ * @specforge/lifecycle (M16.11); spec-create snapshot freeze is M15; the webapp config
+ * write surface is M24.
+ */
+export const IMPLEMENTATION_LIFECYCLE_CONFIG_DOMAIN = 'implementation-lifecycle';
+// First version of the imp-lifecycle config schema — greenfield, no migration.
+export const IMPLEMENTATION_LIFECYCLE_CONFIG_SCHEMA_VERSION = 1;
+export const ImplementationLifecycleConfigSchema = z.object({
+    // System AWS-lockout retry budget: after this many failed advance attempts on a
+    // WorkSession the lifecycle locks the session into create_discovery only (M16).
+    // PINNED default 7 (Gabriel 2026-06 — no longer "e.g. 5–7").
+    maxRetries: z.number().int(),
+    // When true, the implementation-steps completion gate is skipped — the agent may
+    // advance without every TicketImplementationStep marked done (M16 consumes).
+    skipStepsCheck: z.boolean(),
+    // Who validates the recorded file changes:
+    //  - 'agent' → trust the agent's self-reported record_file_change set.
+    //  - 'local' → the MCP-local verifies the changes against the worktree.
+    // Consumption is M16; the knob lands here.
+    validateFiles: z.enum(['agent', 'local']),
+    // Per-gate on/off switches for the four advance gates (M16). Disabling a gate lets
+    // the lifecycle advance past that dimension without its check.
+    gates: z.object({
+        acceptance: z.boolean(),
+        step: z.boolean(),
+        file: z.boolean(),
+        test: z.boolean(),
+    }),
+    // M17 progress-aggregate weights: the per-dimension contribution to the ticket
+    // completion (progress) score. Authored here as a behaviour knob; the assay reads
+    // them when it aggregates ticket progress (M17). Coherence is a separate fixed
+    // formula and carries no weights.
+    weights: z.object({
+        steps: z.number(),
+        ac: z.number(),
+        tests: z.number(),
+        files: z.number(),
+    }),
+});
+/**
+ * ImplementationLifecycleConfigOverridesSchema — a permissive DeepPartial of
+ * {@link ImplementationLifecycleConfigSchema}. A project/spec-level override is a sparse
+ * `DeepPartial<ImplementationLifecycleConfig>` (e.g. `{ gates: { test: false } }`).
+ *
+ * Like `PlanningLifecycleConfigSchema`, this is a plain `ZodObject` tree of objects +
+ * primitives with NO cross-field refinements, so `.deepPartial()` is safe (no `ZodEffects`
+ * to trip over). The full schema is still re-checked on the deepMerged result by the
+ * resolver in @specforge/lifecycle (M16.11).
+ */
+export const ImplementationLifecycleConfigOverridesSchema = ImplementationLifecycleConfigSchema.deepPartial();
+// ---------------------------------------------------------------------------
+// IMPLEMENTATION_LIFECYCLE_DEFAULTS — baseline merged under project/spec overrides.
+// ---------------------------------------------------------------------------
+export const IMPLEMENTATION_LIFECYCLE_DEFAULTS = {
+    maxRetries: 7,
+    skipStepsCheck: false,
+    validateFiles: 'local',
+    gates: {
+        acceptance: true,
+        step: true,
+        file: true,
+        test: true,
+    },
+    // MB.14.5 — step-file UNIFIED weights. The step↔file links (MB.14.1) merge the old
+    // separate `steps` (.40) + `files` (.15) dimensions into one step-file dimension
+    // (`steps`: 0.55): the assay `computeImplStepProgress` now requires a step's linked
+    // files recorded `matched`, so `files` carries 0. The 4-key struct shape is KEPT
+    // (the assay `ProgressWeightsSchema` is `.strict()` on {steps,ac,tests,files}).
+    // DECIDED (c): 0.55 is the DEFAULT; MB.14.7 makes these user-configurable.
+    weights: {
+        steps: 0.55,
+        ac: 0.3,
+        tests: 0.15,
+        files: 0,
+    },
+};
+//# sourceMappingURL=implementation-config.js.map

package/node_modules/@specforge/session-types/dist/runtime/implementation-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation-config.js","sourceRoot":"","sources":["../../src/runtime/implementation-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,0BAAmC,CAAC;AAC1F,+EAA+E;AAC/E,MAAM,CAAC,MAAM,8CAA8C,GAAG,CAAC,CAAC;AAEhE,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1D,gFAAgF;IAChF,gFAAgF;IAChF,6DAA6D;IAC7D,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IAC5B,iFAAiF;IACjF,6EAA6E;IAC7E,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE;IAC3B,2CAA2C;IAC3C,uEAAuE;IACvE,wEAAwE;IACxE,2CAA2C;IAC3C,aAAa,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACzC,mFAAmF;IACnF,+DAA+D;IAC/D,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC;QACd,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE;QACvB,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;QACjB,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;QACjB,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;KAClB,CAAC;IACF,+EAA+E;IAC/E,kFAAkF;IAClF,+EAA+E;IAC/E,kCAAkC;IAClC,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC;QAChB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;QACjB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;QACd,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;QACjB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;KAClB,CAAC;CACH,CAAC,CAAC;AAGH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,4CAA4C,GAAG,mCAAmC,CAAC,WAAW,EAAE,CAAC;AAG9G,8EAA8E;AAC9E,oFAAoF;AACpF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,iCAAiC,GAAkC;IAC9E,UAAU,EAAE,CAAC;IACb,cAAc,EAAE,KAAK;IACrB,aAAa,EAAE,OAAO;IACtB,KAAK,EAAE;QACL,UAAU,EAAE,IAAI;QAChB,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;KACX;IACD,mFAAmF;IACnF,iFAAiF;IACjF,oFAAoF;IACpF,iFAAiF;IACjF,gFAAgF;IAChF,2EAA2E;IAC3E,OAAO,EAAE;QACP,KAAK,EAAE,IAAI;QACX,EAAE,EAAE,GAAG;QACP,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,CAAC;KACT;CACF,CAAC"}

package/node_modules/@specforge/session-types/dist/runtime/implementation-record-event.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { ImplementationRecordEventSchema } from '../schema/implementation-record-event.js';
+/**
+ * ImplementationRecordEvent — work-lifecycle transition/event row (M15.4 / M19.1).
+ * See `../schema/implementation-record-event.ts` for the field-set contract.
+ */
+export type ImplementationRecordEvent = z.infer<typeof ImplementationRecordEventSchema>;
+//# sourceMappingURL=implementation-record-event.d.ts.map

package/node_modules/@specforge/session-types/dist/runtime/implementation-record-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation-record-event.d.ts","sourceRoot":"","sources":["../../src/runtime/implementation-record-event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAEhG;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/node_modules/@specforge/session-types/dist/runtime/implementation-record-event.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=implementation-record-event.js.map

package/node_modules/@specforge/session-types/dist/runtime/implementation-record-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation-record-event.js","sourceRoot":"","sources":["../../src/runtime/implementation-record-event.ts"],"names":[],"mappings":""}