@hypit/hypit 0.1.4 → 0.1.5

package/packages/sound/src/style.ts

@@ -0,0 +1,34 @@
+import { sealGraphFragment } from "@hypit/elaborator";
+import type { GraphFragment } from "@hypit/elaborator";
+import { compositionTypes } from "@hypit/composition";
+import { timelineTypes } from "@hypit/timeline";
+import { temporalTypes } from "@hypit/temporal";
+import { sameType } from "@hypit/protocol";
+import type { SurfaceResolvedReference } from "@hypit/markup";
+
+/** Author-time closure: bound references become ordinary graph edges at each Use. */
+export type SoundStyle = {
+  readonly fragment: GraphFragment;
+  readonly bindings: Readonly<Record<string, { readonly type: SurfaceResolvedReference["type"]; readonly ref: SurfaceResolvedReference["ref"] }>>;
+};
+export function soundStyle(fragment: GraphFragment, bindings: SoundStyle["bindings"] = {}): SoundStyle {
+  fragment = sealGraphFragment(fragment);
+  const common = { timeline: timelineTypes.track, window: temporalTypes.window };
+  for (const [name, type] of Object.entries(common)) {
+    const port = fragment.inputs.find(port => port.name === name);
+    if (port === undefined || !sameType(port.type, type)) throw new Error(`Sound Style requires ${name} input.`);
+    if (bindings[name] !== undefined) throw new Error(`Sound supplies ${name} at each Use.`);
+  }
+  for (const port of fragment.inputs) {
+    if (port.name in common) continue;
+    const binding = bindings[port.name];
+    if (binding === undefined || !sameType(port.type, binding.type)) throw new Error(`Sound Style binding ${port.name} has the wrong Type.`);
+  }
+  for (const name of Object.keys(bindings)) {
+    if (!fragment.inputs.some(port => port.name === name)) throw new Error(`Sound Style has unknown binding ${name}.`);
+  }
+  if (fragment.exports.length !== 1 || fragment.exports[0]?.name !== "audio" || !sameType(fragment.exports[0].type, compositionTypes.audioTrack)) {
+    throw new Error("Sound Style must export audio: AudioTrack.");
+  }
+  return { fragment, bindings: Object.fromEntries(Object.entries(bindings).map(([name, value]) => [name, { ref: value.ref, type: value.type }])) };
+}

package/packages/sound/src/surface.ts

