@defrex/autobuild 0.12.0 → 0.14.0

package/packages/core/src/config/schema.ts

@@ -535,7 +535,8 @@ export type PolicyConfig = z.infer<typeof policySchema>
 // API key comes from the LINEAR_API_KEY environment variable, never from this
 // file.
 
-export const ticketsSchema = z.strictObject({
+export const ticketsInputSchema = z.strictObject({
+  url: z.string().optional(),
   /** Builtin or plugin-registered TicketSource name. Registry membership is
    * validated after configured plugins load. */
   source: z
@@ -569,7 +570,8 @@ export const ticketsSchema = z.strictObject({
     .refine(
       (s) => s.trim().length > 0,
       '[tickets].readyState must not be blank — name the one workflow state a ticket must sit in to be dispatched (e.g. "ready").',
-    ),
+    )
+    .optional(),
   /**
    * Narrows readiness to tickets assigned to one Linear user — a third
    * conjunctive gate beside readyState and readyLabels. `"me"` is the owner of
@@ -592,7 +594,7 @@ export const ticketsSchema = z.strictObject({
     .min(1)
     .refine((value) => value.trim().length > 0, 'state must be nonblank')
     .optional(),
-  /** Hosted project completion state; defaults to Done. */
+  /** Hosted project completion state; defaults to done. */
   doneState: z
     .string()
     .min(1)
@@ -634,6 +636,36 @@ export const ticketsSchema = z.strictObject({
    * still tell a defaulted dir from an explicit one. */
   dir: z.string().min(1).optional(),
 })
+export const ticketsSchema = ticketsInputSchema
+  .superRefine((tickets, ctx) => {
+    if (tickets.source === 'hosted' && tickets.url !== undefined) {
+      try {
+        normalizeServiceURL(tickets.url, 'tickets.url')
+      } catch (error) {
+        ctx.addIssue({ code: 'custom', path: ['url'], message: (error as Error).message })
+      }
+    }
+    if (tickets.source !== 'hosted' && tickets.readyState === undefined)
+      ctx.addIssue({
+        code: 'custom',
+        path: ['readyState'],
+        message:
+          '[tickets].readyState is required — name the one workflow state a ticket must sit in to be dispatched (e.g. "ready").',
+      })
+    if (['file', 'linear'].includes(tickets.source) && tickets.url !== undefined)
+      ctx.addIssue({
+        code: 'custom',
+        path: ['url'],
+        message: '[tickets].url applies only to source = "hosted"',
+      })
+  })
+  .transform((tickets) => ({
+    ...tickets,
+    readyState: tickets.readyState ?? 'ready',
+    ...(tickets.source === 'hosted' && tickets.url !== undefined
+      ? { url: normalizeServiceURL(tickets.url, 'tickets.url') }
+      : {}),
+  }))
 export type TicketsConfig = z.infer<typeof ticketsSchema>
 
 // ── [orchestrator] ──────────────────────────────────────────────────────────

package/packages/core/src/connection.ts

@@ -19,12 +19,12 @@ export interface ConnectionStarted extends ConnectionOutcome {
   interval: number
   expiresAt: string
 }
-export function normalizeServiceURL(raw: string): string {
+export function normalizeServiceURL(raw: string, setting = 'store.url'): string {
   let url: URL
   try {
     url = new URL(raw)
   } catch {
-    throw new Error('store.url must be an absolute HTTPS service URL')
+    throw new Error(`${setting} must be an absolute HTTPS service URL`)
   }
   if (
     !raw.trim() ||
@@ -39,7 +39,7 @@ export function normalizeServiceURL(raw: string): string {
     )
   ) {
     throw new Error(
-      'store.url must be HTTPS (HTTP is allowed on loopback), without credentials, query or fragment',
+      `${setting} must be HTTPS (HTTP is allowed on loopback), without credentials, query or fragment`,
     )
   }
   return url.href.replace(/\/+$/, '')

package/packages/core/src/events/catalog.ts

@@ -185,10 +185,11 @@ export function validateEventWrite(input: {
       actor.kind === 'dispatcher' &&
       (escalation.source !== 'policy' ||
         (escalation.policyCause !== 'infrastructure-failure-limit' &&
-          escalation.policyCause !== 'dispatch-failure-limit'))
+          escalation.policyCause !== 'dispatch-failure-limit' &&
+          escalation.policyCause !== 'execution-no-progress'))
     ) {
       throw new EventValidationError(
-        'invalid dispatcher escalation: only policy/infrastructure-failure-limit or policy/dispatch-failure-limit may be raised outside the kernel',
+        'invalid dispatcher escalation: only policy/infrastructure-failure-limit or policy/dispatch-failure-limit or policy/execution-no-progress may be raised outside the kernel',
       )
     }
     if (escalation.source === 'policy' && escalation.policyCause === undefined) {

package/packages/core/src/events/payloads.ts

@@ -196,6 +196,12 @@ const finalizeStepCompletedPayloadSchema = z.discriminatedUnion('ok', [
 /** One ticket asset revision a build froze (SPEC §6.3): the identity and
  * shape of what `listTicketAssets` returned at the pinning moment. */
 export const pinnedAssetSchema = z.strictObject({
+  snapshot: z
+    .strictObject({
+      kind: z.string().regex(/^ticket-snapshot-[a-f0-9-]+$/),
+      revision: z.number().int().nonnegative(),
+    })
+    .optional(),
   kind: z.string().min(1),
   name: z.string().min(1),
   revision: z.number().int().nonnegative(),

package/packages/core/src/events/repository.ts

@@ -411,9 +411,12 @@ export const dispatcherStatusEventPayloadSchemas = {
     run: dispatchRun,
     error: z.string().min(1),
   }),
-  /** Brackets the one unsafe-to-force dispatcher turn. A supervisor may kill
-   * an unresponsive child only when no started turn remains open. */
-  'dispatcher.tick-started': z.strictObject({ run: dispatchRun }),
+  /** Recorded boundaries of meaningful turns. The repository tick observation
+   * protects active work from forced stop while these facts are buffered. */
+  'dispatcher.tick-started': z.strictObject({
+    run: dispatchRun,
+    startedAt: z.iso.datetime().optional(),
+  }),
   'dispatcher.tick-completed': z.strictObject({
     run: dispatchRun,
     queued: z.number().int().nonnegative(),
@@ -421,6 +424,7 @@ export const dispatcherStatusEventPayloadSchemas = {
      * dispatcher child transported a display sample in its tick fact. */
     observations: z.number().int().nonnegative().optional(),
     counters: tickCountersSchema,
+    blockedDiagnostics: boundedDiagnostics.optional(),
     janitorDiagnostics: boundedDiagnostics,
     ticketDiagnostics: boundedDiagnostics,
     creationDiagnostics: boundedDiagnostics.optional(),

package/packages/core/src/integration/harness.ts

@@ -57,7 +57,13 @@ import type {
 import { GitWorktreeProvider, spawnExec } from '../ports/workspace/git-worktree'
 import { InProcessBuildExecution } from '../ports/workspace/in-process-build-execution'
 import { BuildRunner, LeaseHeldError, SetupFailureError } from '../processes/build-runner'
-import { diagnosticArtifact } from '../processes/build-execution-state'
+import {
+  diagnosticArtifact,
+  BUILD_EFFECTIVE_CONFIG_ARTIFACT,
+  effectiveBuildConfigContent,
+  parseEffectiveBuildConfig,
+} from '../processes/build-execution-state'
+import { composeBuildConfig } from '../config/live'
 import { Dispatcher, type LaunchRunnerResult } from '../processes/dispatcher'
 import {
   getHarvestStatus,
@@ -120,6 +126,7 @@ export const CONFORMING_BODY = [
 export function readyTicket(id: string, over: Partial<Omit<Ticket, 'ref'>> = {}): Ticket {
   const title = over.title ?? 'Add rate limiting'
   return {
+    revision: 'fixture',
     ref: { source: 'fake', id, title },
     title,
     body: over.body ?? CONFORMING_BODY,
@@ -330,7 +337,7 @@ async function repositoryReading(store: BuildStore, repo: string) {
     builds[slug] = { facts: await plainFacts(view, slug), state: await view.buildState(slug) }
   }
   return {
-    journal: view.recordedJournal(),
+    journal: (await store.getRepo(repo)) === null ? [] : await store.getRepoStateEvents(repo),
     digests: [...(await view.getRepoBuildDigests(repo)).entries()].sort(([a], [b]) =>
       a.localeCompare(b),
     ),
@@ -353,7 +360,6 @@ export async function assertSnapshotEquivalence(store: BuildStore, repo: string)
     if (canonical(got) !== canonical(want)) {
       throw new Error(`snapshot-restored reading differs from full replay (${round})`)
     }
-    await restoredView.persistSnapshots({ force: true })
   }
   // The operator routes derive from the same view: each response with
   // snapshots present equals the response with every snapshot deleted.
@@ -398,6 +404,10 @@ export async function makeHarness(opts: {
    * CONFIG_TOML, so every existing scenario is untouched; a scenario proving
    * two-axis routing (§9) supplies its own `[roles.default]`/phase roles. */
   configToml?: string
+  /** Force a routing disagreement while retaining the runner's branch config. */
+  dispatcherConfig?: (config: Config) => Config
+  pinnedConfig?: boolean
+  getConfig?: () => Config
   /** Forge gate existence is independent from current PR mergeability. */
   gatePresence?: 'present' | 'absent'
   /** Optional adapter-level runtime composition for focused integration tests.
@@ -602,6 +612,20 @@ export async function makeHarness(opts: {
       runner: new BuildRunner({
         store: activeStore.scopeBuild(slug),
         config,
+        ...(opts.pinnedConfig
+          ? {
+              getConfig: async () => {
+                const artifact = await activeStore.getArtifact(
+                  slug,
+                  BUILD_EFFECTIVE_CONFIG_ARTIFACT,
+                )
+                return composeBuildConfig(
+                  artifact === null ? config : parseEffectiveBuildConfig(artifact),
+                  opts.getConfig?.() ?? config,
+                )
+              },
+            }
+          : {}),
         // Two-axis registry (§9): every runtime is backed by the SAME scripted
         // runner instance, so the `s_1…s_N` session numbering scenarios rely on
         // is preserved regardless of which runtime a role selects. `scripted`
@@ -629,6 +653,15 @@ export async function makeHarness(opts: {
     }
   }
   const launchRunner = async (slug: string): Promise<LaunchRunnerResult> => {
+    if (
+      opts.pinnedConfig &&
+      (await activeStore.getArtifact(slug, BUILD_EFFECTIVE_CONFIG_ARTIFACT)) === null
+    ) {
+      await activeStore.putArtifact(slug, {
+        kind: BUILD_EFFECTIVE_CONFIG_ARTIFACT,
+        content: effectiveBuildConfigContent(config),
+      })
+    }
     launched.push({ slug, ...(await makeRunner(slug)) })
     return 'scheduled'
   }
@@ -638,10 +671,11 @@ export async function makeHarness(opts: {
     tickets: ticketSource,
     workspaces,
     forge: selectedForge,
-    config,
+    config: opts.dispatcherConfig?.(structuredClone(config)) ?? config,
     repo: origin,
     exec: spawnExec,
     launchRunner,
+    ...(opts.getConfig ? { getConfig: opts.getConfig } : {}),
     ids,
     clock,
   })