@dxos/assistant 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/dist/lib/neutral/index.mjs

@@ -2,7 +2,7 @@ import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
 
-// src/functions/services.ts
+// src/tool-runtime/services.ts
 import * as Tool from "@effect/ai/Tool";
 import * as Context from "effect/Context";
 import * as Effect2 from "effect/Effect";
@@ -77,8 +77,11 @@ var ArtifactURI = class extends Schema.String.annotations({
   }
 };
 var RefFromLLM = Schema.transform(ArtifactURI, Ref.Ref(Obj.Unknown), {
-  decode: (fromA, fromI) => EncodedReference.fromURI(ArtifactURI.toEchoURI(fromA)),
-  encode: (toI, toA) => EncodedReference.toURI(toI),
+  decode: (fromA) => {
+    const eid = ArtifactURI.toEchoURI(fromA);
+    return EncodedReference.fromURI(EID.toLocal(eid));
+  },
+  encode: (toI) => EncodedReference.toURI(toI),
   strict: false
 }).annotations({
   description: ArtifactURI.ast.annotations.description
@@ -86,7 +89,8 @@ var RefFromLLM = Schema.transform(ArtifactURI, Ref.Ref(Obj.Unknown), {
 
 // src/util/diff.ts
 import { next as A } from "@automerge/automerge";
-import { DocAccessor, toCursorRange } from "@dxos/echo-client";
+import { toCursorRange } from "@dxos/echo-client";
+import { Doc } from "@dxos/echo-doc";
 import { log } from "@dxos/log";
 import { isNonNullable } from "@dxos/util";
 var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/assistant/src/util/diff.ts";
@@ -125,7 +129,7 @@ var reduceDiffs = (diffs) => {
 };
 var computeDiffsWithCursors = (accessor, diffs) => {
   return reduceDiffs(diffs).map((diff) => {
-    const text = DocAccessor.getValue(accessor);
+    const text = Doc.getValue(accessor);
     const idx = text.indexOf(diff.match);
     if (idx !== -1) {
       return {
@@ -138,7 +142,7 @@ var computeDiffsWithCursors = (accessor, diffs) => {
 var applyDiffs = (accessor, diffs, { errorOnNotFound = false } = {}) => {
   for (const diff of reduceDiffs(diffs)) {
     accessor.handle.change((doc) => {
-      const text = DocAccessor.getValue(accessor);
+      const text = Doc.getValue(accessor);
       const idx = text.indexOf(diff.match);
       if (idx !== -1) {
         A.splice(doc, accessor.path, idx, diff.match.length, diff.replace);
@@ -146,12 +150,12 @@ var applyDiffs = (accessor, diffs, { errorOnNotFound = false } = {}) => {
         if (errorOnNotFound) {
           throw new Error(`Diff not found: ${diff.match}`);
         } else {
-          log.warn("diff not found", diff, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 71, S: void 0 });
+          log.warn("diff not found", diff, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 76, S: void 0 });
         }
       }
     });
   }
-  return DocAccessor.getValue(accessor);
+  return Doc.getValue(accessor);
 };
 
 // src/util/error-handling.ts
@@ -584,7 +588,7 @@ var stringifyObject = (obj) => {
 import * as Schema3 from "effect/Schema";
 import { Trace } from "@dxos/compute";
 import { Obj as Obj3 } from "@dxos/echo";
-import { ContentBlock as ContentBlock2, Actor } from "@dxos/types";
+import { Actor, ContentBlock as ContentBlock2 } from "@dxos/types";
 var PartialBlock = Trace.EventType("assistant.partialBlock", {
   schema: Schema3.Struct({
     messageId: Obj3.ID,
@@ -621,8 +625,8 @@ var McpServerError = Trace.EventType("assistant.mcpServerError", {
   isEphemeral: true
 });
 
-// src/functions/services.ts
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/assistant/src/functions/services.ts";
+// src/tool-runtime/services.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/assistant/src/tool-runtime/services.ts";
 var makeToolResolverFromOperations = ({ toolkit: extraToolkit = OpaqueToolkit.empty } = {}) => {
   return Layer.effect(ToolResolverService, Effect2.gen(function* () {
     const toolkitProvider = yield* OpaqueToolkit.OpaqueToolkitProvider;
@@ -761,16 +765,16 @@ var ArtifactDiffResolver = class extends Context2.Tag("@dxos/assistant/ArtifactD
 
 // src/request/format.ts
 var __dxlog_file3 = "/__w/dxos/dxos/packages/core/compute/assistant/src/request/format.ts";
-var formatSystemPrompt = ({ system, blueprints = [], objects = [] }) => Effect3.gen(function* () {
-  const blueprintDefs = yield* Function.pipe(blueprints, Effect3.forEach((blueprint) => Effect3.succeed(blueprint.instructions)), Effect3.flatMap(Effect3.forEach((template) => Effect3.gen(function* () {
+var formatSystemPrompt = ({ system, skills = [], objects = [] }) => Effect3.gen(function* () {
+  const skillDefs = yield* Function.pipe(skills, Effect3.forEach((skill) => Effect3.succeed(skill.instructions)), Effect3.flatMap(Effect3.forEach((template) => Effect3.gen(function* () {
     return trim2`
-            <blueprint>
+            <skill>
               ${yield* Template.processTemplate(template)}
-            </blueprint>
+            </skill>
           `;
-  }))), Effect3.map((blueprints2) => blueprints2.length > 0 ? [
-    "## Blueprints Definitions",
-    ...blueprints2
+  }))), Effect3.map((skills2) => skills2.length > 0 ? [
+    "## Skills Definitions",
+    ...skills2
   ].join("\n\n") : void 0));
   const objectDefs = yield* Function.pipe(objects, Effect3.forEach((object) => Effect3.succeed(trim2`
           <object>
@@ -783,15 +787,15 @@ var formatSystemPrompt = ({ system, blueprints = [], objects = [] }) => Effect3.
   ].join("\n\n") : void 0));
   return yield* Function.pipe(Effect3.succeed([
     system,
-    blueprintDefs,
+    skillDefs,
     objectDefs
   ].filter((def) => def !== void 0)), Effect3.map((parts) => parts.join("\n\n")));
 }).pipe(Effect3.withSpan("formatSystemPrompt"));
-var formatUserPrompt = ({ prompt, history = [] }) => Effect3.gen(function* () {
+var formatUserPrompt = ({ prompt, history: history2 = [] }) => Effect3.gen(function* () {
   const blocks = [];
   const artifactDiffResolver = yield* Effect3.serviceOption(ArtifactDiffResolver);
   if (Option2.isSome(artifactDiffResolver)) {
-    const versions = gatherObjectVersions(history);
+    const versions = gatherObjectVersions(history2);
     const artifactDiff = yield* Effect3.tryPromise({
       try: () => artifactDiffResolver.value.resolve([
         ...versions.entries()
@@ -976,15 +980,15 @@ var Request = class {
   * Initialize a session: set up history, perform summarization if needed, and submit the user prompt.
   * Must be called before `runTurn()`.
   */
-  begin = ({ prompt, system, history = [], blueprints = [], objects = [] }) => Effect5.gen(this, function* () {
+  begin = ({ prompt, system, history: history2 = [], skills = [], objects = [] }) => Effect5.gen(this, function* () {
     this._started = Date.now();
     this._history = [
-      ...history
+      ...history2
     ];
     this._pending = [];
     const systemPrompt = yield* formatSystemPrompt({
       system,
-      blueprints,
+      skills,
       objects
     }).pipe(Effect5.orDie);
     if (this._options.summarizationThreshold !== void 0) {
@@ -1002,12 +1006,12 @@ var Request = class {
     }
     yield* this._submitMessage(yield* formatUserPrompt({
       prompt,
-      history
+      history: history2
     }));
   }).pipe(Effect5.withSpan("AiRequest.begin"));
   /**
   * Execute a single turn: one LLM generation followed by tool execution.
-  * The toolkit and system prompt can be updated between turns to reflect context changes (e.g. dynamically enabled blueprints).
+  * The toolkit and system prompt can be updated between turns to reflect context changes (e.g. dynamically enabled skills).
   */
   runAgentTurn = ({ system, toolkit: opaqueToolkit }) => Effect5.gen(this, function* () {
     log3("request", {
@@ -1028,6 +1032,7 @@ var Request = class {
     const toolkit = opaqueToolkit ? yield* opaqueToolkit.handlers : void 0;
     const observer = this._observer;
     let currentMessageId = null;
+    let finishReason;
     const messages = yield* LanguageModel.streamText({
       prompt,
       toolkit,
@@ -1039,12 +1044,15 @@ var Request = class {
       onPart: (part) => observer.onPart(part),
       onEnd: (summary) => observer.onEnd(summary)
     }), Stream.map((block) => enrichToolCallBlock(block, toolkit)), Stream.mapEffect((block) => Effect5.gen(this, function* () {
+      if (block._tag === "stats" && block.finishReason !== void 0) {
+        finishReason = block.finishReason;
+      }
       if (block.pending) {
         currentMessageId ??= Obj5.ID.random();
         log3("emit ephemeral message", {
           id: currentMessageId,
           type: block._tag
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 150, S: this });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 154, S: this });
         yield* Trace2.write(PartialBlock, {
           messageId: currentMessageId,
           role: "assistant",
@@ -1058,7 +1066,7 @@ var Request = class {
         log3("emit complete message", {
           id,
           type: block._tag
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 164, S: this });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 168, S: this });
         const message = Obj5.make(Message3.Message, {
           id,
           created: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1077,20 +1085,29 @@ var Request = class {
     }), Stream.filterMap((_) => _), Stream.runCollect, Effect5.map(Chunk.toArray));
     log3("messages", {
       messages
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 184, S: this });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 188, S: this });
+    if (finishReason === "pause") {
+      return {
+        messages,
+        done: false,
+        finishReason
+      };
+    }
     const toolCalls = this.getToolCalls();
     if (toolCalls.length === 0) {
       this._ended = Date.now();
       return {
         messages,
-        done: true
+        done: true,
+        finishReason
       };
     } else if (!toolkit) {
       throw new Error("No toolkit provided");
     }
     return {
       messages,
-      done: false
+      done: false,
+      finishReason
     };
   }).pipe(Effect5.withSpan("AiRequest.runAgentTurn"));
   runTools = ({ toolkit: opaqueToolkit }) => Effect5.gen(this, function* () {
@@ -1114,27 +1131,30 @@ var Request = class {
   /**
   * Run a full conversation turn loop. Equivalent to calling `begin()` then `runTurn()` in a loop.
   */
-  run = ({ prompt, system: systemTemplate, history = [], objects = [], blueprints = [], toolkit }) => Effect5.gen(this, function* () {
+  run = ({ prompt, system: systemTemplate, history: history2 = [], objects = [], skills = [], toolkit }) => Effect5.gen(this, function* () {
     yield* this.begin({
       prompt,
       system: systemTemplate,
-      history,
+      history: history2,
       objects,
-      blueprints
+      skills
     });
     const system = yield* formatSystemPrompt({
       system: systemTemplate,
-      blueprints,
+      skills,
       objects
     }).pipe(Effect5.orDie);
     do {
-      const { done } = yield* this.runAgentTurn({
+      const { done, finishReason } = yield* this.runAgentTurn({
         system,
         toolkit
       });
       if (done) {
         break;
       }
+      if (finishReason === "pause") {
+        continue;
+      }
       yield* this.runTools({
         toolkit
       });
@@ -1143,7 +1163,7 @@ var Request = class {
       pending: this._pending.length,
       duration: this.duration,
       tools: this._toolCalls
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 247, S: this });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 267, S: this });
     return this._pending;
   }).pipe(this._semaphore.withPermits(1), Effect5.withSpan("AiRequest.run"));
 };
@@ -1184,17 +1204,17 @@ import * as Effect6 from "effect/Effect";
 import * as Layer2 from "effect/Layer";
 import { OpaqueToolkit as OpaqueToolkit2, ToolExecutionService as ToolExecutionService2, ToolResolverService as ToolResolverService2 } from "@dxos/ai";
 import { isTruthy } from "@dxos/util";
-var createToolkit = ({ toolkit: toolkitProp, blueprints = [], opaqueToolkits = [] }) => Effect6.gen(function* () {
-  const blueprintToolkit = yield* ToolResolverService2.resolveToolkit(blueprints.flatMap(({ tools }) => tools));
-  const blueprintToolHandler = yield* blueprintToolkit.toContext(ToolExecutionService2.handlersFor(blueprintToolkit));
+var createToolkit = ({ toolkit: toolkitProp, skills = [], opaqueToolkits = [] }) => Effect6.gen(function* () {
+  const skillToolkit = yield* ToolResolverService2.resolveToolkit(skills.flatMap(({ tools }) => tools));
+  const skillToolHandler = yield* skillToolkit.toContext(ToolExecutionService2.handlersFor(skillToolkit));
   const opaqueToolkit = OpaqueToolkit2.merge(...opaqueToolkits);
   const toolkitDefs = [
     toolkitProp?.toolkit,
-    blueprintToolkit,
+    skillToolkit,
     opaqueToolkit.toolkit
   ].filter(isTruthy);
   const mergedToolkit = Toolkit.merge(...toolkitDefs);
-  const combinedHandlerLayer = Layer2.mergeAll(Layer2.succeedContext(blueprintToolHandler), toolkitProp?.layer ?? OpaqueToolkit2.empty.layer, opaqueToolkit.layer);
+  const combinedHandlerLayer = Layer2.mergeAll(Layer2.succeedContext(skillToolHandler), toolkitProp?.layer ?? OpaqueToolkit2.empty.layer, opaqueToolkit.layer);
   return OpaqueToolkit2.make(mergedToolkit, combinedHandlerLayer);
 });
 
@@ -1203,17 +1223,14 @@ var AiContext_exports = {};
 __export(AiContext_exports, {
   Binder: () => Binder,
   Binding: () => Binding,
-  Bindings: () => Bindings,
-  Service: () => Service
+  Bindings: () => Bindings
 });
 import { Atom, Registry as AtomRegistry } from "@effect-atom/atom-react";
 import * as EArray from "effect/Array";
-import * as Context3 from "effect/Context";
-import * as Effect7 from "effect/Effect";
 import * as Function3 from "effect/Function";
 import * as Runtime from "effect/Runtime";
 import * as Schema5 from "effect/Schema";
-import { Blueprint } from "@dxos/compute";
+import { Skill } from "@dxos/compute";
 import { Resource } from "@dxos/context";
 import { Annotation, DXN as DXN2, Feed, Obj as Obj6, Query, Ref as Ref3, Type as Type2 } from "@dxos/echo";
 import { assertArgument } from "@dxos/invariant";
@@ -1221,18 +1238,19 @@ import { EID as EID3 } from "@dxos/keys";
 import { log as log4 } from "@dxos/log";
 import { ComplexSet, isNonNullable as isNonNullable3 } from "@dxos/util";
 var __dxlog_file5 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/AiContext.ts";
-var Binding = Schema5.Struct({
-  blueprints: Schema5.Struct({
-    added: Schema5.Array(Ref3.Ref(Blueprint.Blueprint)),
-    removed: Schema5.Array(Ref3.Ref(Blueprint.Blueprint))
+var Binding = class extends Type2.makeObject(DXN2.make("org.dxos.type.contextBinding", "0.1.0"))(Schema5.Struct({
+  skills: Schema5.Struct({
+    added: Schema5.Array(Ref3.Ref(Skill.Skill)),
+    removed: Schema5.Array(Ref3.Ref(Skill.Skill))
   }),
   objects: Schema5.Struct({
     added: Schema5.Array(Ref3.Ref(Obj6.Unknown)),
     removed: Schema5.Array(Ref3.Ref(Obj6.Unknown))
   })
-}).pipe(Annotation.HiddenAnnotation.set(true), Type2.makeObject(DXN2.make("org.dxos.type.contextBinding", "0.1.0")));
+}).pipe(Annotation.HiddenAnnotation.set(true))) {
+};
 var Bindings = class {
-  blueprints = new ComplexSet((ref) => ref.uri);
+  skills = new ComplexSet((ref) => ref.uri);
   // TODO(burdon): Some DXNs have the Space prefix so only compare the object ID.
   objects = new ComplexSet((ref) => {
     const echoUri = EID3.tryParse(ref.uri);
@@ -1240,13 +1258,13 @@ var Bindings = class {
   });
   toJSON() {
     return {
-      blueprints: EArray.fromIterable(this.blueprints).map((ref) => ref.uri),
+      skills: EArray.fromIterable(this.skills).map((ref) => ref.uri),
       objects: EArray.fromIterable(this.objects).map((ref) => ref.uri)
     };
   }
 };
 var Binder = class extends Resource {
-  _blueprints = Atom.make([]).pipe(Atom.keepAlive);
+  _skills = Atom.make([]).pipe(Atom.keepAlive);
   _objects = Atom.make([]).pipe(Atom.keepAlive);
   _registry;
   _feed;
@@ -1261,10 +1279,10 @@ var Binder = class extends Resource {
     this._registry = options.registry ?? AtomRegistry.make();
   }
   /**
-  * Returns the blueprints atom for subscription.
+  * Returns the skills atom for subscription.
   */
-  get blueprints() {
-    return this._blueprints;
+  get skills() {
+    return this._skills;
   }
   /**
   * Returns the objects atom for subscription.
@@ -1273,10 +1291,10 @@ var Binder = class extends Resource {
     return this._objects;
   }
   /**
-  * Gets the current blueprints value.
+  * Gets the current skills value.
   */
-  getBlueprints() {
-    return this._registry.get(this._blueprints);
+  getSkills() {
+    return this._registry.get(this._skills);
   }
   /**
   * Gets the current objects value.
@@ -1285,10 +1303,10 @@ var Binder = class extends Resource {
     return this._registry.get(this._objects);
   }
   /**
-  * Subscribe to changes in blueprints.
+  * Subscribe to changes in skills.
   */
-  subscribeBlueprints(cb) {
-    return this._registry.subscribe(this._blueprints, () => cb(this._registry.get(this._blueprints)));
+  subscribeSkills(cb) {
+    return this._registry.subscribe(this._skills, () => cb(this._registry.get(this._skills)));
   }
   /**
   * Subscribe to changes in objects.
@@ -1312,12 +1330,12 @@ var Binder = class extends Resource {
       const results = await this.#bindingsQuery.run();
       log4("sync", {
         bindingItems: results.length
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 108, S: this });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 107, S: this });
       await this._updateBindings(results);
       log4("sync complete", {
-        blueprints: this._registry.get(this._blueprints).length,
-        blueprintKeys: this._registry.get(this._blueprints).map((bp) => Blueprint.getKey(bp))
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 112, S: this });
+        skills: this._registry.get(this._skills).length,
+        skillKeys: this._registry.get(this._skills).map((bp) => Skill.getKey(bp))
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 111, S: this });
     }
   }
   async _updateBindings(items) {
@@ -1327,75 +1345,75 @@ var Binder = class extends Resource {
     const bindings = this._reduce(items);
     log4("_updateBindings", {
       items: items.length,
-      blueprintRefs: [
-        ...bindings.blueprints
+      skillRefs: [
+        ...bindings.skills
       ].map((ref) => ({
         uri: ref.uri,
         available: ref.isAvailable
       }))
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 124, S: this });
-    const currentBlueprints = this._registry.get(this._blueprints);
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 123, S: this });
+    const currentSkills = this._registry.get(this._skills);
     const currentObjects = this._registry.get(this._objects);
-    const resolvedBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
+    const resolvedSkills = await this._resolve(bindings.skills, currentSkills);
     const resolvedObjects = await this._resolve(bindings.objects, currentObjects);
     log4("_updateBindings resolved", {
-      resolvedBlueprints: resolvedBlueprints.length,
-      resolvedBlueprintKeys: resolvedBlueprints.map((bp) => Obj6.getMeta(bp).key ?? "<missing>")
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 138, S: this });
-    const keyedBlueprints = resolvedBlueprints.filter((bp) => {
+      resolvedSkills: resolvedSkills.length,
+      resolvedSkillKeys: resolvedSkills.map((bp) => Obj6.getMeta(bp).key ?? "<missing>")
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 137, S: this });
+    const keyedSkills = resolvedSkills.filter((bp) => {
       if (Obj6.getMeta(bp).key === void 0) {
-        log4.warn("dropping blueprint with no meta key", {
+        log4.warn("dropping skill with no meta key", {
           uri: Obj6.getURI(bp)
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 146, S: this });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 145, S: this });
         return false;
       }
       return true;
     });
-    const reducedBlueprintDxns = new Set([
-      ...bindings.blueprints
+    const reducedSkillDxns = new Set([
+      ...bindings.skills
     ].map((ref) => ref.uri));
     const reducedObjectDxns = new Set([
       ...bindings.objects
     ].map((ref) => ref.uri));
-    const filteredBlueprints = currentBlueprints.filter((obj) => {
+    const filteredSkills = currentSkills.filter((obj) => {
       const uri = Obj6.getURI(obj);
-      return uri != null && reducedBlueprintDxns.has(uri) && Obj6.getMeta(obj).key !== void 0;
+      return uri != null && reducedSkillDxns.has(uri) && Obj6.getMeta(obj).key !== void 0;
     });
     const filteredObjects = currentObjects.filter((obj) => {
       const uri = Obj6.getURI(obj);
       return uri != null && reducedObjectDxns.has(uri);
     });
-    const mergedBlueprints = this._mergeInto(filteredBlueprints, keyedBlueprints);
+    const mergedSkills = this._mergeInto(filteredSkills, keyedSkills);
     const mergedObjects = this._mergeInto(filteredObjects, resolvedObjects);
-    this._registry.set(this._blueprints, mergedBlueprints);
+    this._registry.set(this._skills, mergedSkills);
     this._registry.set(this._objects, mergedObjects);
     log4("updated bindings", {
-      blueprints: mergedBlueprints.length,
+      skills: mergedSkills.length,
       objects: mergedObjects.length
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 173, S: this });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 172, S: this });
   }
   async _close() {
-    this._registry.set(this._blueprints, []);
+    this._registry.set(this._skills, []);
     this._registry.set(this._objects, []);
   }
-  async bind({ blueprints, objects }) {
-    const currentBlueprints = this._registry.get(this._blueprints);
+  async bind({ skills, objects }) {
+    const currentSkills = this._registry.get(this._skills);
     const currentObjects = this._registry.get(this._objects);
-    const { added: addedBlueprints, next: nextBlueprints } = this._processBindings(blueprints, currentBlueprints);
+    const { added: addedSkills, next: nextSkills } = this._processBindings(skills, currentSkills);
     const { added: addedObjects, next: nextObjects } = this._processBindings(objects, currentObjects);
-    if (!addedBlueprints.length && !addedObjects.length) {
+    if (!addedSkills.length && !addedObjects.length) {
       return;
     }
-    this._registry.set(this._blueprints, nextBlueprints);
+    this._registry.set(this._skills, nextSkills);
     this._registry.set(this._objects, nextObjects);
     log4("bind", {
-      blueprints: addedBlueprints.length,
+      skills: addedSkills.length,
       objects: addedObjects.length
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 194, S: this });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 193, S: this });
     await Runtime.runPromise(this._runtime)(Feed.append(this._feed, [
       Obj6.make(Binding, {
-        blueprints: {
-          added: addedBlueprints,
+        skills: {
+          added: addedSkills,
           removed: []
         },
         objects: {
@@ -1405,29 +1423,29 @@ var Binder = class extends Resource {
       })
     ]));
   }
-  async unbind({ blueprints, objects }) {
-    if (!blueprints?.length && !objects?.length) {
+  async unbind({ skills, objects }) {
+    if (!skills?.length && !objects?.length) {
       return;
     }
-    const removedBlueprintDxns = (blueprints ?? []).map((ref) => ref.uri);
+    const removedSkillDxns = (skills ?? []).map((ref) => ref.uri);
     const removedObjectDxns = (objects ?? []).map((ref) => ref.uri);
-    if (removedBlueprintDxns.length > 0) {
-      const current = this._registry.get(this._blueprints);
-      this._registry.set(this._blueprints, current.filter((obj) => !removedBlueprintDxns.some((uri) => Obj6.getURI(obj) === uri)));
+    if (removedSkillDxns.length > 0) {
+      const current = this._registry.get(this._skills);
+      this._registry.set(this._skills, current.filter((obj) => !removedSkillDxns.some((uri) => Obj6.getURI(obj) === uri)));
     }
     if (removedObjectDxns.length > 0) {
       const current = this._registry.get(this._objects);
       this._registry.set(this._objects, current.filter((obj) => !removedObjectDxns.some((uri) => Obj6.getURI(obj) === uri)));
     }
     log4("unbind", {
-      blueprints: blueprints?.length,
+      skills: skills?.length,
       objects: objects?.length
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 226, S: this });
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 225, S: this });
     await Runtime.runPromise(this._runtime)(Feed.append(this._feed, [
       Obj6.make(Binding, {
-        blueprints: {
+        skills: {
           added: [],
-          removed: blueprints ?? []
+          removed: skills ?? []
         },
         objects: {
           added: [],
@@ -1471,12 +1489,12 @@ var Binder = class extends Resource {
     };
   }
   /**
-  * Reduce results into sets of blueprints and objects.
+  * Reduce results into sets of skills and objects.
   */
   _reduce(items) {
-    return Function3.pipe(items, EArray.reduce(new Bindings(), (context, { blueprints, objects }) => {
-      blueprints.added.forEach((ref) => context.blueprints.add(ref));
-      blueprints.removed.forEach((ref) => context.blueprints.delete(ref));
+    return Function3.pipe(items, EArray.reduce(new Bindings(), (context, { skills, objects }) => {
+      skills.added.forEach((ref) => context.skills.add(ref));
+      skills.removed.forEach((ref) => context.skills.delete(ref));
       objects.added.forEach((ref) => context.objects.add(ref));
       objects.removed.forEach((ref) => {
         for (const obj of context.objects) {
@@ -1507,7 +1525,7 @@ var Binder = class extends Resource {
   }
   /**
   * Resolve references to objects, loading them first if needed and falling back to existing objects.
-  * DXN refs (e.g. `dxn:org.dxos.blueprint.database`) resolve via the wired-up ECHO ref resolver
+  * DXN refs (e.g. `dxn:org.dxos.skill.database`) resolve via the wired-up ECHO ref resolver
   * which already spans both the space DB and the hypergraph registry.
   */
   async _resolve(refs, current) {
@@ -1524,47 +1542,56 @@ var Binder = class extends Resource {
     }).filter(isNonNullable3);
   }
 };
-var Service = class _Service extends Context3.Tag("@dxos/assistant/AiContextService")() {
-  static bindContext = ({ blueprints, objects }) => Effect7.gen(function* () {
-    const { binder } = yield* _Service;
-    yield* Effect7.promise(() => binder.bind({
-      blueprints,
-      objects
-    }));
-  });
-  static findObjects = (type) => {
-    return Effect7.gen(function* () {
-      const { binder } = yield* _Service;
-      return binder.getObjects().filter(Obj6.instanceOf(type));
-    });
-  };
-};
 
 // src/session/AiSession.ts
 var AiSession_exports = {};
 __export(AiSession_exports, {
-  Service: () => Service2,
   Session: () => Session
 });
 import * as Array4 from "effect/Array";
-import * as Context4 from "effect/Context";
-import * as Effect9 from "effect/Effect";
+import * as Effect10 from "effect/Effect";
 import * as Either from "effect/Either";
 import { pipe as pipe4 } from "effect/Function";
-import * as Layer3 from "effect/Layer";
+import * as Layer4 from "effect/Layer";
 import * as Record2 from "effect/Record";
 import * as Runtime2 from "effect/Runtime";
-import { Operation as Operation2, Trace as Trace3 } from "@dxos/compute";
+import { Operation as Operation3, Trace as Trace3 } from "@dxos/compute";
 import { Resource as Resource2 } from "@dxos/context";
-import { Database as Database2, Feed as Feed4, Filter as Filter3, Obj as Obj9 } from "@dxos/echo";
-import { EffectEx } from "@dxos/effect";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { log as log5 } from "@dxos/log";
+import { Feed as Feed5, Filter as Filter4, Obj as Obj10 } from "@dxos/echo";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { log as log6 } from "@dxos/log";
 import { McpToolkit } from "@dxos/mcp-client";
+import { Message as Message6 } from "@dxos/types";
+
+// src/session/Harness.ts
+var Harness_exports = {};
+__export(Harness_exports, {
+  HarnessService: () => HarnessService,
+  NotSupportedError: () => NotSupportedError,
+  bindContext: () => bindContext,
+  binder: () => binder,
+  enqueueMessage: () => enqueueMessage,
+  fromBinder: () => fromBinder,
+  history: () => history,
+  layerSpec: () => layerSpec,
+  make: () => make3,
+  queryContext: () => queryContext,
+  setAlarm: () => setAlarm
+});
+import * as Context3 from "effect/Context";
+import * as DateTime from "effect/DateTime";
+import * as Effect8 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import * as Option4 from "effect/Option";
+import { LayerSpec, Process, ServiceNotAvailableError } from "@dxos/compute";
+import { ProcessManager } from "@dxos/compute-runtime";
+import { Annotation as Annotation2, Database as Database2, EID as EID4, Feed as Feed4, Filter as Filter3 } from "@dxos/echo";
+import { EffectEx } from "@dxos/effect";
+import { BaseError as BaseError2 } from "@dxos/errors";
 import { Message as Message5 } from "@dxos/types";
 
 // src/session/SessionLoader.ts
-import * as Effect8 from "effect/Effect";
+import * as Effect7 from "effect/Effect";
 import { Feed as Feed3, Filter as Filter2, Obj as Obj8 } from "@dxos/echo";
 import { Message as Message4 } from "@dxos/types";
 
@@ -1575,12 +1602,13 @@ __export(SessionLink_exports, {
 });
 import * as Schema6 from "effect/Schema";
 import { DXN as DXN3, Feed as Feed2, Obj as Obj7, Ref as Ref4, Type as Type3 } from "@dxos/echo";
-var SessionLink = Schema6.Struct({
+var SessionLink = class extends Type3.makeObject(DXN3.make("org.dxos.type.sessionLink", "0.1.0"))(Schema6.Struct({
   /** Reference to the feed of the source session. */
   feedRef: Ref4.Ref(Feed2.Feed),
   /** Messages from the source feed up to and including this message ID are injected. */
   messageId: Obj7.ID
-}).pipe(Type3.makeObject(DXN3.make("org.dxos.type.sessionLink", "0.1.0")));
+})) {
+};
 
 // src/session/SessionLoader.ts
 var SessionLoader = class {
@@ -1590,8 +1618,8 @@ var SessionLoader = class {
   * the referenced feed up to and including `messageId` and prepends them.
   */
   reifyHistory(feed, messages) {
-    return Effect8.gen(function* () {
-      const links = yield* Feed3.runQuery(feed, Filter2.type(SessionLink));
+    return Effect7.gen(function* () {
+      const links = yield* Feed3.query(feed, Filter2.type(SessionLink)).run;
       const sessionLinks = links.filter(Obj8.instanceOf(SessionLink));
       const link = sessionLinks[0];
       if (!link) {
@@ -1601,7 +1629,7 @@ var SessionLoader = class {
       if (!sourceFeed) {
         return messages;
       }
-      const sourceMessages = yield* Feed3.runQuery(sourceFeed, Filter2.type(Message4.Message));
+      const sourceMessages = yield* Feed3.query(sourceFeed, Filter2.type(Message4.Message)).run;
       const filtered = sourceMessages.filter(Obj8.instanceOf(Message4.Message));
       const sorted = [
         ...filtered
@@ -1618,12 +1646,138 @@ var SessionLoader = class {
   }
 };
 
+// src/session/Harness.ts
+var HarnessService = class extends Context3.Tag("@dxos/assistant/HarnessService")() {
+};
+var binder = Effect8.flatMap(HarnessService, (service) => service.binder);
+var queryContext = (filter2) => Effect8.flatMap(HarnessService, (service) => service.queryContext(filter2));
+var history = Effect8.flatMap(HarnessService, (service) => service.history);
+var enqueueMessage = (options) => Effect8.flatMap(HarnessService, (service) => service.enqueueMessage(options));
+var setAlarm = (options) => Effect8.flatMap(HarnessService, (service) => service.setAlarm(options));
+var bindContext = ({ skills, objects }) => Effect8.gen(function* () {
+  const sessionBinder = yield* binder;
+  yield* Effect8.promise(() => sessionBinder.bind({
+    skills,
+    objects
+  }));
+});
+var NotSupportedError = class extends BaseError2.extend("NotSupportedError", "Operation not supported") {
+};
+var layerSpec = LayerSpec.make({
+  affinity: "process",
+  requires: [
+    Database2.Service,
+    ProcessManager.Service
+  ],
+  provides: [
+    HarnessService
+  ]
+}, (context) => Layer3.scoped(HarnessService, Effect8.gen(function* () {
+  if (!context.conversation) {
+    return yield* Effect8.die(new ServiceNotAvailableError(HarnessService.key, {
+      message: `Service not available: ${HarnessService.key} \u2014 process spawn is missing 'conversation' in environment (set via Operation.withInvocationOptions or ProcessManager.spawn environment)`
+    }));
+  }
+  const conversation = context.conversation;
+  const processManager = yield* ProcessManager.Service;
+  const runtime2 = yield* Effect8.runtime();
+  return yield* make3({
+    conversation,
+    processManager,
+    runtime: runtime2
+  });
+})));
+var make3 = ({ conversation, processManager, runtime: runtime2 }) => Effect8.gen(function* () {
+  const feed = yield* Database2.resolve(EID4.parse(conversation), Feed4.Feed).pipe(Effect8.provide(runtime2), Effect8.orDie);
+  const boundBinder = yield* EffectEx.acquireReleaseResource(() => new Binder({
+    feed,
+    runtime: runtime2
+  }));
+  return makeService({
+    feed,
+    runtime: runtime2,
+    binder: boundBinder,
+    owningHost: lookupOwningHost(processManager, conversation)
+  });
+});
+var fromBinder = ({ feed, runtime: runtime2, binder: binder2 }) => makeService({
+  feed,
+  runtime: runtime2,
+  binder: binder2,
+  owningHost: Effect8.fail(new NotSupportedError())
+});
+var makeService = ({ feed, runtime: runtime2, binder: binder2, owningHost }) => ({
+  binder: Effect8.succeed(binder2),
+  history: Effect8.gen(function* () {
+    const messages = yield* Feed4.query(feed, Filter3.type(Message5.Message)).run;
+    return yield* new SessionLoader().reifyHistory(feed, messages);
+  }).pipe(Effect8.provide(runtime2)),
+  queryContext: (filter2) => Effect8.sync(() => {
+    const match = Filter3.toPredicate(filter2);
+    return binder2.getObjects().filter(match);
+  }),
+  enqueueMessage: ({ content }) => owningHost.pipe(Effect8.flatMap((rpc) => rpc.enqueueMessage({
+    content
+  }))),
+  setAlarm: ({ at, message }) => owningHost.pipe(Effect8.flatMap((rpc) => rpc.setAlarm({
+    at: DateTime.toUtc(at),
+    message
+  })))
+});
+var lookupOwningHost = (processManager, conversation) => Effect8.gen(function* () {
+  const processes = yield* processManager.list({
+    target: conversation
+  });
+  const host = processes.find((process) => !isTerminalProcess(process.status.state) && Option4.getOrElse(Annotation2.getDictionary(process.params.annotations, Process.HarnessHostAnnotation), () => false));
+  if (!host) {
+    return yield* Effect8.fail(new NotSupportedError());
+  }
+  return host.rpc;
+});
+var isTerminalProcess = (state) => state === Process.State.SUCCEEDED || state === Process.State.FAILED || state === Process.State.TERMINATED;
+
+// src/session/SkillHooks.ts
+var SkillHooks_exports = {};
+__export(SkillHooks_exports, {
+  runHooks: () => runHooks
+});
+import * as Effect9 from "effect/Effect";
+import { Operation as Operation2, Skill as Skill2 } from "@dxos/compute";
+import { Database as Database3, Obj as Obj9 } from "@dxos/echo";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log5 } from "@dxos/log";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/SkillHooks.ts";
+var runHooks = ({ skills, phase, invoke }) => Effect9.gen(function* () {
+  for (const skill of skills) {
+    for (const hook of skill.hooks ?? []) {
+      if (hook.spec._tag !== phase) {
+        continue;
+      }
+      if (!hook.function) {
+        continue;
+      }
+      yield* Effect9.gen(function* () {
+        const record = yield* Database3.load(hook.function);
+        invariant2(Obj9.instanceOf(Operation2.PersistentOperation, record), "Hook function must be an operation.", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 28, S: this, A: ["Obj.instanceOf(Operation.PersistentOperation, record)", "'Hook function must be an operation.'"] });
+        const operation = Operation2.deserialize(record);
+        yield* invoke(operation, {
+          ...hook.input
+        });
+      }).pipe(Effect9.catchAllCause((cause) => Effect9.sync(() => log5.warn("skill hook failed", {
+        phase,
+        skill: Skill2.getKey(skill),
+        cause
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 35, S: this }))));
+    }
+  }
+});
+
 // src/session/AiSession.ts
-var __dxlog_file6 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/AiSession.ts";
+var __dxlog_file7 = "/__w/dxos/dxos/packages/core/compute/assistant/src/session/AiSession.ts";
 var SUMMARY_THRESHOLD = 8e4;
 var Session = class extends Resource2 {
   /**
-  * Blueprints and objects bound to the session.
+  * Skills and objects bound to the session.
   */
   _binder;
   _feed;
@@ -1633,8 +1787,8 @@ var Session = class extends Resource2 {
     super();
     this._feed = options.feed;
     this._runtime = options.runtime;
-    invariant2(this._feed, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 45, S: this, A: ["this._feed", ""] });
-    invariant2(this._runtime, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 46, S: this, A: ["this._runtime", ""] });
+    invariant3(this._feed, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 45, S: this, A: ["this._feed", ""] });
+    invariant3(this._runtime, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 46, S: this, A: ["this._runtime", ""] });
     this._binder = new Binder({
       feed: this._feed,
       runtime: this._runtime,
@@ -1651,134 +1805,116 @@ var Session = class extends Resource2 {
     return this._binder;
   }
   async getHistory() {
-    const queryResult = await Runtime2.runPromise(this._runtime)(Feed4.query(this._feed, Filter3.type(Message5.Message)));
+    const queryResult = await Runtime2.runPromise(this._runtime)(Feed5.query(this._feed, Filter4.type(Message6.Message)));
     const items = await queryResult.run();
-    const messages = items.filter(Obj9.instanceOf(Message5.Message));
+    const messages = items.filter(Obj10.instanceOf(Message6.Message));
     return Runtime2.runPromise(this._runtime)(this._sessionLoader.reifyHistory(this._feed, messages));
   }
   getTools() {
-    return Effect9.gen(this, function* () {
+    return Effect10.gen(this, function* () {
       const toolkit = yield* createToolkit({
-        blueprints: this.context.getBlueprints()
+        skills: this.context.getSkills()
       });
       return toolkit.toolkit.tools;
-    }).pipe(Effect9.orDie);
+    }).pipe(Effect10.orDie);
   }
   /**
   * Not provided by default, since users might want to override them.
   */
   makeToolExecutionServices() {
-    return ToolExecutionServices.pipe(Layer3.provide(Operation2.withInvocationOptions({
-      conversation: Obj9.getURI(this._feed)
+    return ToolExecutionServices.pipe(Layer4.provide(Operation3.withInvocationOptions({
+      conversation: Obj10.getURI(this._feed)
     })));
   }
   /**
   * Creates a new cancelable request effect.
   */
   createRequest(params) {
-    return Effect9.gen(this, function* () {
-      const history = yield* Effect9.promise(() => this.getHistory());
-      const blueprints = this.context.getBlueprints();
+    return Effect10.gen(this, function* () {
+      const history2 = yield* Effect10.promise(() => this.getHistory());
+      const skills = this.context.getSkills();
       const objects = this.context.getObjects();
-      log5("run", {
-        history: history.length,
-        blueprints: blueprints.length,
+      log6("run", {
+        history: history2.length,
+        skills: skills.length,
         objects: objects.length
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 90, S: this });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 90, S: this });
       const request = new AiRequest_exports.Request({
         summarizationThreshold: SUMMARY_THRESHOLD,
         observer: params.observer,
         persist: params.persist,
-        onOutput: (message) => Effect9.promise(() => Runtime2.runPromise(this._runtime)(Feed4.append(this._feed, [
+        onOutput: (message) => Effect10.promise(() => Runtime2.runPromise(this._runtime)(Feed5.append(this._feed, [
           message
         ])))
       });
       yield* request.begin({
-        history,
-        blueprints,
+        history: history2,
+        skills,
         objects,
         prompt: params.prompt,
         system: params.system
       });
+      yield* runHooks({
+        skills,
+        phase: "begin-request",
+        invoke: (operation, input) => Operation3.invoke(operation, input).pipe(Effect10.asVoid, Effect10.orDie)
+      });
       do {
-        yield* Effect9.promise(() => this.context.sync());
-        const currentBlueprints = this.context.getBlueprints();
-        const mcps = yield* connectMcpServers(currentBlueprints, params.mcpServers);
+        yield* Effect10.promise(() => this.context.sync());
+        const currentSkills = this.context.getSkills();
+        const mcps = yield* connectMcpServers(currentSkills, params.mcpServers);
         const toolkit = yield* createToolkit({
           toolkit: params.toolkit,
-          blueprints: currentBlueprints,
+          skills: currentSkills,
           opaqueToolkits: mcps
         });
-        log5("toolkit", {
+        log6("toolkit", {
           tools: Record2.keys(toolkit.toolkit.tools)
-        }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 120, S: this });
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 127, S: this });
         const system = yield* formatSystemPrompt({
           system: params.system,
-          blueprints: currentBlueprints,
+          skills: currentSkills,
           objects: this.context.getObjects()
-        }).pipe(Effect9.orDie);
-        const { done } = yield* request.runAgentTurn({
+        }).pipe(Effect10.orDie);
+        const { done, finishReason } = yield* request.runAgentTurn({
           system,
           toolkit
         });
         if (done) {
           break;
         }
+        if (finishReason === "pause") {
+          continue;
+        }
         yield* request.runTools({
           toolkit
         });
       } while (true);
-      log5("result", {
+      log6("result", {
         messages: request.pending.length,
         duration: request.duration,
         toolCalls: request.toolCalls
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 139, S: this });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 151, S: this });
       return [
         ...request.pending
       ];
-    }).pipe(Effect9.provide(Layer3.mergeAll(Layer3.succeed(Service, {
-      binder: this.context
-    }), Layer3.succeed(Service2, this), Operation2.withInvocationOptions({
-      conversation: Obj9.getURI(this._feed)
-    }))), Effect9.withSpan("AiSession.createRequest"));
+    }).pipe(Effect10.provide(Layer4.mergeAll(
+      // Tier A only: the agent's own turn fiber has no `ProcessManager.Service` in scope, so
+      // Tier B (setAlarm/enqueueMessage) is reachable only by child operations through the
+      // process-affinity HarnessService LayerSpec — not from here.
+      Layer4.succeed(HarnessService, fromBinder({
+        feed: this._feed,
+        runtime: this._runtime,
+        binder: this.context
+      })),
+      Operation3.withInvocationOptions({
+        conversation: Obj10.getURI(this._feed)
+      })
+    )), Effect10.withSpan("AiSession.createRequest"));
   }
 };
-var Service2 = class _Service extends Context4.Tag("@dxos/assistant/AiSessionService")() {
-  /**
-  * Create a new session layer from options.
-  */
-  static layer = (options) => aiContextFromSession.pipe(Layer3.provideMerge(Layer3.scoped(_Service, Effect9.gen(function* () {
-    const session = yield* EffectEx.acquireReleaseResource(() => new Session(options));
-    return session;
-  }))));
-  /**
-  * Create a new session with a new feed.
-  */
-  static layerNewFeed = (options) => Layer3.unwrapScoped(Effect9.gen(function* () {
-    const feed = yield* Database2.add(Feed4.make());
-    const runtime2 = yield* Effect9.runtime();
-    return _Service.layer({
-      ...options,
-      feed,
-      runtime: runtime2
-    });
-  }));
-  /**
-  * Run a prompt in the current session.
-  */
-  static run = (params) => Effect9.gen(function* () {
-    const session = yield* _Service;
-    return yield* session.createRequest(params);
-  });
-};
-var aiContextFromSession = Layer3.effect(Service, Effect9.gen(function* () {
-  const session = yield* Service2;
-  return {
-    binder: session.context
-  };
-}));
-var connectMcpServers = (blueprints, spaceMcpServers = []) => {
-  const blueprintServers = pipe4(blueprints, Array4.flatMap((_) => _.mcpServers ?? []), Array4.map(({ url, protocol, apiKey }) => ({
+var connectMcpServers = (skills, spaceMcpServers = []) => {
+  const skillServers = pipe4(skills, Array4.flatMap((_) => _.mcpServers ?? []), Array4.map(({ url, protocol, apiKey }) => ({
     url,
     protocol,
     apiKey
@@ -1789,22 +1925,22 @@ var connectMcpServers = (blueprints, spaceMcpServers = []) => {
     apiKey
   }));
   const allServers = [
-    ...blueprintServers,
+    ...skillServers,
     ...spaceServers
   ];
-  return pipe4(allServers, Effect9.forEach((options) => McpToolkit.make(options).pipe(
+  return pipe4(allServers, Effect10.forEach((options) => McpToolkit.make(options).pipe(
     // NOTE: Type-inference fails here without explicit void return.
-    Effect9.tap((toolkit) => log5.info("Connected to MCP server", {
+    Effect10.tap((toolkit) => log6.info("Connected to MCP server", {
       url: options.url,
       tools: Object.keys(toolkit.toolkit.tools).length
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 203, S: void 0 })),
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 187, S: void 0 })),
     // Surface typed connection failures via ephemeral trace + warn log, then drop the server.
-    Effect9.tapError((error) => Effect9.gen(function* () {
-      log5.warn("Failed to connect to MCP server", {
+    Effect10.tapError((error) => Effect10.gen(function* () {
+      log6.warn("Failed to connect to MCP server", {
         url: error.url,
         protocol: error.protocol,
         message: error.message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 208, S: this });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 192, S: this });
       yield* Trace3.write(McpServerError, {
         url: error.url,
         protocol: error.protocol,
@@ -1813,36 +1949,54 @@ var connectMcpServers = (blueprints, spaceMcpServers = []) => {
     })),
     // Catch unexpected defects too (e.g. malformed tool schemas) so a single broken
     // server can never abort the whole turn — surface them through the same channel.
-    Effect9.catchAllDefect((defect) => Effect9.gen(function* () {
+    Effect10.catchAllDefect((defect) => Effect10.gen(function* () {
       const message = defect instanceof Error ? defect.message : String(defect);
-      log5.warn("Unexpected MCP defect", {
+      log6.warn("Unexpected MCP defect", {
         url: options.url,
         message
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 222, S: this });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 206, S: this });
       yield* Trace3.write(McpServerError, {
         url: options.url,
         protocol: options.protocol,
         message: `Unexpected MCP failure: ${message}`
       });
-      return yield* Effect9.fail(new McpToolkit.McpConnectionError({
+      return yield* Effect10.fail(new McpToolkit.McpConnectionError({
         url: options.url,
         protocol: options.protocol,
         message
       }));
     })),
-    Effect9.either
-  )), Effect9.map(Array4.filterMap((_) => Either.getRight(_))));
+    Effect10.either
+  )), Effect10.map(Array4.filterMap((_) => Either.getRight(_))));
 };
 
+// src/session/harness-control.ts
+import * as Rpc from "@effect/rpc/Rpc";
+import * as RpcGroup from "@effect/rpc/RpcGroup";
+import * as Schema7 from "effect/Schema";
+import { ContentBlock as ContentBlock4 } from "@dxos/types";
+var HarnessControl = RpcGroup.make(Rpc.make("setAlarm", {
+  payload: Schema7.Struct({
+    at: Schema7.DateTimeUtc,
+    message: Schema7.NullOr(Schema7.String)
+  }),
+  success: Schema7.Void
+}), Rpc.make("enqueueMessage", {
+  payload: Schema7.Struct({
+    content: Schema7.Array(ContentBlock4.Any)
+  }),
+  success: Schema7.Void
+}));
+
 // src/templates/system.ts
 import defaultsDeep from "lodash.defaultsdeep";
 import { Template as Template2 } from "@dxos/compute";
 
 // raw-loader:/__w/dxos/dxos/packages/core/compute/assistant/src/templates/instructions/format.tpl
-var format_default = "{{! System Core }}\n\n## Input Formats\n\n### Blueprints\n\nYou may be provided with Blueprint definitions that include specific instructions and tools for a given set of tasks.\nBlue print instructions will be enclosed in a <blueprint> tag.\n\n### Context objects\n\nYou may be provided with references to objects that are relevant to the current prompt.\nObjects will be in the form of a <object> tag with a <dxn> element that is the unique key of the object required by many tools.\nThe <typename> element is the type of the object.\n\n<object>\n  <dxn>object-id</dxn>\n  <typename>example.com/type/TypeName</typename>\n</object>\n\n## Response Formats\n\nIt is very important to respond in the correct format.\nYou response must be valid Markdown.\nIn some cases you should respond with well-formed XML tags along with the content.\nCode snippets should use 2-space indents.\n\n{{#if cot}}\nBefore responding, explain your reasoning and include your detailed chain-of-thought enclosed in a <cot> tag.\nThe <cot> tag should be the first thing in your response.\n{{/if}}\n\n## Block references\n\nYou can reply with a block reference for objects if you have the DXN. For example:\n\n<object>\n  <dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n<object>\n  <dxn>dxn:echo:@:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n\n### Suggestions\n\nEach suggestion must in the form of a proposed action enclosed in a <suggestion> tag.\nExample: <suggestion>Show on a map</suggestion>\nDo not use bullets when listing suggestions.\n\n### Multiple choice questions\n\nYou may ask multiple choice questions by wrapping consise options inside <option> tags inside a well formed <select> tag.\nExample: <select><option>Yes</option><option>No</option></select>\n\n## Context\n\nThe current date and time is {{DATETIME}}.\n";
+var format_default = "{{! System Core }}\n\n## Input Formats\n\n### Skills\n\nYou may be provided with Skill definitions that include specific instructions and tools for a given set of tasks.\nBlue print instructions will be enclosed in a <skill> tag.\n\n### Context objects\n\nYou may be provided with references to objects that are relevant to the current prompt.\nObjects will be in the form of a <object> tag with a <dxn> element that is the unique key of the object required by many tools.\nThe <typename> element is the type of the object.\n\n<object>\n  <dxn>object-id</dxn>\n  <typename>example.com/type/TypeName</typename>\n</object>\n\n## Response Formats\n\nIt is very important to respond in the correct format.\nYou response must be valid Markdown.\nIn some cases you should respond with well-formed XML tags along with the content.\nCode snippets should use 2-space indents.\n\n{{#if cot}}\nBefore responding, explain your reasoning and include your detailed chain-of-thought enclosed in a <cot> tag.\nThe <cot> tag should be the first thing in your response.\n{{/if}}\n\n## Block references\n\nYou can reply with a block reference for objects if you have the DXN. For example:\n\n<object>\n  <dxn>dxn:queue:data:B6INSIBY3CBEF4M5VZRYBCMAHQMPYK5AJ:01K24XMVHSZHS97SG1VTVQDM5Z:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n<object>\n  <dxn>dxn:echo:@:01K24XPK464FSCKVQJAB2H662M</dxn>\n</object>\n\n### Suggestions\n\nEach suggestion must in the form of a proposed action enclosed in a <suggestion> tag.\nExample: <suggestion>Show on a map</suggestion>\nDo not use bullets when listing suggestions.\n\n### Multiple choice questions\n\nYou may ask multiple choice questions by wrapping consise options inside <option> tags inside a well formed <select> tag.\nExample: <select><option>Yes</option><option>No</option></select>\n\n## Context\n\nThe current date and time is {{DATETIME}}.\n";
 
 // raw-loader:/__w/dxos/dxos/packages/core/compute/assistant/src/templates/instructions/system.tpl
-var system_default = "{{! System Prompt }}\n\n- You are a helpful assistant called Kai. \n- Your name is Kai and you are powered by different language models.\n- You were created by DXOS and operate inside of Composer and on the DXOS EDGE network.\n- In your initial greeting state your name and make some suggestions based on the current context objects.\n- You are an advanced AI assistant capable of creating and managing artifacts from provided data and tools.\n- Your task is to process user commands and questions and decide how best to respond.\n- In general be concise and direct.\n- Follow all instructions carefully.\n\n## Planning\n\n- Analyze the structure and type of the content in the user's message.\n- Determine if you complete the task using the available blueprint definitions?\n- If you can't complete the task using the available blueprint definitions, query the list of available blueprint definitions using the appropriate tool.\n- Identify which blueprint definitions are relevant to the user's request.\n- Evaluate the potential benefits of creating an artifact vs. normal processing for each identified element.\n- Make a final decision on whether to create an artifact and explain your reasoning.\n- Are the required blueprint definitions already available?\n- If not, select which blueprint definition(s) will be the most relevant and require them using the require_artifact_definitions tool.\n- The require'd artifact tools will be available for use after require.\n- If creating an artifact, outline how you will structure it within the response.\n- Decide if the artifact needs to be shown to the user.\n- Call the show tool to show the artifact to the user.\n- Your reasoning must include: whether to use artifacts or not, to create one or query, whether to show the artifact to the user, and how to structure the response.\n\n## Blueprints and Artifacts\n\n- Determine if the interaction involves an artifact. Prefer artifacts for tables, lists, spreadsheets, kanbans, games, images, and other structured data.\n- Determine if the user is explicitly talking about creating a new artifact, or wants to use an existing artifact.\n- If it is ambiguous, query for existing artifacts first and then decide.\n- If you decide to create an artifact, call the associated tool to create the artifact.\n- Artifacts are stored in the database. Tools are used to create and query artifacts.\n- If you are unsure about creating an artifact ask the user for clarification.\n- Artifacts are mutable objects that can change over the course of the conversation.\n- Always re-query the artifact using the tool (like query or inspect) to get the latest state of the artifact before answering the user.\n- You must never generate the id of the artifact; only recall the ids that are already in the history.\n- Artifacts are created by requiring the specific artifact using the require_artifact tool and creating it by calling the associated tool.\n- You can add suggested actions at the end of your response.\n- Suggested actions should be very concise and start with a verb and be phrased as a command to an agent -- not a question to the user.\n- Suggested actions must be in the form of a user instruction that you can follow.\n- Suggested actions could include actions that create artifacts.\n- After creating an artifact use a tool to add it to the chat context.\n\n## Navigation\n\n- When the user asks to open, go to, navigate to, or show a specific document, page, or object, use the navigation tools instead of loading content inline.\n- First, call the Resolve navigation targets tool to find the navigation path for the requested item.\n  - Without arguments, it returns available pages that can be navigated to.\n  - With a DXN in the query, it resolves that specific object to a navigation path.\n- If you know the object's DXN (e.g. from a database query or context objects), pass it in the query to get the exact navigation path.\n- Then, call the Open tool with the resolved navigation path(s) in the subject array to navigate the user to that item.\n- Do not respond with the document's content when the user asks to open it \u2014 open it in the main content area instead.\n- If multiple targets match, present the options to the user and let them choose which to open.\n\n## Response format\n\n- NEVER output narration text outside `<status>` tags or the final user-facing answer. Any progress update, transition sentence, or \"let me\u2026\" lead-in MUST be wrapped in `<status>...</status>`. Violating this is an error.\n- When updating the user about the progress of the work you are doing, put the update in a <status> XML tag.\n- Only when you need to show the result to the user or ask a question use a text block without status tags.\n- After a `</status>` tag, the next output must be either another `<status>` tag, a tool call, or the final user-facing answer \u2014 never a transition sentence.\n\n<example>\n// reasoning...\n<status>Looking for emails from Depot</status>\n// tool call..\n<status>Found 2 emails from Depot.</status>\n<status>Loading email details</status>\n// tool call\n<status>Located mailbox</status>\nI found **2 emails from Depot**:\n</example>\n\nDo not do (no status tags):\n\n<incorrect_example>\n// reasoning...\n// tool call..\nI found 2 emails from Depot. Let me load their details:\n// tool call\nI found **2 emails from Depot**:\n</incorrect_example>\n\nDo not do (transition sentence after a status tag, before tool calls):\n\n<incorrect_example>\n<status>Doing X</status>\nLet me start by doing X:\n// tool call\n</incorrect_example>\n\n- NEVER write a lead-in sentence before a tool call. Use a `<status>` tag instead.\n- Avoid using plain text to tell the user what you are about to do; instead, use status blocks.\n- WRONG: Let me get...\n- CORRECT: <status>Getting...</status>";
+var system_default = "{{! System Prompt }}\n\n- You are a helpful assistant called Kai. \n- Your name is Kai and you are powered by different language models.\n- You were created by DXOS and operate inside of Composer and on the DXOS EDGE network.\n- In your initial greeting state your name and make some suggestions based on the current context objects.\n- You are an advanced AI assistant capable of creating and managing artifacts from provided data and tools.\n- Your task is to process user commands and questions and decide how best to respond.\n- In general be concise and direct.\n- Follow all instructions carefully.\n\n## Planning\n\n- Analyze the structure and type of the content in the user's message.\n- Determine if you complete the task using the available skill definitions?\n- If you can't complete the task using the available skill definitions, query the list of available skill definitions using the appropriate tool.\n- Identify which skill definitions are relevant to the user's request.\n- Evaluate the potential benefits of creating an artifact vs. normal processing for each identified element.\n- Make a final decision on whether to create an artifact and explain your reasoning.\n- Are the required skill definitions already available?\n- If not, select which skill definition(s) will be the most relevant and require them using the require_artifact_definitions tool.\n- The require'd artifact tools will be available for use after require.\n- If creating an artifact, outline how you will structure it within the response.\n- Decide if the artifact needs to be shown to the user.\n- Call the show tool to show the artifact to the user.\n- Your reasoning must include: whether to use artifacts or not, to create one or query, whether to show the artifact to the user, and how to structure the response.\n\n## Skills and Artifacts\n\n- Determine if the interaction involves an artifact. Prefer artifacts for tables, lists, spreadsheets, kanbans, games, images, and other structured data.\n- Determine if the user is explicitly talking about creating a new artifact, or wants to use an existing artifact.\n- If it is ambiguous, query for existing artifacts first and then decide.\n- If you decide to create an artifact, call the associated tool to create the artifact.\n- Artifacts are stored in the database. Tools are used to create and query artifacts.\n- If you are unsure about creating an artifact ask the user for clarification.\n- Artifacts are mutable objects that can change over the course of the conversation.\n- Always re-query the artifact using the tool (like query or inspect) to get the latest state of the artifact before answering the user.\n- You must never generate the id of the artifact; only recall the ids that are already in the history.\n- Artifacts are created by requiring the specific artifact using the require_artifact tool and creating it by calling the associated tool.\n- You can add suggested actions at the end of your response.\n- Suggested actions should be very concise and start with a verb and be phrased as a command to an agent -- not a question to the user.\n- Suggested actions must be in the form of a user instruction that you can follow.\n- Suggested actions could include actions that create artifacts.\n- After creating an artifact use a tool to add it to the chat context.\n\n## Navigation\n\n- When the user asks to open, go to, navigate to, or show a specific document, page, or object, use the navigation tools instead of loading content inline. Navigation is always two steps: first resolve a navigation path with Resolve navigation targets, then open that path with Open.\n- The Open tool accepts navigation **paths** only. Never pass an object DXN, URI, or id to Open \u2014 pass only a `path` returned by Resolve navigation targets. Passing anything else will fail to navigate.\n- To open a specific object: call Resolve navigation targets with the object's URI in the `query.uri` field \u2014 use the value from the object's `<dxn>` tag in context (which may be an `echo:` EID or a `dxn:` DXN), then pass the returned target's `path` to Open.\n- To navigate to a page (not a specific object): call Resolve navigation targets without arguments to list the available pages, then pass the chosen target's `path` to Open.\n- Do not respond with the document's content when the user asks to open it \u2014 open it in the main content area instead.\n- If multiple targets match, present the options to the user and let them choose which to open.\n\n## Response format\n\n- NEVER output narration text outside `<status>` tags or the final user-facing answer. Any progress update, transition sentence, or \"let me\u2026\" lead-in MUST be wrapped in `<status>...</status>`. Violating this is an error.\n- When updating the user about the progress of the work you are doing, put the update in a <status> XML tag.\n- Only when you need to show the result to the user or ask a question use a text block without status tags.\n- After a `</status>` tag, the next output must be either another `<status>` tag, a tool call, or the final user-facing answer \u2014 never a transition sentence.\n\n<example>\n// reasoning...\n<status>Looking for emails from Depot</status>\n// tool call..\n<status>Found 2 emails from Depot.</status>\n<status>Loading email details</status>\n// tool call\n<status>Located mailbox</status>\nI found **2 emails from Depot**:\n</example>\n\nDo not do (no status tags):\n\n<incorrect_example>\n// reasoning...\n// tool call..\nI found 2 emails from Depot. Let me load their details:\n// tool call\nI found **2 emails from Depot**:\n</incorrect_example>\n\nDo not do (transition sentence after a status tag, before tool calls):\n\n<incorrect_example>\n<status>Doing X</status>\nLet me start by doing X:\n// tool call\n</incorrect_example>\n\n- NEVER write a lead-in sentence before a tool call. Use a `<status>` tag instead.\n- Avoid using plain text to tell the user what you are about to do; instead, use status blocks.\n- WRONG: Let me get...\n- CORRECT: <status>Getting...</status>";
 
 // src/templates/system.ts
 var createSystemPrompt = (options = {}) => Template2.process(format_default, defaultsDeep(options, {
@@ -1866,11 +2020,14 @@ export {
   CompleteBlock,
   ExecutionGraph,
   GenerationObserver,
+  Harness_exports as Harness,
+  HarnessControl,
   McpServerError,
   PartialBlock,
   RefFromLLM,
   SessionLink_exports as SessionLink,
   SessionLoader,
+  SkillHooks_exports as SkillHooks,
   ToolExecutionServices,
   applyDiffs,
   computeDiffsWithCursors,