@@ -0,0 +1,90 @@
+import { assertAttributes, assertEmptyElement, textAttribute, optionalTextAttribute } from "@hypit/markup";
+import type { StructuredSurfaceHandler, SurfaceResolvedReference, SurfaceRecordDraft, SurfaceComponentDraft, StructuredElement } from "@hypit/markup";
+import { canonicalize, sameType } from "@hypit/protocol";
+import type { TypeRef } from "@hypit/protocol";
+import { sealGraphFragment } from "@hypit/elaborator";
+import type { FragmentOperation } from "@hypit/elaborator";
+import { createTemporalWindowProjection, resolveTemporalContext, temporalWindowAttributeNames } from "@hypit/temporal-markup";
+import { temporalTypes } from "@hypit/temporal";
+import { compositionTypes } from "@hypit/composition";
+import { timelineTypes } from "@hypit/timeline";
+import { soundStyle } from "./style.js";
+import type { SoundStyle } from "./style.js";
+import { soundTypes, soundProducers, ordinaryInputs } from "./manifest.js";
+
+const input = (name: string) => ({ kind: "fragment-input" as const, name });
+const operation = (id: string) => ({ kind: "fragment-operation" as const, operation: id });
+function reference(element: StructuredElement, name: string, type: TypeRef, resolve: (path: string) => SurfaceResolvedReference | undefined): SurfaceResolvedReference {
+  const raw = element.attributes[name];
+  if (typeof raw !== "object" || raw.kind !== "reference") throw new Error(`${element.name}.${name} must be a reference.`);
+  const found = resolve(raw.path);
+  if (found === undefined || !sameType(found.type, type)) throw new Error(`${element.name}.${name} has the wrong Type.`);
+  return found;
+}
+function authored<T>(value: SurfaceResolvedReference): T {
+  if (value.record?.value.kind !== "inline") throw new Error("A presentation Style or Recipe must be an authored inline value.");
+  return value.record.value.value as unknown as T;
+}
+export const decodeSoundTrackSurface: StructuredSurfaceHandler = ({ element, resolveReference }) => {
+  assertAttributes(element, ["id", "timeline"]);
+  const id = textAttribute(element, "id"), context = resolveTemporalContext({ element, resolveReference });
+  const records: SurfaceRecordDraft[] = [{ id: `${id}.header`, type: soundTypes.header, value: { kind: "inline", value: { id } }, range: element.range }];
+  const components: SurfaceComponentDraft[] = [];
+  const fragments = [] as ReturnType<typeof sealGraphFragment>[];
+  const collectorInputs = [{ name: "timeline", type: timelineTypes.track }, { name: "header", type: soundTypes.header }];
+  const bindings: Record<string, SurfaceResolvedReference["ref"]> = { timeline: context.timeline.ref, header: { kind: "record", id: `${id}.header` } };
+  const operations: FragmentOperation[] = [{ id: "empty", producer: soundProducers.create, inputs: {}, result: { kind: "output", name: "set" } }];
+  let previous = "empty", index = 0;
+  for (const child of element.children) {
+    if (child.kind === "text") { if (child.value.trim()) throw new Error("Sound Track accepts Use children."); continue; }
+    if (child.name.split(":").at(-1) !== "Use") throw new Error("Sound Track accepts Use children.");
+    assertAttributes(child, ["id", "style", ...temporalWindowAttributeNames]); assertEmptyElement(child);
+    const useId = optionalTextAttribute(child, "id") ?? `${id}.use.${index + 1}`;
+    index += 1;
+    const hasTime = temporalWindowAttributeNames.some(name => child.attributes[name] !== undefined);
+    const temporal = createTemporalWindowProjection({ id: useId, ...context, resolveReference,
+      element: hasTime ? child : { ...child, attributes: { ...child.attributes, during: "program" } } });
+    records.push(...temporal.records); components.push(...temporal.components); fragments.push(...temporal.fragments);
+    const value = authored<SoundStyle>(reference(child, "style", soundTypes.style, resolveReference));
+    const style = soundStyle(value.fragment, value.bindings);
+    fragments.push(style.fragment);
+    const audioId = `${useId}.audio`;
+    components.push({ id: `${useId}.__style`, fragment: style.fragment.id,
+      inputs: { ...Object.fromEntries(Object.entries(style.bindings).map(([key, bound]) => [key, bound.ref])),
+        timeline: context.timeline.ref, window: temporal.ref }, outputs: { audio: audioId }, range: child.range });
+    const suffix = `use-${operations.length}`;
+    collectorInputs.push({ name: `${suffix}-window`, type: temporalTypes.window }, { name: `${suffix}-audio`, type: compositionTypes.audioTrack });
+    bindings[`${suffix}-window`] = temporal.ref; bindings[`${suffix}-audio`] = { kind: "component-output", component: `${useId}.__style`, output: "audio" };
+    operations.push({ id: suffix, producer: soundProducers.append, inputs: { set: operation(previous), window: input(`${suffix}-window`), audio: input(`${suffix}-audio`) }, result: { kind: "output", name: "set" } });
+    previous = suffix;
+  }
+  operations.push({ id: "resolve", producer: soundProducers.resolve, inputs: { set: operation(previous), timeline: input("timeline"), header: input("header") }, result: { kind: "output", name: "audio" } });
+  const collector = sealGraphFragment({ inputs: collectorInputs, operations, exports: [{ name: "audio", type: compositionTypes.audioTrack, root: operation("resolve") }, { name: "program", type: soundTypes.set, root: operation(previous) }] });
+  fragments.push(collector);
+  components.push({ id, fragment: collector.id, inputs: bindings, outputs: { audio: `${id}.audio`, program: `${id}.program` }, range: element.range });
+  return { records, components, fragments, exports: [`${id}.audio`, `${id}.program`] };
+};
+
+export const ordinarySoundFragment = sealGraphFragment({
+  inputs: ordinaryInputs,
+  operations: [{ id: "ordinary", producer: soundProducers.ordinary,
+    inputs: Object.fromEntries(ordinaryInputs.map(port => [port.name, input(port.name)])), result: { kind: "output", name: "audio" } }],
+  exports: [{ name: "audio", type: compositionTypes.audioTrack, root: operation("ordinary") }],
+});
+export const decodeSoundStyleSurface: StructuredSurfaceHandler = ({ element }) => {
+  assertAttributes(element, ["id", "gain", "end-gain"]); assertEmptyElement(element);
+  const id = textAttribute(element, "id");
+  const number = (name: string, fallback: number): number => {
+    const raw = optionalTextAttribute(element, name);
+    const value = raw === undefined ? fallback : raw.trim() === "" ? NaN : Number(raw);
+    if (!Number.isFinite(value) || value < 0 || value > 64) throw new Error(`Sound Style ${name} must be a gain from 0 to 64.`);
+    return value;
+  };
+  const gain = number("gain", 1), endGain = number("end-gain", gain);
+  const specId = `${id}.gain`;
+  const style = soundStyle(ordinarySoundFragment, { spec: { ref: { kind: "record", id: specId }, type: soundTypes.gain } });
+  return { records: [
+    { id: specId, type: soundTypes.gain, value: { kind: "inline", value: { gain, endGain } }, range: element.range },
+    { id, type: soundTypes.style, value: { kind: "inline", value: canonicalize(style) }, range: element.range },
+  ], components: [], fragments: [] };
+};

