@deepseek-ai/dsh-goal 0.0.1-rc.1

package/lib/types/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Pure types of the goal domain: the ONE home of the `goal` projection-key
+ * declaration plus the durable payload vocabulary it carries, free of this
+ * package's host-side imports (cordis events, dsh-agent, dsh-llm, the
+ * service). Two namespace projections serve it — `./types` for host
+ * consumers, `./client` (the browser half-entry's re-export) for client
+ * aggregates — with zero content duplication. Host-coupled domain
+ * vocabulary (message sources, events, fold shapes) lives in ./domain.ts.
+ *
+ * @module @deepseek-ai/dsh-goal/types
+ */
+import type { Branded } from '@deepseek-ai/dsh-brand';
+/** Identifies one goal across its durable revisions. */
+export type GoalId = Branded<'GoalId'>;
+/** Compare-and-set identity for one exact goal revision. */
+export interface GoalRef {
+    /** Stable goal identity. */
+    readonly id: GoalId;
+    /** Positive revision; every durable mutation increments it. */
+    readonly revision: number;
+}
+/** Input whose omitted round cap is resolved by the service configuration. */
+export interface CreateGoalRequest {
+    readonly objective: string;
+    readonly maxGoalRounds?: number;
+}
+/** Wire-safe acknowledgement of one created goal. */
+export interface CreateGoalResult {
+    readonly ref: GoalRef;
+}
+/** Fields changed by an edit; at least one must be present. */
+export interface EditGoalRequest {
+    readonly objective?: string;
+    readonly maxGoalRounds?: number;
+}
+/** Durable continuation phase. Activation is process-local and separate. */
+export type GoalPhase = 'active' | 'paused' | 'blocked' | 'complete';
+/** Machine-routable and human-readable explanation for a blocked goal. */
+export interface GoalBlockReason {
+    /** Stable lower-kebab-case classification chosen by the blocking policy. */
+    readonly code: string;
+    /** Non-empty explanation shown to humans and models. */
+    readonly message: string;
+}
+/** Full durable state written by every non-clear goal mutation. */
+export interface GoalSnapshot extends GoalRef {
+    /** Human-requested completion objective. */
+    readonly objective: string;
+    /** Durable lifecycle phase. */
+    readonly phase: GoalPhase;
+    /** Present exactly while `phase` is `blocked`. */
+    readonly blockedReason?: GoalBlockReason;
+    /** Total admitted goal-round cap. */
+    readonly maxGoalRounds: number;
+}
+/** Whether this live process may automatically continue an active goal. */
+export type GoalActivation = 'armed' | 'disarmed';
+/** Current goal projection, including values derived from the session log. */
+export interface GoalView extends GoalSnapshot {
+    /** Highest admitted round number for this goal. */
+    readonly roundsStarted: number;
+    /** Epoch milliseconds of the create mutation. */
+    readonly createdAt: number;
+    /** Epoch milliseconds of the latest mutation. */
+    readonly updatedAt: number;
+    /** Process-local continuation eligibility; never persisted. */
+    readonly activation: GoalActivation;
+}
+/**
+ * The `goal` projection value: the current durable goal with its replay
+ * counters, exactly as the latest `goal/change` event carried them.
+ * Activation is process-local (never persisted) and deliberately absent —
+ * the projection reflects durable phase only.
+ */
+export interface GoalProjection {
+    /** Current durable goal snapshot (the CAS ref for mutations rides on it). */
+    readonly goal: GoalSnapshot;
+    /** Highest admitted round number for this goal. */
+    readonly roundsStarted: number;
+    /** Epoch milliseconds of the create mutation. */
+    readonly createdAt: number;
+    /** Epoch milliseconds of the latest mutation. */
+    readonly updatedAt: number;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionMap {
+        /**
+         * The session's current goal (the latest `goal/change` whole value), or
+         * `null` before the first create and after a clear tombstone.
+         * Whole-value rule: every goal change carries the complete post-change
+         * state, so the fold is last-wins.
+         */
+        goal: GoalProjection | null;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,13 @@
+/**
+ * Pure types of the goal domain: the ONE home of the `goal` projection-key
+ * declaration plus the durable payload vocabulary it carries, free of this
+ * package's host-side imports (cordis events, dsh-agent, dsh-llm, the
+ * service). Two namespace projections serve it — `./types` for host
+ * consumers, `./client` (the browser half-entry's re-export) for client
+ * aggregates — with zero content duplication. Host-coupled domain
+ * vocabulary (message sources, events, fold shapes) lives in ./domain.ts.
+ *
+ * @module @deepseek-ai/dsh-goal/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@deepseek-ai/dsh-goal",
+  "description": "Event-sourced same-session goal state and lifecycle service for the DeepSeek Harness",
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/goal/goal"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./client": {
+      "types": "./lib/types/client.d.ts",
+      "default": "./lib/types/client.js"
+    },
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts",
+    "lib/typert.host.js",
+    "lib/typert.host.d.ts",
+    "lib/typert.remote-client.js",
+    "lib/typert.remote-client.d.ts",
+    "lib/typert.remote-client.d.ts.map",
+    "src"
+  ],
+  "license": "BSD-3-Clause",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-session-projection": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-brand": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-scope": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-type-meta": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1"
+  },
+  "dependencies": {
+    "zod": "^4.4.3",
+    "@deepseek-ai/schemastery": "^3.18.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-session-projection": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-brand": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-type-meta": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-loader-smoke": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-scope": "^0.0.1-rc.1"
+  }
+}

package/src/client.ts

@@ -0,0 +1,10 @@
+/**
+ * Client-namespace projection of the goal domain: a pure re-export of the
+ * package's types outlet. Client code imports ONLY the client namespace
+ * (repo discipline), so `./client` projects the same single-source content
+ * `./types` serves to host consumers — zero duplication.
+ *
+ * @module @deepseek-ai/dsh-goal/client
+ */
+
+export type * from './types.ts'

package/src/domain.ts

@@ -0,0 +1,116 @@
+/**
+ * Host-side vocabulary of the goal domain: live views, durable change
+ * payloads, message attribution, replay folds, and the scoped `goal/changed`
+ * event. Kept separate from ./types.ts (the pure client-safe outlet) because
+ * these declarations pull dsh-agent, dsh-llm, and cordis into the program —
+ * the one-program-per-side layout forbids that on client aggregates.
+ * @module @deepseek-ai/dsh-goal
+ */
+
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { GoalId, GoalRef, GoalSnapshot, GoalView } from './types.ts'
+
+/** Goal state-changing verbs recorded in the durable source change. */
+export type GoalOperation =
+  | 'create'
+  | 'edit'
+  | 'pause'
+  | 'resume'
+  | 'complete'
+  | 'block'
+  | 'clear'
+
+/** Full-snapshot goal mutation committed by a durable `goal/change` event. */
+export interface GoalSnapshotChangeMeta {
+  readonly kind: 'goal/change'
+  readonly version: 1
+  readonly operation: Exclude<GoalOperation, 'clear'>
+  readonly goal: GoalSnapshot
+  readonly roundsStarted: number
+  readonly createdAt: number
+  readonly updatedAt: number
+}
+
+/** Tombstone retained when the current goal is cleared. */
+export interface GoalClearChangeMeta {
+  readonly kind: 'goal/change'
+  readonly version: 1
+  readonly operation: 'clear'
+  readonly cleared: GoalRef
+  readonly clearedAt: number
+}
+
+/** Durable change union carried by the goal domain's own session event. */
+export type GoalChangeMeta = GoalSnapshotChangeMeta | GoalClearChangeMeta
+
+/** Message attribution for admitted continuation rounds. */
+export interface GoalMessageSource {
+  readonly kind: 'goal'
+  readonly goalId: GoalId
+  readonly revision: number
+  /** Positive admitted continuation round. */
+  readonly round: number
+}
+
+declare module '@deepseek-ai/dsh-llm' {
+  interface MessageSourceMap {
+    goal: GoalMessageSource
+  }
+}
+
+declare module '@deepseek-ai/dsh-session/types' {
+  interface SessionEventMap {
+    /**
+     * Complete post-mutation goal state or clear tombstone.
+     */
+    'goal/change': GoalChangeMeta
+  }
+}
+
+/** Pure replay fold of durable goal facts. */
+export interface FoldedGoal {
+  /** Current goal, absent after a clear or before the first create. */
+  readonly goal?: GoalSnapshot
+  /** Highest admitted round for the current goal. */
+  readonly roundsStarted: number
+  /** Current goal creation time, absent without a current goal. */
+  readonly createdAt?: number
+  /** Current goal mutation time, absent without a current goal. */
+  readonly updatedAt?: number
+  /** Latest mutation ref, including a clear tombstone. */
+  readonly lastRef?: GoalRef
+}
+
+/** Live notification after one durable goal mutation commits. */
+export interface GoalChanged {
+  readonly operation: GoalOperation
+  readonly ref: GoalRef
+  /** Absent for a clear tombstone. */
+  readonly goal?: GoalView
+}
+
+/** Stable error codes for rejected goal reads and mutations. */
+export type GoalErrorCode =
+  | 'GOAL_AGENT_NOT_LIVE'
+  | 'GOAL_NOT_FOUND'
+  | 'GOAL_ALREADY_EXISTS'
+  | 'GOAL_STALE_REVISION'
+  | 'GOAL_INVALID_OBJECTIVE'
+  | 'GOAL_INVALID_MAX_ROUNDS'
+  | 'GOAL_INVALID_BLOCK_REASON'
+  | 'GOAL_INVALID_EDIT'
+  | 'GOAL_INVALID_TRANSITION'
+
+declare module '@deepseek-ai/cordis' {
+  interface Events {
+    /**
+     * Goal mutation accepted by one live agent. The matching `goal/change`
+     * session event has already committed. Listener failures are contained.
+     * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only that agent.
+     * @param payload.agent - agent whose session owns the goal.
+     * @param payload.change - fresh current projection or clear tombstone.
+     * @mode emit
+     */
+    'goal/changed'(this: import('@deepseek-ai/dsh-scope').Scoped<Agent>, payload: { agent: Agent; change: GoalChanged }): void
+  }
+}

package/src/fold.ts

@@ -0,0 +1,349 @@
+/** Pure replay fold and strict decoder for durable goal changes. */
+
+import type { MessageSource } from '@deepseek-ai/dsh-llm'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import { GOAL_CHANGE_VERSION, GoalId } from './runtime.ts'
+import type { GoalBlockReason, GoalPhase, GoalRef, GoalSnapshot } from './types.ts'
+import type {
+  FoldedGoal,
+  GoalChangeMeta,
+  GoalClearChangeMeta,
+  GoalMessageSource,
+  GoalOperation,
+  GoalSnapshotChangeMeta,
+} from './domain.ts'
+
+const SNAPSHOT_OPERATIONS: ReadonlySet<Exclude<GoalOperation, 'clear'>> = new Set([
+  'create',
+  'edit',
+  'pause',
+  'resume',
+  'complete',
+  'block',
+])
+const PHASES: ReadonlySet<GoalPhase> = new Set(['active', 'paused', 'blocked', 'complete'])
+
+/** Mutable accumulator kept private to the pure fold. */
+export interface GoalFoldState {
+  goal: GoalSnapshot | undefined
+  roundsStarted: number
+  createdAt: number | undefined
+  updatedAt: number | undefined
+  lastRef: GoalRef | undefined
+  seenGoalIds: Set<GoalSnapshot['id']>
+}
+
+/**
+ * Build an empty replay accumulator.
+ * @returns mutable state with no current goal or prior ref.
+ */
+export function emptyGoalFoldState(): GoalFoldState {
+  return {
+    goal: undefined,
+    roundsStarted: 0,
+    createdAt: undefined,
+    updatedAt: undefined,
+    lastRef: undefined,
+    seenGoalIds: new Set(),
+  }
+}
+
+/** Whether a value is a JSON record rather than an array. */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/** Require one positive safe integer. */
+function positiveInteger(value: unknown, field: string): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`goal change ${field} must be a positive safe integer`)
+  }
+  return value
+}
+
+/** Require one non-negative safe integer. */
+function nonNegativeInteger(value: unknown, field: string): number {
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`goal change ${field} must be a non-negative safe integer`)
+  }
+  return value
+}
+
+/** Decode one canonical blocker explanation. */
+function decodeBlockReason(value: unknown): GoalBlockReason {
+  if (!isRecord(value) || Object.keys(value).sort().join(',') !== 'code,message') {
+    throw new Error('goal change goal.blockedReason must have exactly code and message fields')
+  }
+  if (typeof value['code'] !== 'string' || !/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value['code'])) {
+    throw new Error('goal change goal.blockedReason.code must be lower-kebab-case')
+  }
+  if (typeof value['message'] !== 'string' || value['message'].trim().length === 0
+    || value['message'] !== value['message'].trim()) {
+    throw new Error('goal change goal.blockedReason.message must be non-empty and normalized')
+  }
+  return { code: value['code'], message: value['message'] }
+}
+
+/** Decode and validate one snapshot. */
+function decodeSnapshot(value: unknown): GoalSnapshot {
+  if (!isRecord(value)) throw new Error('goal change goal must be a record')
+  if (typeof value['id'] !== 'string' || value['id'].length === 0) {
+    throw new Error('goal change goal.id must be a non-empty string')
+  }
+  if (typeof value['objective'] !== 'string' || value['objective'].trim().length === 0
+    || value['objective'] !== value['objective'].trim()) {
+    throw new Error('goal change goal.objective must be non-empty and normalized')
+  }
+  if (typeof value['phase'] !== 'string' || !PHASES.has(value['phase'] as GoalPhase)) {
+    throw new Error('goal change goal.phase is invalid')
+  }
+  const phase = value['phase'] as GoalPhase
+  const expectedKeys = phase === 'blocked'
+    ? 'blockedReason,id,maxGoalRounds,objective,phase,revision'
+    : 'id,maxGoalRounds,objective,phase,revision'
+  if (Object.keys(value).sort().join(',') !== expectedKeys) {
+    throw new Error(`goal change goal for phase ${phase} must have exactly ${expectedKeys} fields`)
+  }
+  return {
+    id: GoalId(value['id']),
+    revision: positiveInteger(value['revision'], 'goal.revision'),
+    objective: value['objective'],
+    phase,
+    maxGoalRounds: positiveInteger(value['maxGoalRounds'], 'goal.maxGoalRounds'),
+    ...phase === 'blocked' ? { blockedReason: decodeBlockReason(value['blockedReason']) } : {},
+  }
+}
+
+/** Decode and validate one ref. */
+function decodeRef(value: unknown): GoalRef {
+  if (!isRecord(value) || Object.keys(value).sort().join(',') !== 'id,revision') {
+    throw new Error('goal clear tombstone must have exactly id and revision fields')
+  }
+  if (typeof value['id'] !== 'string' || value['id'].length === 0) {
+    throw new Error('goal clear tombstone id must be a non-empty string')
+  }
+  return { id: GoalId(value['id']), revision: positiveInteger(value['revision'], 'cleared.revision') }
+}
+
+/**
+ * Decode a value that declares itself as a goal change. Unrelated values
+ * return `undefined`; malformed goal changes fail replay loudly.
+ * @param value - candidate source change.
+ * @returns validated goal change or `undefined` for another value kind.
+ */
+export function decodeGoalChange(value: unknown): GoalChangeMeta | undefined {
+  if (!isRecord(value) || value['kind'] !== 'goal/change') return undefined
+  if (value['version'] !== GOAL_CHANGE_VERSION) {
+    throw new Error(`unsupported goal change version ${String(value['version'])}`)
+  }
+  if (value['operation'] === 'clear') {
+    const allowed = ['cleared', 'clearedAt', 'kind', 'operation', 'version']
+    if (Object.keys(value).sort().join(',') !== allowed.sort().join(',')) {
+      throw new Error(`goal clear change must have exactly ${allowed.sort().join(',')} fields`)
+    }
+    return {
+      kind: 'goal/change',
+      version: GOAL_CHANGE_VERSION,
+      operation: 'clear',
+      cleared: decodeRef(value['cleared']),
+      clearedAt: nonNegativeInteger(value['clearedAt'], 'clearedAt'),
+    } satisfies GoalClearChangeMeta
+  }
+  if (typeof value['operation'] !== 'string'
+    || !SNAPSHOT_OPERATIONS.has(value['operation'] as Exclude<GoalOperation, 'clear'>)) {
+    throw new Error('goal change operation is invalid')
+  }
+  const allowed = ['createdAt', 'goal', 'kind', 'operation', 'roundsStarted', 'updatedAt', 'version']
+  if (Object.keys(value).sort().join(',') !== allowed.sort().join(',')) {
+    throw new Error(`goal snapshot change must have exactly ${allowed.sort().join(',')} fields`)
+  }
+  const createdAt = nonNegativeInteger(value['createdAt'], 'createdAt')
+  const updatedAt = nonNegativeInteger(value['updatedAt'], 'updatedAt')
+  if (updatedAt < createdAt) throw new Error('goal change updatedAt cannot precede createdAt')
+  return {
+    kind: 'goal/change',
+    version: GOAL_CHANGE_VERSION,
+    operation: value['operation'] as Exclude<GoalOperation, 'clear'>,
+    goal: decodeSnapshot(value['goal']),
+    roundsStarted: nonNegativeInteger(value['roundsStarted'], 'roundsStarted'),
+    createdAt,
+    updatedAt,
+  } satisfies GoalSnapshotChangeMeta
+}
+
+/** Narrow model attribution to a valid goal source. */
+function goalSource(source: MessageSource): GoalMessageSource | undefined {
+  if (source.kind !== 'goal') return undefined
+  if (typeof source.goalId !== 'string' || source.goalId.length === 0
+    || !Number.isSafeInteger(source.revision) || source.revision < 1
+    || !Number.isSafeInteger(source.round) || source.round < 1) {
+    throw new Error('goal message source is invalid')
+  }
+  return source
+}
+
+/** Require two snapshots to retain fields that only `edit` may replace. */
+function requireSameDefinition(current: GoalSnapshot, next: GoalSnapshot, operation: GoalOperation): void {
+  if (next.objective !== current.objective || next.maxGoalRounds !== current.maxGoalRounds) {
+    throw new Error(`goal ${operation} cannot change objective or maxGoalRounds`)
+  }
+}
+
+/** Require one exact next revision of the current goal. */
+function requireNextRevision(current: GoalSnapshot, next: GoalRef, operation: GoalOperation): void {
+  if (next.id !== current.id || next.revision !== current.revision + 1) {
+    throw new Error(`goal ${operation} must advance the current goal by one revision`)
+  }
+}
+
+/** Validate one non-create snapshot operation against the preceding projection. */
+function validateSnapshotTransition(
+  state: GoalFoldState,
+  change: GoalSnapshotChangeMeta,
+  current: GoalSnapshot,
+): void {
+  const next = change.goal
+  requireNextRevision(current, next, change.operation)
+  /* v8 ignore next -- a current goal established by this fold always has an updatedAt */
+  if (state.updatedAt === undefined) throw new Error('current goal fold lacks updatedAt')
+  if (change.createdAt !== state.createdAt
+    || change.updatedAt < state.updatedAt
+    || change.roundsStarted !== state.roundsStarted) {
+    throw new Error(`goal ${change.operation} does not preserve the current counters and timestamps`)
+  }
+  switch (change.operation) {
+    case 'edit':
+      if (next.phase !== current.phase
+        || JSON.stringify(next.blockedReason) !== JSON.stringify(current.blockedReason)) {
+        throw new Error('goal edit cannot change phase or blocked reason')
+      }
+      break
+    case 'pause':
+      requireSameDefinition(current, next, change.operation)
+      if (current.phase !== 'active' || next.phase !== 'paused') throw new Error('goal pause has an invalid phase transition')
+      break
+    case 'resume': {
+      requireSameDefinition(current, next, change.operation)
+      const resumable: ReadonlySet<GoalPhase> = new Set([
+        'active',
+        'paused',
+        'blocked',
+      ])
+      if (!resumable.has(current.phase) || next.phase !== 'active' || state.roundsStarted >= next.maxGoalRounds) {
+        throw new Error('goal resume has an invalid phase transition or exhausted round budget')
+      }
+      break
+    }
+    case 'complete':
+      requireSameDefinition(current, next, change.operation)
+      if (current.phase === 'complete' || next.phase !== 'complete') throw new Error('goal complete has an invalid phase transition')
+      break
+    case 'block':
+      requireSameDefinition(current, next, change.operation)
+      if (current.phase !== 'active' || next.phase !== 'blocked') throw new Error('goal block has an invalid phase transition')
+      break
+    /* v8 ignore start -- the caller excludes create and GoalOperation is closed; these arms retain fail-loud exhaustiveness */
+    case 'create':
+      throw new Error('goal create cannot be validated as a current-goal transition')
+    default:
+      change.operation satisfies never
+      throw new Error('unknown goal snapshot operation')
+    /* v8 ignore stop */
+  }
+}
+
+/**
+ * Return the revision identity carried by a snapshot or tombstone.
+ * @param change - decoded goal mutation.
+ * @returns stable identity used to reconcile a deferred change with its log event.
+ */
+export function goalChangeRef(change: GoalChangeMeta): GoalRef {
+  return change.operation === 'clear'
+    ? change.cleared
+    : { id: change.goal.id, revision: change.goal.revision }
+}
+
+/**
+ * Validate and apply one decoded change to a mutable accumulator.
+ * @param state - preceding durable goal projection.
+ * @param change - decoded full snapshot or clear tombstone.
+ */
+export function applyGoalChange(state: GoalFoldState, change: GoalChangeMeta): void {
+  const ref = goalChangeRef(change)
+  if (change.operation === 'clear') {
+    const current = state.goal
+    if (current === undefined) throw new Error('goal clear requires a current goal')
+    requireNextRevision(current, change.cleared, change.operation)
+    /* v8 ignore next -- a current goal established by this fold always has an updatedAt */
+    if (state.updatedAt === undefined) throw new Error('current goal fold lacks updatedAt')
+    if (change.clearedAt < state.updatedAt) {
+      throw new Error('goal clear timestamp cannot precede the current goal update')
+    }
+    state.goal = undefined
+    state.roundsStarted = 0
+    state.createdAt = undefined
+    state.updatedAt = undefined
+    state.lastRef = ref
+    return
+  }
+  if (change.operation === 'create') {
+    if (change.goal.revision !== 1 || change.goal.phase !== 'active' || change.roundsStarted !== 0
+      || (state.goal !== undefined && state.goal.phase !== 'complete')
+      || state.seenGoalIds.has(change.goal.id)) {
+      throw new Error('goal create requires a fresh active revision-one goal with zero rounds')
+    }
+    state.seenGoalIds.add(change.goal.id)
+  } else {
+    const current = state.goal
+    if (current === undefined) throw new Error(`goal ${change.operation} requires a current goal`)
+    validateSnapshotTransition(state, change, current)
+  }
+  state.goal = change.goal
+  state.roundsStarted = change.roundsStarted
+  state.createdAt = change.createdAt
+  state.updatedAt = change.updatedAt
+  state.lastRef = ref
+}
+
+/**
+ * Apply one session event to the strict durable goal fold.
+ * @param state - mutable fold accumulator.
+ * @param event - next event in sequence order.
+ */
+export function applyGoalEvent(state: GoalFoldState, event: SessionEvent): void {
+  if (event.type === 'goal/change') {
+    const change = decodeGoalChange(event.data)
+    /* v8 ignore next -- the event's declared payload always identifies itself as a goal change. */
+    if (change === undefined) throw new Error(`goal change at session event ${event.seq} has an invalid kind`)
+    applyGoalChange(state, change)
+    return
+  }
+  if (event.type === 'user/message') {
+    const source = goalSource(event.data.source)
+    if (source === undefined) return
+    const current = state.goal
+    if (current === undefined || current.phase !== 'active' || source.goalId !== current.id
+      || source.revision !== current.revision || source.round !== state.roundsStarted + 1
+      || source.round > current.maxGoalRounds) {
+      throw new Error(`goal round at session event ${event.seq} is not the next admitted round of the active goal`)
+    }
+    state.roundsStarted = source.round
+  }
+}
+
+/**
+ * Fold current goal state from a contiguous session event log.
+ * @param events - session events in sequence order.
+ * @returns a fresh durable projection; activation is deliberately absent.
+ */
+export function foldGoal(events: readonly SessionEvent[]): FoldedGoal {
+  const state = emptyGoalFoldState()
+  for (const event of events) applyGoalEvent(state, event)
+  return {
+    ...state.goal === undefined ? {} : { goal: { ...state.goal } },
+    roundsStarted: state.roundsStarted,
+    ...state.createdAt === undefined ? {} : { createdAt: state.createdAt },
+    ...state.updatedAt === undefined ? {} : { updatedAt: state.updatedAt },
+    ...state.lastRef === undefined ? {} : { lastRef: { ...state.lastRef } },
+  }
+}