package/packages/sound-studio/README.md

@@ -0,0 +1,22 @@
+# Sound Studio Companion
+
+Sound contributes one Track with content and a bottom Uses band through the public Companion interface:
+
+- The content lane shows placed audio Takes with waveforms. Each Take retains its actual interval, including gaps and overlaps. Picture-only Takes contribute no sound item.
+- The Uses label band shows each authored Style application. Later declarations appear over earlier ones; selection raises an item for editing without changing that priority. Silent and fully covered Uses remain selectable.
+
+One Sound label spans the waveform content and Uses band. Selecting a Take shows its Segment and placed frame range.
+Selecting a Use shows its Style and resolved frame range, alongside the ordinary Style's authored
+`gain` and `end-gain` parameters. Gain is displayed as a percentage: 100% writes the linear value 1.
+The end gain defaults to the start gain. The parameter Companion exposes this dependent default;
+the first edit inserts an explicit attribute into the Style.
+
+The fields live in When and How. Shared Style edits affect all Uses selecting that Style.
+Temporal gestures follow the existing Selection/Moment/clock projection and exact source endpoint
+rules. Project Styles expose their own parameters through `createStudioCompanionHostFacet({ parameters })`,
+matching their own Module and Surface. The Track opts `style` into this owner with `companion: true`.
+
+`Sound Track.program` exports the already-computed ordered Use set before presentation coverage
+is resolved. `Sound Track.audio` exports the effective audio arrangement. The Companion reads the
+former to preserve editing choices even when they currently produce no sound; rendering consumes
+the latter. Studio does not reconstruct the rule set from audible output or inspect Sound internals.

package/packages/sound-studio/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@hypit/sound-studio",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "hypit": {
+    "activation": "./src/activation.ts"
+  },
+  "dependencies": {
+    "@hypit/timeline": "workspace:*",
+    "@hypit/temporal": "workspace:*",
+    "@hypit/composition": "workspace:*",
+    "@hypit/studio-adapter": "workspace:*",
+    "@hypit/sound": "workspace:*"
+  }
+}

package/packages/sound-studio/src/activation.ts

@@ -0,0 +1,6 @@
+import { createStudioCompanionHostFacet } from "@hypit/studio-adapter";
+import { soundStudioTrackCompanions, soundStudioParameterCompanions } from "./index.js";
+export default {
+  format: "hypit.node-package@1" as const,
+  hostFacets: [createStudioCompanionHostFacet({ tracks: soundStudioTrackCompanions, parameters: soundStudioParameterCompanions })],
+};

package/packages/sound-studio/src/index.ts

@@ -0,0 +1,74 @@
+import { soundModuleRef } from "@hypit/sound";
+import type { SoundSet } from "@hypit/sound";
+import { projectTimelineMedia, timelineTypes } from "@hypit/timeline";
+import type { Timeline } from "@hypit/timeline";
+import { temporalTypes } from "@hypit/temporal";
+import { compositionTypes } from "@hypit/composition";
+import { artifactPreview, authoredChildFor, previewLayer, requiredReferencedValue, requiredSurfaceValue, temporalLineageFor, temporalSemanticSource } from "@hypit/studio-adapter";
+import type { StudioTrackCompanion, StudioTrackCompanionContext, StudioEntityDraft } from "@hypit/studio-adapter";
+
+export function projectSound(context: StudioTrackCompanionContext): readonly StudioEntityDraft[] {
+  const timeline = requiredReferencedValue(context, "timeline", timelineTypes.track) as Timeline;
+  const program = requiredSurfaceValue(context, "program") as SoundSet;
+  // Source content keeps its own placement. A Use changes its presentation, not its media clock.
+  const content: StudioEntityDraft[] = projectTimelineMedia(timeline).flatMap((clip, index) => {
+    if (clip.media.audio === undefined) return [];
+    return [{
+      id: `${context.track.outputRef}:content:${clip.segmentId}`,
+      authoredId: clip.segmentId,
+      display: { title: clip.segmentId, layers: [previewLayer(artifactPreview("audio", clip.media.audio.artifact.resource), "waveform")] },
+      ...clip.span, stackOrder: index,
+      inspector: [
+        { id: "segment", label: "Segment", domain: "how", section: { id: "content", label: "Content" }, value: clip.segmentId },
+        { id: "range", label: "Range", domain: "when", section: { id: "placement", label: "Placement" }, value: `${clip.span.startFrame}–${clip.span.endFrameExclusive}`, unit: "f", summary: "Placed interval; the end frame is exclusive." },
+      ],
+      presentation: { entity: "sound-content", chrome: "standard" },
+    }];
+  });
+  const uses: StudioEntityDraft[] = program.uses.map((use, index) => {
+    const authoredId = use.window.subjectId;
+    const child = authoredChildFor(context, authoredId, [temporalTypes.windowSpec]);
+    if (child === undefined) throw new Error(`Sound Use ${authoredId} has no author provenance.`);
+    const style = child.referenceAttributes.style;
+    const temporal = temporalLineageFor(context, authoredId, "window");
+    const semantic = temporalSemanticSource(temporal);
+    return {
+      id: `${context.track.outputRef}:use:${authoredId}`, authoredId,
+      display: { title: style ?? authoredId, layers: [] },
+      ...use.window.span, stackOrder: index,
+      elementRange: child.range,
+      ...(temporal === undefined ? {} : { temporal }),
+      ...(semantic === undefined ? {} : { markerId: semantic.id }),
+      presentation: { entity: "sound-use", chrome: "standard" },
+      band: "uses",
+      inspector: [{ id: "range", label: "Range", domain: "when", section: { id: "placement", label: "Placement" }, value: `${use.window.span.startFrame}–${use.window.span.endFrameExclusive}`, unit: "f", summary: "Resolved Use interval; the end frame is exclusive. Timeline gestures follow this Use's author timing." }],
+    };
+  });
+  return [...content, ...uses];
+}
+
+export const soundStudioTrackCompanions: readonly StudioTrackCompanion[] = [{
+  id: "audio", role: "track",
+  output: { type: compositionTypes.audioTrack, surface: "track", modules: [soundModuleRef] },
+  family: "sound", label: "Sound", tone: "green", icon: "waveform",
+  lane: { heightPx: 48 },
+  requiredValues: ["program"],
+  bands: [{
+    id: "uses", placement: "after", heightPx: 15, display: "label",
+    bindings: [{ name: "style", companion: true }],
+    inspector: [{ binding: "style", label: "Style", domain: "how", section: { id: "sound", label: "Sound" }, control: "text", summary: "This Style is shared by every Use that selects it." }],
+  }],
+  project: projectSound,
+}];
+
+export const soundStudioParameterCompanions: readonly import("@hypit/studio-adapter").StudioParameterCompanion[] = [{
+  id: "style", match: { module: soundModuleRef, surface: "style" },
+  bindings: [ { name: "gain", writable: true, fallback: 1 },
+    { name: "end-gain", writable: true, fallback: authored => Number(authored.gain ?? 1) } ],
+  inspector: (["gain", "end-gain"] as const).map(name => ({
+    binding: name, label: name === "gain" ? "Gain" : "End Gain", domain: "how",
+    section: { id: "sound", label: "Sound" }, control: "number", unit: "%",
+    number: { scale: 100, minimum: 0, maximum: 6400, step: 1 },
+    summary: name === "gain" ? "Linear gain at the start of each Use. 100% preserves the source level." : "Linear gain at the end of each Use. The Use interval owns the ramp.",
+  })),
+}];

package/packages/speech/README.md

@@ -6,8 +6,8 @@ owns the types and helpers below; Source imports retain the `@hypit/speech@1` Mo
 
 Public contracts for speech duration, normalized semantic Takes and provider-neutral evidence audio.
 A `SemanticTake` contains one normalized media product, one authored Segment, its words and local
-frame anchors. Ordered Takes are assembled by `@hypit/speech-track` into a `SemanticTrack`, which is
-the program's continuous semantic skeleton. `SpeechEvidenceAudio` carries canonical 16 kHz WAV bytes
+frame anchors. Ordered Takes are assembled by `@hypit/timeline-author` into a `Timeline`, which is
+the complete Program range and Take placements, including gaps or overlap. `SpeechEvidenceAudio` carries canonical 16 kHz WAV bytes
 and their exact sample count; it never carries Script or Segment identity.
 
 The package also owns deterministic boundary materialization for a Segment with no Tokens. It maps

package/packages/speech-alignment/src/local.ts

@@ -16,8 +16,16 @@ function segmentNarrative(narrative: Narrative, excerpt: NarrativeExcerpt): Narr
     throw new Error(`NarrativeExcerpt ${excerpt.id} does not describe its authored Segment.`);
   }
   const tokens = narrative.tokens.slice(segment.tokenStart, segment.tokenEndExclusive);
+  const units = narrative.caption.units.filter((unit) => unit.segmentId === segment.id);
+  const unitIds = new Set(units.map((unit) => unit.id));
   return {
     id: narrative.id,
+    caption: {
+      ...narrative.caption,
+      units,
+      words: narrative.caption.words.filter((word) => unitIds.has(word.unitId)),
+      cueBreaks: narrative.caption.cueBreaks.filter((cue) => unitIds.has(cue.afterUnitId)),
+    },
     segments: [{ ...segment, tokenStart: 0, tokenEndExclusive: tokens.length }],
     tokens,
     turns: narrative.turns

package/packages/speech-alignment/src/locate.ts

@@ -456,7 +456,7 @@ export function locateAlignedSegmentTiming(
   const tokensById = new Map(timedTokens.map((token) => [token.tokenId, token]));
   const segmentsById = new Map(timedSegments.map((segment) => [segment.segmentId, segment]));
   const anchors: LocalSemanticTimePoint[] = narrative.semanticIndex.anchors.flatMap((anchor): LocalSemanticTimePoint[] => {
-    // Program boundaries belong to the assembled SemanticTrack, never to one Segment-local Take.
+    // Program boundaries belong to the assembled Timeline, never to one Segment-local Take.
     if (anchor.kind === "program-start" || anchor.kind === "program-end") return [];
     if (anchor.kind === "segment-start" || anchor.kind === "segment-end") {
       const segment = segmentsById.get(anchor.segmentId)!;

package/packages/store-sqlite/README.md

@@ -12,3 +12,10 @@ has recorded them. Unknown remote outcomes do not keep a failed Build active.
 Artifact bytes and secret credential values never enter this database. Components and Endpoint packages do not import
 SQLite. `SqliteRuntimeState` exposes the narrow stores needed by the local Runtime and owns their shared
 connection.
+
+Execution choices live in `context_json` on the existing submission/execution records. The store treats
+that value as opaque Host data. `started_at` distinguishes queued work from an executor that was lost.
+`listUnstarted` and `listReady` return only IDs for dispatch, without parsing every Profile or graph.
+Scoped claims and shared capacity updates remain atomic across execution contexts and processes. No global Profile
+pin prevents a new Build from using new selections. An interrupted executor is concluded only after
+its supervisor knows the process has exited; stored Operation receipts are retained for Result writing.

package/packages/store-sqlite/src/store.ts

@@ -35,7 +35,6 @@ import type {
   OperationSnapshot,
   OperationStore,
   OperationUpdate,
-  RuntimeEnvironmentStore,
 } from "@hypit/runtime";
 
 export type SqliteRuntimeStateOptions = {
@@ -224,6 +223,7 @@ function parseExecutionRequest(row: Row, subject: string): BuildExecutionRequest
     `SQLite ${subject} Result location is invalid`);
   return {
     build: row.build_id,
+    ...(typeof row.context_json === "string" ? { context: JSON.parse(row.context_json) as NonNullable<BuildExecutionRequest["context"]> } : {}),
     componentPackages,
     result: result as BuildExecutionRequest["result"],
   };
@@ -263,12 +263,13 @@ class SqlitePendingBuildStore implements PendingBuildStore {
       assert(occupied === undefined, `Build ${request.build} already has Runtime state`);
       this.#database.prepare(`
         INSERT INTO hypit_submissions (
-          build_id, component_packages_json, result_location_json, created_at
-        ) VALUES (?, ?, ?, ?)
+          build_id, component_packages_json, result_location_json, context_json, created_at
+        ) VALUES (?, ?, ?, ?, ?)
       `).run(
         request.build,
         JSON.stringify(request.componentPackages),
         JSON.stringify(request.result),
+        request.context === undefined ? null : JSON.stringify(request.context),
         now,
       );
       return parsePendingBuildSubmission(
@@ -295,7 +296,8 @@ class SqlitePendingBuildStore implements PendingBuildStore {
       if (row === undefined) throw new Error(`Build submission ${request.build} was not prepared`);
       const submission = parsePendingBuildSubmission(row);
       assert(JSON.stringify(submission.componentPackages) === JSON.stringify(request.componentPackages)
-        && JSON.stringify(submission.result) === JSON.stringify(request.result),
+        && JSON.stringify(submission.result) === JSON.stringify(request.result)
+        && JSON.stringify(submission.context) === JSON.stringify(request.context),
       `Build submission ${request.build} does not match its prepared state`);
       this.#database.prepare(`
         INSERT INTO hypit_builds (build_id, definition_json) VALUES (?, ?)
@@ -305,15 +307,16 @@ class SqlitePendingBuildStore implements PendingBuildStore {
       `).run(request.build, Date.now(), JSON.stringify(request.catalog));
       this.#database.prepare(`
         INSERT INTO hypit_executions (
-          build_id, component_packages_json, result_location_json, created_at, wake_at,
+          build_id, component_packages_json, result_location_json, context_json, created_at, wake_at,
           turn_owner, turn_acquired_at, result_writer_owner, result_writer_acquired_at,
           stop_cause, stop_reason,
           decision_outcome, decision_reason, attention_step, attention_error
-        ) VALUES (?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
+        ) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
       `).run(
         request.build,
         JSON.stringify(request.componentPackages),
         JSON.stringify(request.result),
+        request.context === undefined ? null : JSON.stringify(request.context),
         submission.createdAt,
         Date.now(),
       );
@@ -424,6 +427,9 @@ function parseCommandExecution(row: Row): CommandExecutionReceipt {
     command: row.command_id,
     status: row.status,
     ...(event === undefined ? {} : { event }),
+    ...(row.status !== "started" || typeof row.activity_json !== "string" ? {} : {
+      activity: JSON.parse(row.activity_json) as NonNullable<CommandExecutionReceipt["activity"]>,
+    }),
   };
 }
 
@@ -456,7 +462,7 @@ class SqliteCommandExecutionStore implements CommandExecutionStore {
       const current = parseCommandExecution(row);
       if (current.status === "completed") return current;
       this.#database.prepare(`
-        UPDATE hypit_command_executions SET status = 'completed', event_json = ?
+        UPDATE hypit_command_executions SET status = 'completed', event_json = ?, activity_json = NULL
         WHERE build_id = ? AND command_id = ? AND status = 'started'
       `).run(JSON.stringify(event), build, command);
       return parseCommandExecution(this.#database.prepare(`
@@ -471,54 +477,18 @@ class SqliteCommandExecutionStore implements CommandExecutionStore {
     `).all(build) as Row[]).map(parseCommandExecution);
   }
 
-  async removeBuild(build: string): Promise<void> {
-    this.#database.prepare("DELETE FROM hypit_command_executions WHERE build_id = ?").run(build);
-  }
-}
-
-class SqliteRuntimeEnvironmentStore implements RuntimeEnvironmentStore {
-  readonly #database: DatabaseSync;
-
-  constructor(database: DatabaseSync) {
-    this.#database = database;
-  }
-
-  async use(config: string): Promise<void> {
-    assert(config.length > 0, "Runtime environment configuration is empty");
-    transaction(this.#database, () => {
-      const active = this.#database.prepare(
-        `SELECT
-          (SELECT COUNT(*) FROM hypit_submissions)
-          + (SELECT COUNT(*) FROM hypit_executions) AS count`,
-      ).get() as Row;
-      assert(typeof active.count === "number", "SQLite active Runtime work count is invalid");
-      const row = this.#database.prepare(
-        "SELECT config_json FROM hypit_runtime_environment WHERE singleton = 1",
-      ).get() as Row | undefined;
-      if (active.count > 0) {
-        assert(typeof row?.config_json === "string",
-          "Active Runtime work has no recorded environment; use its original Profile or resolve it explicitly");
-        assert(row.config_json === config,
-          "Runtime Profile differs from the environment pinned by active Builds");
-        return;
-      }
-      this.#database.prepare(`
-        INSERT INTO hypit_runtime_environment (singleton, config_json) VALUES (1, ?)
-        ON CONFLICT(singleton) DO UPDATE SET config_json = excluded.config_json
-      `).run(config);
-    });
+  async reportProgress(build: string, command: string, activity: NonNullable<CommandExecutionReceipt["activity"]>): Promise<void> {
+    this.#database.prepare(`
+      UPDATE hypit_command_executions SET activity_json = ?
+      WHERE build_id = ? AND command_id = ? AND status = 'started'
+    `).run(JSON.stringify(activity), build, command);
   }
 
-  async assert(config: string): Promise<void> {
-    const row = this.#database.prepare(
-      "SELECT config_json FROM hypit_runtime_environment WHERE singleton = 1",
-    ).get() as Row | undefined;
-    assert(typeof row?.config_json === "string" && row.config_json === config,
-      "Runtime Profile no longer matches this Worker's active environment");
+  async removeBuild(build: string): Promise<void> {
+    this.#database.prepare("DELETE FROM hypit_command_executions WHERE build_id = ?").run(build);
   }
 }
 
-
 function parseExecutionSnapshot(row: Row): BuildExecutionSnapshot {
   assert(typeof row.created_at === "number", "SQLite Execution creation time is invalid");
   assert(row.wake_at === null || typeof row.wake_at === "number", "SQLite Execution wake time is invalid");
@@ -538,6 +508,7 @@ function parseExecutionSnapshot(row: Row): BuildExecutionSnapshot {
   return {
     ...parseExecutionRequest(row, "Execution"),
     createdAt: row.created_at,
+    ...(typeof row.started_at === "number" ? { startedAt: row.started_at } : {}),
     ...(typeof row.wake_at === "number" ? { wakeAt: row.wake_at } : {}),
     ...(typeof row.operation_wait_json === "string" ? { operationWait: JSON.parse(row.operation_wait_json) as string[] } : {}),
     ...(typeof row.turn_owner === "string" ? {
@@ -582,12 +553,12 @@ class SqliteBuildExecutionStore implements BuildExecutionStore {
     nonNegativeInteger(now, "Execution creation time");
     this.#database.prepare(`
       INSERT INTO hypit_executions (
-        build_id, component_packages_json, result_location_json, created_at, wake_at,
+        build_id, component_packages_json, result_location_json, context_json, created_at, wake_at,
         turn_owner, turn_acquired_at, result_writer_owner, result_writer_acquired_at,
         stop_cause, stop_reason,
         decision_outcome, decision_reason, attention_step, attention_error
-      ) VALUES (?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
-    `).run(request.build, JSON.stringify(request.componentPackages), JSON.stringify(request.result), now, now);
+      ) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
+    `).run(request.build, JSON.stringify(request.componentPackages), JSON.stringify(request.result), request.context === undefined ? null : JSON.stringify(request.context), now, now);
     return {
       ...copy(request),
       createdAt: now,
@@ -608,19 +579,20 @@ class SqliteBuildExecutionStore implements BuildExecutionStore {
     return rows.map(parseExecutionSnapshot);
   }
 
-  async claim(owner: string, now = Date.now()): Promise<BuildExecutionSnapshot | undefined> {
+  async claim(owner: string, now = Date.now(), build?: string): Promise<BuildExecutionSnapshot | undefined> {
     assert(owner.trim().length > 0, "Execution turn owner is empty");
     nonNegativeInteger(now, "Execution claim time");
     return transaction(this.#database, () => {
       const row = this.#database.prepare(`
         SELECT execution.build_id FROM hypit_executions AS execution
         WHERE decision_outcome IS NULL AND turn_owner IS NULL AND wake_at <= ?
+          AND (? IS NULL OR execution.build_id = ?)
         ORDER BY EXISTS (
           SELECT 1 FROM hypit_capacity AS capacity
           WHERE capacity.build_id = execution.build_id
         ) DESC, wake_at ASC, created_at ASC, execution.build_id ASC
         LIMIT 1
-      `).get(now) as Row | undefined;
+      `).get(now, build ?? null, build ?? null) as Row | undefined;
       if (row === undefined) return undefined;
       assert(typeof row.build_id === "string", "SQLite ready Execution has no Build id");
       const updated = this.#database.prepare(`
@@ -635,6 +607,45 @@ class SqliteBuildExecutionStore implements BuildExecutionStore {
     });
   }
 
+  async listUnstarted(): Promise<readonly string[]> {
+    return (this.#database.prepare(`SELECT build_id FROM hypit_executions
+      WHERE decision_outcome IS NULL AND started_at IS NULL ORDER BY created_at, build_id`).all() as Row[])
+      .map((row) => row.build_id as string);
+  }
+
+  async listReady(now = Date.now()): Promise<readonly string[]> {
+    return (this.#database.prepare(`SELECT build_id FROM hypit_executions
+      WHERE decision_outcome IS NULL AND turn_owner IS NULL AND wake_at <= ?
+      ORDER BY wake_at, created_at, build_id`).all(now) as Row[]).map((row) => row.build_id as string);
+  }
+
+  async start(build: string, now = Date.now()): Promise<BuildExecutionSnapshot> {
+    nonNegativeInteger(now, "Execution start time");
+    const updated = this.#database.prepare(`
+      UPDATE hypit_executions SET started_at = ?
+      WHERE build_id = ? AND started_at IS NULL AND decision_outcome IS NULL
+    `).run(now, build);
+    assert(updated.changes === 1, `Execution ${build} has already started or ended`);
+    return (await this.read(build))!;
+  }
+
+  async interrupt(build: string, reason: string): Promise<BuildExecutionSnapshot> {
+    return transaction(this.#database, () => {
+      const row = this.#database.prepare("SELECT * FROM hypit_executions WHERE build_id = ?").get(build) as Row | undefined;
+      assert(row !== undefined, `Execution ${build} does not exist`);
+      const current = parseExecutionSnapshot(row);
+      if (current.decision !== undefined) return current;
+      this.#release(build);
+      this.#database.prepare(`
+        UPDATE hypit_executions SET decision_outcome = ?, decision_reason = ?,
+          turn_owner = NULL, turn_acquired_at = NULL,
+          result_writer_owner = NULL, result_writer_acquired_at = NULL
+        WHERE build_id = ?
+      `).run(current.stop?.cause === "user-cancelled" ? "cancelled" : "failed", current.stop?.reason ?? reason, build);
+      return parseExecutionSnapshot(this.#database.prepare("SELECT * FROM hypit_executions WHERE build_id = ?").get(build) as Row);
+    });
+  }
+
   async releaseTurn(build: string, owner: string, wakeAt: number | undefined, operationWait?: readonly string[]): Promise<BuildExecutionSnapshot> {
     if (wakeAt !== undefined) nonNegativeInteger(wakeAt, "Execution wakeAt");
     return transaction(this.#database, () => {
@@ -902,28 +913,6 @@ class SqliteBuildExecutionStore implements BuildExecutionStore {
     transaction(this.#database, () => this.#release(build));
   }
 
-  async reclaimTurns(now = Date.now()): Promise<readonly string[]> {
-    nonNegativeInteger(now, "Execution turn reclaim time");
-    return transaction(this.#database, () => {
-      const rows = this.#database.prepare(
-        "SELECT build_id FROM hypit_executions WHERE turn_owner IS NOT NULL AND decision_outcome IS NULL",
-      ).all() as Row[];
-      const builds = rows.map((row) => {
-        assert(typeof row.build_id === "string", "SQLite owned Execution has no Build id");
-        return row.build_id;
-      });
-      for (const row of rows) {
-        assert(typeof row.build_id === "string", "SQLite active Execution is invalid");
-        this.#database.prepare(`
-          UPDATE hypit_executions
-          SET turn_owner = NULL, turn_acquired_at = NULL, wake_at = ?
-          WHERE build_id = ? AND decision_outcome IS NULL
-        `).run(now, row.build_id);
-      }
-      return builds;
-    });
-  }
-
   async listCapacity(): Promise<readonly CapacityReservation[]> {
     return (this.#database.prepare(
       "SELECT * FROM hypit_capacity ORDER BY created_at ASC, build_id ASC, command_id ASC",
@@ -961,7 +950,6 @@ export class SqliteRuntimeState {
   readonly commandExecutions: CommandExecutionStore;
   readonly execution: BuildExecutionStore;
   readonly catalog: BuildCatalog;
-  readonly environment: RuntimeEnvironmentStore;
   readonly submissions: PendingBuildStore;
   readonly #database: DatabaseSync;
 
@@ -1007,6 +995,7 @@ export class SqliteRuntimeState {
         command_id TEXT NOT NULL,
         status TEXT NOT NULL CHECK (status IN ('started', 'completed')),
         event_json TEXT,
+        activity_json TEXT,
         PRIMARY KEY (build_id, command_id)
       ) STRICT;
       CREATE TABLE IF NOT EXISTS hypit_build_catalog (
@@ -1018,13 +1007,16 @@ export class SqliteRuntimeState {
         build_id TEXT PRIMARY KEY,
         component_packages_json TEXT NOT NULL,
         result_location_json TEXT NOT NULL,
+        context_json TEXT,
         created_at INTEGER NOT NULL
       ) STRICT;
       CREATE TABLE IF NOT EXISTS hypit_executions (
         build_id TEXT PRIMARY KEY,
         component_packages_json TEXT NOT NULL,
         result_location_json TEXT NOT NULL,
+        context_json TEXT,
         created_at INTEGER NOT NULL,
+        started_at INTEGER,
         wake_at INTEGER,
         operation_wait_json TEXT,
         turn_owner TEXT,
@@ -1062,17 +1054,26 @@ export class SqliteRuntimeState {
         resource_id TEXT PRIMARY KEY, limit_units INTEGER NOT NULL, period_ms INTEGER NOT NULL,
         tokens REAL NOT NULL, updated_at INTEGER NOT NULL
       ) STRICT;
-      CREATE TABLE IF NOT EXISTS hypit_runtime_environment (
-        singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-        config_json TEXT NOT NULL
-      ) STRICT;
     `);
+    if (!options.readOnly) transaction(database, () => {
+      for (const table of ["hypit_submissions", "hypit_executions"]) {
+        const columns = database.prepare(`PRAGMA table_info(${table})`).all() as Row[];
+        if (!columns.some((column) => column.name === "context_json")) database.exec(`ALTER TABLE ${table} ADD COLUMN context_json TEXT`);
+        if (table === "hypit_executions" && !columns.some((column) => column.name === "started_at")) database.exec("ALTER TABLE hypit_executions ADD COLUMN started_at INTEGER");
+      }
+    });
+    // Add the nullable live-activity column without touching any accepted facts or Results.
+    if (!options.readOnly) transaction(database, () => {
+      if (!(database.prepare("PRAGMA table_info(hypit_command_executions)").all() as Row[])
+        .some((column) => column.name === "activity_json")) {
+        database.exec("ALTER TABLE hypit_command_executions ADD COLUMN activity_json TEXT");
+      }
+    });
     this.builds = new SqliteBuildStore(database);
     this.operations = new SqliteOperationStore(database);
     this.commandExecutions = new SqliteCommandExecutionStore(database);
     this.execution = new SqliteBuildExecutionStore(database);
     this.catalog = new SqliteBuildCatalog(database);
-    this.environment = new SqliteRuntimeEnvironmentStore(database);
     this.submissions = new SqlitePendingBuildStore(database);
   }