@xandreed/core 0.13.0 → 0.14.0

package/dist/memory/memory-log.entity.functions.js

@@ -1,5 +1,8 @@
 import { Effect, Option, Schema } from "effect";
+import { elideMediaData, IMAGE_TOKEN_ESTIMATE, mediaAt, mediaLabel, mediaSlotsOf } from "../domain/media.entity.functions.js";
+import { MEDIA_LIMITS } from "../domain/media.entity.js";
 import { handoffToMessage } from "../loop/mapping.js";
+import { attachmentsOf, userMessageText } from "../turn/user-message.entity.functions.js";
 import { EntryId as EntryIdSchema } from "./memory-log.entity.js";
 export const canonicalJson = (value) => JSON.stringify(sortKeys(value)) ?? "null";
 const sortKeys = (value) => Array.isArray(value) ? value.map(sortKeys) : typeof value === "object" && value !== null ? Object.fromEntries(Object.keys(value).sort().flatMap((key) => {
@@ -8,11 +11,15 @@ const sortKeys = (value) => Array.isArray(value) ? value.map(sortKeys) : typeof
 })) : value;
 export const fingerprintOf = (text) => {
   return `${Array.from(text).reduce((h, ch) => Math.imul((h ^ ch.charCodeAt(0)) >>> 0, 16777619) >>> 0, 2166136261).toString(16).padStart(8, "0")}${text.length.toString(16)}`;
-}, estimateTokens = (text) => Math.ceil(text.length / 3), estimateMessageTokens = (messages) => messages.reduce((sum, message) => sum + estimateTokens(canonicalJson(message)), 0), entryId = (runId, index) => EntryIdSchema.make(`${runId}:${index}`);
+}, estimateTokens = (text) => Math.ceil(text.length / 3), estimateMessageTokens = (messages) => messages.reduce((sum, message) => sum + estimateTokens(canonicalJson(elideMediaData(message))) + mediaSlotsOf(message).length * IMAGE_TOKEN_ESTIMATE, 0), entryId = (runId, index) => EntryIdSchema.make(`${runId}:${index}`);
 const digestsOf = (entries) => new Map(entries.flatMap((entry) => entry.body._tag === "ToolDigest" ? [[String(entry.body.entry), entry.body.text]] : [])), appliedCompactions = (entries, strategy) => entries.reduce((applied, entry) => {
-  if (entry.body._tag !== "Compaction" || entry.body.strategy !== strategy)
+  if (entry.body._tag !== "Compaction")
     return applied;
   const action = entry.body.action, ids = [...applied.ids, entry.id];
+  if (action._tag === "OmitMedia")
+    return { ...applied, ids, omitted: new Set([...applied.omitted, ...action.entries.map(String)]) };
+  if (entry.body.strategy !== strategy)
+    return applied;
   if (action._tag === "CompactViews")
     return { ...applied, ids, views: new Map([...applied.views, ...action.entries.map((id, index) => [id, action.texts[index] ?? ""])]) };
   if (action._tag === "Spill")
@@ -32,7 +39,7 @@ ${action.ledger}` })
     cutTurn: action.keepFromTurn - 1,
     preamble: Option.some(handoffToMessage(action.summary))
   };
-}, { views: new Map, cutTurn: 0, preamble: Option.none(), ids: [] }), toolCallIds = (message) => message.role === "assistant" ? message.content.flatMap((part) => part.type === "tool-call" ? [part.toolCallId] : []) : [], assistantText = (message) => {
+}, { views: new Map, cutTurn: 0, preamble: Option.none(), ids: [], omitted: new Set }), toolCallIds = (message) => message.role === "assistant" ? message.content.flatMap((part) => part.type === "tool-call" ? [part.toolCallId] : []) : [], assistantText = (message) => {
   if (message.role !== "assistant")
     return Option.none();
   const text = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
@@ -53,12 +60,47 @@ export const artifactLines = (artifacts, maxImages) => {
   ].join(`
 `);
 };
-const userRoleMessage = (content) => ({ role: "user", content }), assistantMessage = (text) => ({ role: "assistant", content: [{ type: "text", text }] });
+const userRoleMessage = (content) => ({ role: "user", content }), assistantMessage = (text) => ({ role: "assistant", content: [{ type: "text", text }] }), imageKey = (entry, index) => `${entry.id}#${index}`, noneChosen = { chosen: new Set, images: 0, chars: 0, full: !1 }, charsOf = (images) => images.reduce((sum, image) => sum + image.media.data.length, 0), mediaPlan = (entries, options) => {
+  const applied = appliedCompactions(entries, options.strategy), digests = options.digests ? digestsOf(entries) : new Map, kept = (entry) => entry.turn > applied.cutTurn, imagesOf = (entry) => {
+    const body = entry.body;
+    if (!kept(entry) || applied.omitted.has(entry.id))
+      return [];
+    if (body._tag === "TurnStarted")
+      return attachmentsOf(body.userMessage).map((media, index) => ({ key: imageKey(entry, index), media }));
+    if (body._tag !== "ToolResult" || body.isError || applied.views.has(entry.id) || digests.has(entry.id))
+      return [];
+    return (body.media ?? []).flatMap((slot, index) => Option.toArray(Option.map(mediaAt(body.encoded, slot), (media) => ({ key: imageKey(entry, index), media }))));
+  }, maxImages = Math.min(options.media.maxImages, MEDIA_LIMITS.requestImages), take = (choice, group) => choice.full ? choice : choice.images + group.length <= maxImages && choice.chars + charsOf(group) <= options.media.maxChars ? {
+    ...choice,
+    chosen: new Set([...choice.chosen, ...group.map((image) => image.key)]),
+    images: choice.images + group.length,
+    chars: choice.chars + charsOf(group)
+  } : { ...choice, full: !0 }, current = entries.filter((entry) => entry.turn === options.currentTurn), attachments = current.flatMap((entry) => entry.body._tag === "TurnStarted" ? imagesOf(entry).map((image) => [image]) : []), results = current.flatMap((entry) => entry.body._tag === "ToolResult" ? [imagesOf(entry)] : []).filter((group) => group.length > 0).reverse(), older = options.media.mode === "none" ? [] : entries.flatMap((entry) => entry.turn < options.currentTurn ? imagesOf(entry).map((image) => ({ turn: entry.turn, image })) : []), earlier = [...new Set(older.map((item) => item.turn))].sort((left, right) => right - left).map((turn) => older.filter((item) => item.turn === turn).map((item) => item.image)), inline = [...attachments, ...results, ...earlier].reduce(take, noneChosen).chosen;
+  return { applied, digests, kept, imagesOf, inline };
+}, userMessageContent = (entry, message, inline) => {
+  const images = attachmentsOf(message), sent = images.flatMap((media, index) => inline.has(imageKey(entry, index)) ? [media] : []);
+  if (sent.length === 0)
+    return userRoleMessage(userMessageText(message));
+  const text = [message.text, ...images.flatMap((media, index) => inline.has(imageKey(entry, index)) ? [] : [mediaLabel(media)])].filter((line) => line.length > 0).join(`
+`);
+  return { role: "user", content: [...sent, ...text.length === 0 ? [] : [{ type: "text", text }]] };
+}, toolResultPart = (entry, body, text, options, inline) => {
+  const images = (body.media ?? []).map((slot, index) => ({ key: imageKey(entry, index), slot, media: mediaAt(body.encoded, slot) })), sent = images.flatMap((image) => inline.has(image.key) ? Option.toArray(image.media) : []), labels = [...(body.mediaNotes ?? []).filter((line) => !text.includes(line)), ...images.flatMap((image) => inline.has(image.key) ? [] : [mediaLabel(Option.getOrElse(image.media, () => image.slot))])], shown = labels.length === 0 ? text : [text, ...labels].filter((line) => line.length > 0).join(`
+`);
+  return {
+    type: "tool-result",
+    toolCallId: body.toolCallId,
+    toolName: body.toolName,
+    output: `${shown}${artifactLines(body.artifacts, options.media.maxImages)}`,
+    isError: body.isError,
+    ...sent.length === 0 ? {} : { media: sent }
+  };
+};
 export const renderLog = (entries, options) => {
-  const applied = appliedCompactions(entries, options.strategy), digests = options.digests ? digestsOf(entries) : new Map, pinned = new Set(entries.flatMap((entry) => entry.body._tag === "ToolResult" && entry.body.pinned ? [String(entry.body.toolCallId)] : [])), kept = (entry) => entry.turn > applied.cutTurn, stepContext = options.stepContext === "none" ? [] : entries.filter((entry) => entry.body._tag === "StepContext" && entry.runId === options.currentRun).slice(-1), initial = { out: [], lastText: new Map }, body = entries.reduce((state, entry) => {
+  const { applied, digests, kept, inline } = mediaPlan(entries, options), pinned = new Set(entries.flatMap((entry) => entry.body._tag === "ToolResult" && entry.body.pinned ? [String(entry.body.toolCallId)] : [])), stepContext = options.stepContext === "none" ? [] : entries.filter((entry) => entry.body._tag === "StepContext" && entry.runId === options.currentRun).slice(-1), initial = { out: [], lastText: new Map }, body = entries.reduce((state, entry) => {
     const b = entry.body;
     if (b._tag === "TurnStarted")
-      return kept(entry) ? { ...state, out: [...state.out, userRoleMessage(b.userMessage.text)] } : state;
+      return kept(entry) ? { ...state, out: [...state.out, userMessageContent(entry, b.userMessage, inline)] } : state;
     if (b._tag === "TurnContext")
       return kept(entry) && (options.turnContext === "all" || entry.turn === options.currentTurn) ? { ...state, out: [...state.out, userRoleMessage(b.text)] } : state;
     if (b._tag === "Message") {
@@ -74,13 +116,7 @@ export const renderLog = (entries, options) => {
     if (b._tag === "ToolResult") {
       if (!kept(entry) && !b.pinned)
         return state;
-      const text = applied.views.get(entry.id) ?? digests.get(entry.id) ?? b.view, message = { role: "tool", content: [{
-        type: "tool-result",
-        toolCallId: b.toolCallId,
-        toolName: b.toolName,
-        output: `${text}${artifactLines(b.artifacts, options.media.maxImages)}`,
-        isError: b.isError
-      }] };
+      const text = applied.views.get(entry.id) ?? digests.get(entry.id) ?? b.view, message = { role: "tool", content: [toolResultPart(entry, b, text, options, inline)] };
       return { ...state, out: [...state.out, message] };
     }
     if (b._tag === "TurnEnded" && options.replies && kept(entry))
@@ -91,11 +127,14 @@ export const renderLog = (entries, options) => {
     return state;
   }, initial).out, tail = stepContext.flatMap((entry) => entry.body._tag === "StepContext" ? [userRoleMessage(entry.body.text)] : []);
   return mergeToolMessages([...Option.toArray(applied.preamble), ...body, ...tail]);
+}, entriesSendingMedia = (entries, options) => {
+  const { imagesOf, inline } = mediaPlan(entries, options);
+  return entries.flatMap((entry) => imagesOf(entry).some((image) => inline.has(image.key)) ? [entry.id] : []);
 }, buildContext = (entries, options) => {
   const messages = renderLog(entries, options);
   return {
     messages,
-    fingerprint: fingerprintOf(canonicalJson(messages)),
+    fingerprint: fingerprintOf(canonicalJson(messages.map(elideMediaData))),
     estimatedTokens: estimateMessageTokens(messages),
     compactions: appliedCompactions(entries, options.strategy).ids,
     through: Option.fromNullishOr(entries.at(-1)?.id)
@@ -108,17 +147,17 @@ export const renderLog = (entries, options) => {
   tools: [...active.tools, ...entry.body.tools.filter((tool) => !active.tools.includes(tool))]
 }, { skills: [], tools: [] }), referenceTranscript = (entries) => entries.flatMap((entry) => {
   if (entry.body._tag === "TurnStarted")
-    return [userRoleMessage(entry.body.userMessage.text)];
+    return [userRoleMessage(userMessageText(entry.body.userMessage))];
   if (entry.body._tag === "TurnEnded")
     return Option.match(entry.body.reply, { onNone: () => [], onSome: (text) => text.length === 0 ? [] : [{ role: "assistant", content: [{ type: "text", text }] }] });
   return [];
 }), rawTranscript = (entries) => mergeToolMessages(entries.flatMap((entry) => {
   if (entry.body._tag === "TurnStarted")
-    return [userRoleMessage(entry.body.userMessage.text)];
+    return [userRoleMessage(userMessageText(entry.body.userMessage))];
   if (entry.body._tag === "Message")
     return [entry.body.message];
   if (entry.body._tag === "ToolResult")
-    return [{ role: "tool", content: [{ type: "tool-result", toolCallId: entry.body.toolCallId, toolName: entry.body.toolName, output: entry.body.encoded, isError: entry.body.isError }] }];
+    return [{ role: "tool", content: [{ type: "tool-result", toolCallId: entry.body.toolCallId, toolName: entry.body.toolName, output: elideMediaData(entry.body.encoded), isError: entry.body.isError }] }];
   return [];
 })), emptyQuery = {
   kinds: [],
@@ -131,7 +170,7 @@ export const renderLog = (entries, options) => {
   const matches = entries.filter((entry) => (query.kinds.length === 0 || query.kinds.includes(entry.body._tag)) && Option.match(query.turns, { onNone: () => !0, onSome: (range) => entry.turn >= range.from && entry.turn <= range.to }) && Option.match(query.tool, { onNone: () => !0, onSome: (tool) => entry.body._tag === "ToolResult" && entry.body.toolName === tool }) && Option.match(query.subject, {
     onNone: () => !0,
     onSome: (wanted) => entry.body._tag === "ToolResult" && entry.body.subjects.some((subject) => subject.kind === wanted.kind && Option.match(wanted.id, { onNone: () => !0, onSome: (id) => subject.id === id }))
-  }) && Option.match(query.text, { onNone: () => !0, onSome: (text) => canonicalJson(entry.body).toLowerCase().includes(text.toLowerCase()) }));
+  }) && Option.match(query.text, { onNone: () => !0, onSome: (text) => canonicalJson(elideMediaData(entry.body)).toLowerCase().includes(text.toLowerCase()) }));
   return Option.match(query.limit, { onNone: () => matches, onSome: (limit) => matches.slice(-limit) });
 }, toolInputsOf = (entries, tail) => new Map([
   ...entries.flatMap((entry) => entry.body._tag === "Message" ? [entry.body.message] : []),
@@ -149,7 +188,7 @@ export const digestTranscript = (entries, caps) => {
   const lines = entries.flatMap((entry) => {
     const body = entry.body;
     if (body._tag === "TurnStarted")
-      return [`User: ${body.userMessage.text}`];
+      return [`User: ${userMessageText(body.userMessage)}`];
     if (body._tag === "Message")
       return Option.toArray(Option.map(assistantText(body.message), (text) => `Assistant: ${text}`));
     if (body._tag === "ToolResult")
@@ -168,7 +207,7 @@ ${lines.slice(1).join(`
 `).slice(-(caps.total - head.length))}`;
 }, ledgerOf = (entries, throughTurn, perTurnChars) => {
   const kept = entries.filter((entry) => entry.turn <= throughTurn), lines = [...new Set(kept.map((entry) => entry.turn))].sort((left, right) => left - right).flatMap((turn) => {
-    const inTurn = kept.filter((entry) => entry.turn === turn), asked = inTurn.flatMap((entry) => entry.body._tag === "TurnStarted" ? [entry.body.userMessage.text] : []).at(0), reply = inTurn.flatMap((entry) => entry.body._tag === "TurnEnded" ? Option.toArray(entry.body.reply) : []).at(-1);
+    const inTurn = kept.filter((entry) => entry.turn === turn), asked = inTurn.flatMap((entry) => entry.body._tag === "TurnStarted" ? [userMessageText(entry.body.userMessage)] : []).at(0), reply = inTurn.flatMap((entry) => entry.body._tag === "TurnEnded" ? Option.toArray(entry.body.reply) : []).at(-1);
     return asked === void 0 ? [] : [`- Asked: ${clipText(asked, perTurnChars)}${reply === void 0 ? "" : ` \u2014 replied: ${clipText(reply, perTurnChars)}`}`];
   }), subjects = subjectsOf(kept, []).slice(-24).map((subject) => `${subject.kind} ${subject.id}${Option.match(subject.label, { onNone: () => "", onSome: (label) => ` (${label})` })}`);
   return [

package/dist/memory/memory-log.entity.js

@@ -1,7 +1,8 @@
-import { Schema } from "effect";
+import { Schema, SchemaTransformation } from "effect";
+import { Media, MediaSlot } from "../domain/media.entity.js";
 import { AgentMessage, ToolCallId } from "../domain/message.entity.js";
 import { DecisionId } from "../decision-record.entity.js";
-import { UserMessageFromString } from "../turn/user-message.entity.js";
+import { UserMessage } from "../turn/user-message.entity.js";
 export const EntryId = Schema.Trimmed.check(Schema.isNonEmpty()).pipe(Schema.brand("EntryId")), Subject = Schema.Struct({
   kind: Schema.Trimmed.check(Schema.isNonEmpty()),
   id: Schema.Trimmed.check(Schema.isNonEmpty()),
@@ -17,14 +18,24 @@ export const EntryId = Schema.Trimmed.check(Schema.isNonEmpty()).pipe(Schema.bra
   Schema.TaggedStruct("CompactViews", { entries: Schema.Array(EntryId), texts: Schema.Array(Schema.String) }),
   Schema.TaggedStruct("Spill", { entry: EntryId, preview: Schema.String }),
   Schema.TaggedStruct("DropTurns", { throughTurn: Schema.Int, ledger: Schema.String }),
-  Schema.TaggedStruct("Summarize", { keepFromTurn: Schema.Int, summary: Schema.String })
-]), ActivationSource = Schema.Literals(["always", "matcher", "load_skill", "host"]), LogBody = Schema.Union([
+  Schema.TaggedStruct("Summarize", { keepFromTurn: Schema.Int, summary: Schema.String }),
+  Schema.TaggedStruct("OmitMedia", { entries: Schema.Array(EntryId), reason: Schema.String })
+]), ActivationSource = Schema.Literals(["always", "matcher", "load_skill", "host"]);
+const StoredTurnStarted = Schema.Struct({
+  _tag: Schema.Literal("TurnStarted"),
+  prompt: Schema.String,
+  attachments: Schema.optionalKey(Schema.Array(Schema.toEncoded(Media)))
+});
+export const LogBody = Schema.Union([
   Schema.TaggedStruct("SystemPrepared", {
     fingerprint: Schema.String,
     text: Schema.String,
     sections: Schema.Array(Schema.Struct({ id: Schema.String, version: Schema.String, fingerprint: Schema.String }))
   }),
-  Schema.TaggedStruct("TurnStarted", { userMessage: UserMessageFromString }).pipe(Schema.encodeKeys({ userMessage: "prompt" })),
+  StoredTurnStarted.pipe(Schema.decodeTo(Schema.TaggedStruct("TurnStarted", { userMessage: UserMessage }), SchemaTransformation.transform({
+    decode: ({ prompt, attachments }) => ({ _tag: "TurnStarted", userMessage: attachments === void 0 ? { text: prompt } : { text: prompt, attachments } }),
+    encode: ({ userMessage }) => userMessage.attachments === void 0 ? { _tag: "TurnStarted", prompt: userMessage.text } : { _tag: "TurnStarted", prompt: userMessage.text, attachments: userMessage.attachments }
+  }))),
   Schema.TaggedStruct("TurnContext", { sectionId: Schema.String, version: Schema.String, text: Schema.String }),
   Schema.TaggedStruct("Message", { message: AgentMessage }),
   Schema.TaggedStruct("ToolResult", {
@@ -36,7 +47,9 @@ export const EntryId = Schema.Trimmed.check(Schema.isNonEmpty()).pipe(Schema.bra
     viewVersion: Schema.String,
     subjects: Schema.Array(Subject),
     artifacts: Schema.Array(ArtifactRef),
-    pinned: Schema.Boolean
+    pinned: Schema.Boolean,
+    media: Schema.optionalKey(Schema.Array(MediaSlot)),
+    mediaNotes: Schema.optionalKey(Schema.Array(Schema.String))
   }),
   Schema.TaggedStruct("ToolDigest", {
     entry: EntryId,

package/dist/memory/memory-session.js

@@ -1,4 +1,5 @@
 import { Clock, Effect, Option, Ref, Semaphore } from "effect";
+import { toolResultMedia } from "../domain/media.entity.functions.js";
 import { ResultDigester } from "../ports/memory.port.js";
 import {
   buildContext,
@@ -55,19 +56,22 @@ export const openLogSession = (log, policy, scope) => Effect.gen(function* () {
     })
   }))), recordTail = (tail, views, step) => Effect.gen(function* () {
     const inputs = toolInputsOf(yield* Ref.get(entries), tail), bodies = yield* Effect.forEach(tail, (message) => message.role !== "tool" ? Effect.succeed([{ _tag: "Message", message }]) : Effect.forEach(message.content, (part) => {
-      const params = inputs.get(String(part.toolCallId)) ?? {};
-      return views.view(part.toolName, part.output, params, part.isError ?? !1).pipe(Effect.map((view) => ({
+      const params = inputs.get(String(part.toolCallId)) ?? {}, isError = part.isError ?? !1;
+      return views.view(part.toolName, part.output, params, isError).pipe(Effect.flatMap((view) => toolResultMedia(part.output, isError ? [] : view.media ?? []).pipe(Effect.map((media) => ({
         _tag: "ToolResult",
         toolCallId: part.toolCallId,
         toolName: part.toolName,
-        isError: part.isError ?? !1,
+        isError,
         encoded: part.output,
-        view: view.text,
+        view: media.labels.length === 0 ? view.text : [view.text, ...media.labels].filter((line) => line.length > 0).join(`
+`),
         viewVersion: view.version,
         subjects: view.subjects,
         artifacts: view.artifacts,
-        pinned: view.pinned
-      })));
+        pinned: view.pinned,
+        ...media.slots.length === 0 ? {} : { media: media.slots },
+        ...media.labels.length === 0 ? {} : { mediaNotes: media.labels }
+      })))));
     })), recorded = yield* record(bodies.flat(), step), onWrite = policy.digestOnWrite, targets = Option.isNone(onWrite) ? [] : recorded.filter((entry) => entry.body._tag === "ToolResult" && onWrite.value({ tool: entry.body.toolName, chars: entry.body.view.length })), digests = yield* digest(targets, views, "write", step);
     return [...recorded, ...digests];
   }), maintain = (signal) => Effect.gen(function* () {

package/dist/memory/memory.conformance.d.ts

@@ -24,7 +24,14 @@ type Memory = Context.Service.Shape<typeof ConversationMemory>;
  * The ConversationMemory contract, as checks any strategy must pass: own
  * entry ids, a log that reads back exactly after a reopen, views and
  * artifacts kept, a pure build, the step context only when asked,
- * append-only maintenance and a reference transcript without tool traffic.
+ * append-only maintenance, a reference transcript without tool traffic, and
+ * a message's images kept through a reopen and built (never with an empty
+ * text part): the current turn's as image parts, an earlier turn's as image
+ * parts or label lines; a tool result's images stored once, kept through a
+ * reopen, and the current turn's built as the result's images. Those checks
+ * need a media budget that admits one small image, as the memory plugins'
+ * defaults do: a strategy set to send none (`maxImages: 0` or
+ * `maxChars: 0`) fails them, as it fails `turnConformance`'s.
  * `services` are the turn services the strategy needs (a summarizer…); each
  * session is opened with them provided.
  */

package/dist/memory/memory.conformance.js

@@ -1,5 +1,7 @@
 import { Context, Effect, Option, Ref, Schema } from "effect";
 import { ConformanceFailure } from "../conformance.entity.js";
+import { pixelPng } from "../conformance.functions.js";
+import { mediaFromBase64, mediaLabel, mediaSlotsOf } from "../domain/media.entity.functions.js";
 import { ConversationId, ToolCallId } from "../domain/message.entity.js";
 import { HarnessError } from "../harness/plugin.entity.js";
 import { draftOfEntry, entriesOfEvents, turnStartedDraft } from "../session/session-event.entity.functions.js";
@@ -92,6 +94,36 @@ export const memoryConformance = (memory, services = Context.empty()) => {
       const after = yield* session.entries;
       yield* expect("append-only", encodeEntries(after.slice(0, before.length)) === encodeEntries(before), "maintenance rewrote earlier entries");
     })),
+    check("a message's images survive a reopen; the current turn's are built as image parts, an earlier turn's as image parts or label lines", "attachments", (open, log) => Effect.gen(function* () {
+      const image = yield* mediaFromBase64(pixelPng, { name: "pixel.png" }).pipe(Effect.mapError((error) => new ConformanceFailure({ check: "attachments", message: error.message }))), session = yield* open(log, "run-1");
+      yield* session.record([{ _tag: "TurnStarted", userMessage: new UserMessage({ text: "what is this?", attachments: [image] }) }], 0);
+      yield* session.record([{ _tag: "TurnEnded", outcome: "completed", reply: Option.some("a pixel") }], 0);
+      const other = yield* open(log, "run-2");
+      yield* other.record([{ _tag: "TurnStarted", userMessage: new UserMessage({ text: "", attachments: [image] }) }], 0);
+      const reopened = yield* open(log, "run-2");
+      yield* expect("attachments", encodeEntries(yield* reopened.entries) === encodeEntries(yield* other.entries), "the reopened log lost or changed an image");
+      const users = (yield* reopened.build({ stepContext: "tail" })).messages.filter((message) => message.role === "user"), shown = users.map((message) => typeof message.content === "string" ? message.content.includes(mediaLabel(image)) ? "label" : "missing" : message.content.some((part) => part.type === "text" && part.text.length === 0) ? "empty text" : message.content.some((part) => part.type === "media" && part.fingerprint === image.fingerprint && part.data === image.data) ? "image" : "missing"), [earlier, current] = [shown[0] ?? "missing", shown[1] ?? "missing"];
+      yield* expect("attachments", shown.length === 2 && (earlier === "image" || earlier === "label") && current === "image", `the earlier message showed its image as ${earlier} (an image or its label line), the current turn's as ${current} (its image, with the same data)`);
+      const firstText = Option.match(Option.fromNullishOr(users[0]), {
+        onNone: () => "",
+        onSome: (message) => typeof message.content === "string" ? message.content : message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+`)
+      });
+      yield* expect("attachments", firstText.includes("what is this?"), "the first message lost its text");
+    })),
+    check("a tool result's images survive a reopen, stored once, and the current turn's reach the build as the result's images", "tool-media", (open, log) => Effect.gen(function* () {
+      const image = yield* mediaFromBase64(pixelPng, { name: "shot.png" }).pipe(Effect.mapError((error) => new ConformanceFailure({ check: "tool-media", message: error.message }))), imaging = { ...views, view: (_tool, encoded) => Effect.succeed({ text: "a screenshot", version: "1", subjects: [], artifacts: [], pinned: !1, media: mediaSlotsOf(encoded) }) }, session = yield* open(log, "run-1");
+      yield* session.record([said("how does it look?")], 0);
+      yield* session.recordTail([
+        { role: "assistant", content: [{ type: "tool-call", toolCallId: callId, toolName: "screenshot", input: {} }] },
+        { role: "tool", content: [{ type: "tool-result", toolCallId: callId, toolName: "screenshot", output: { shot: image }, isError: !1 }] }
+      ], imaging, 0);
+      const reopened = yield* open(log, "run-1"), entries = yield* reopened.entries;
+      yield* expect("tool-media", encodeEntries(entries) === encodeEntries(yield* session.entries), "the reopened log lost or changed the result's image");
+      yield* expect("tool-media", encodeEntries(entries).split(image.data).length - 1 === 1, "the result's image is not stored exactly once");
+      const parts = (yield* reopened.build({ stepContext: "tail" })).messages.flatMap((message) => message.role === "tool" ? message.content : []);
+      yield* expect("tool-media", parts.some((part) => (part.media ?? []).some((media) => media.fingerprint === image.fingerprint && media.data === image.data)), "the current turn's tool result was built without its image");
+    })),
     check("the reference transcript holds user messages and replies, never tool traffic", "reference", (open, log) => Effect.gen(function* () {
       const session = yield* open(log, "run-1");
       yield* recordTurn(session, "find alpha", "found record-alpha");

package/dist/models/auth-store.conformance.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "effect";
+import type { ConformanceCheck } from "../conformance.entity.js";
+import type { AuthStore } from "../ports/auth-store.port.js";
+type Store = Context.Service.Shape<typeof AuthStore>;
+/**
+ * The AuthStore contract, as checks any store must pass: what `get`, `all`
+ * and `resolveKey` say about each kind of credential, what `set` and
+ * `remove` change, and that providers do not share state. Every check uses
+ * fresh provider ids (`conformance-<uuid>`, which no store can refresh) and
+ * removes them when it ends, so the kit can run against a shared store.
+ */
+export declare const authStoreConformance: (store: Store) => ReadonlyArray<ConformanceCheck>;
+export {};

package/dist/models/auth-store.conformance.js

@@ -0,0 +1,73 @@
+import { Clock, Effect, Option, Redacted } from "effect";
+import { check, expect, fail } from "../conformance.functions.js";
+import { ProviderId } from "../domain/model-selection.entity.js";
+import { canonicalJson } from "../memory/memory-log.entity.functions.js";
+const HOUR = 3600000, freshProvider = Effect.sync(() => ProviderId.make(`conformance-${crypto.randomUUID()}`)), secret = (label) => `conformance-${label}-${crypto.randomUUID()}`, same = (a, b) => Option.isSome(a) && canonicalJson(a.value) === canonicalJson(b), keyOf = (id, resolved) => Option.match(resolved, {
+  onNone: () => Effect.succeed(Option.none()),
+  onSome: (key) => Redacted.isRedacted(key) ? Effect.succeed(Option.some(Redacted.value(key))) : fail(id, "the resolved key is not Redacted")
+}), withProviders = (store, count, body) => Effect.forEach(Array.from({ length: count }), () => freshProvider).pipe(Effect.flatMap((providers) => body(providers).pipe(Effect.ensuring(Effect.forEach(providers, (provider) => store.remove(provider).pipe(Effect.ignore), { discard: !0 })))));
+export const authStoreConformance = (store) => [
+  check("an absent provider has no credential, no key and no entry", "absent", () => withProviders(store, 1, ([provider]) => Effect.gen(function* () {
+    const id = provider;
+    yield* expect("absent", Option.isNone(yield* store.get(id)), "get found a credential");
+    yield* expect("absent", Option.isNone(yield* store.resolveKey(id)), "resolveKey found a key");
+    yield* expect("absent", !(yield* store.all).has(id), "all lists the provider");
+  }))),
+  check("an api_key credential reads back, is listed, and resolves to its key as Redacted", "api-key", () => withProviders(store, 1, ([provider]) => Effect.gen(function* () {
+    const id = provider, credential = { type: "api_key", key: secret("key") };
+    yield* store.set(id, credential);
+    yield* expect("api-key", same(yield* store.get(id), credential), "get returned a different credential");
+    yield* expect("api-key", same(Option.fromNullishOr((yield* store.all).get(id)), credential), "all lists a different credential, or none");
+    const key = yield* keyOf("api-key", yield* store.resolveKey(id));
+    yield* expect("api-key", Option.getOrUndefined(key) === credential.key, "resolveKey did not return the stored key");
+  }))),
+  check("a local credential reads back and resolves to no key", "local", () => withProviders(store, 1, ([provider]) => Effect.gen(function* () {
+    const id = provider, credential = { type: "local", baseUrl: "http://127.0.0.1:1/v1" };
+    yield* store.set(id, credential);
+    yield* expect("local", same(yield* store.get(id), credential), "get returned a different credential");
+    yield* expect("local", Option.isNone(yield* store.resolveKey(id)), "resolveKey returned a key for a local credential");
+  }))),
+  check("an OAuth token that has not expired resolves to its access token", "oauth-valid", () => withProviders(store, 1, ([provider]) => Effect.gen(function* () {
+    const id = provider, now = yield* Clock.currentTimeMillis, credential = { type: "oauth", access: secret("access"), refresh: secret("refresh"), expires: now + HOUR };
+    yield* store.set(id, credential);
+    yield* expect("oauth-valid", same(yield* store.get(id), credential), "get returned a different credential");
+    const key = yield* keyOf("oauth-valid", yield* store.resolveKey(id));
+    yield* expect("oauth-valid", Option.getOrUndefined(key) === credential.access, "resolveKey did not return the access token");
+  }))),
+  check("an expired OAuth token the store cannot refresh fails with an AuthError naming the provider, never the stale token", "oauth-expired", () => withProviders(store, 1, ([provider]) => Effect.gen(function* () {
+    const id = provider, now = yield* Clock.currentTimeMillis;
+    yield* store.set(id, { type: "oauth", access: secret("stale"), refresh: secret("refresh"), expires: now - HOUR });
+    const resolved = yield* Effect.result(store.resolveKey(id));
+    if (resolved._tag === "Success")
+      return yield* fail("oauth-expired", Option.isSome(resolved.success) ? "resolveKey returned the expired token" : "resolveKey found no key instead of failing");
+    yield* expect("oauth-expired", resolved.failure._tag === "AuthError" && resolved.failure.provider === id, `failed with ${resolved.failure._tag} for ${resolved.failure.provider}`);
+  }))),
+  check("a second set replaces the first", "overwrite", () => withProviders(store, 1, ([provider]) => Effect.gen(function* () {
+    const id = provider, second = { type: "api_key", key: secret("second") };
+    yield* store.set(id, { type: "api_key", key: secret("first") });
+    yield* store.set(id, second);
+    yield* expect("overwrite", same(yield* store.get(id), second), "get still returns the first credential");
+    const key = yield* keyOf("overwrite", yield* store.resolveKey(id));
+    yield* expect("overwrite", Option.getOrUndefined(key) === second.key, "resolveKey still returns the first key");
+  }))),
+  check("remove deletes a credential wherever it is read, and removing an absent provider succeeds", "remove", () => withProviders(store, 2, ([provider, unknown]) => Effect.gen(function* () {
+    const id = provider;
+    yield* store.set(id, { type: "api_key", key: secret("removed") });
+    yield* store.remove(id);
+    yield* expect("remove", Option.isNone(yield* store.get(id)), "get still finds the credential");
+    yield* expect("remove", Option.isNone(yield* store.resolveKey(id)), "resolveKey still finds a key");
+    yield* expect("remove", !(yield* store.all).has(id), "all still lists the provider");
+    yield* store.remove(id);
+    yield* store.remove(unknown);
+  }))),
+  check("providers are isolated: writing or removing one leaves another as it was", "isolation", () => withProviders(store, 2, ([first, second]) => Effect.gen(function* () {
+    const a = first, b = second, kept = { type: "api_key", key: secret("kept") };
+    yield* store.set(b, kept);
+    yield* store.set(a, { type: "api_key", key: secret("other") });
+    yield* store.remove(a);
+    yield* store.set(a, { type: "local" });
+    yield* expect("isolation", same(yield* store.get(b), kept), "another provider's credential changed");
+    const key = yield* keyOf("isolation", yield* store.resolveKey(b));
+    yield* expect("isolation", Option.getOrUndefined(key) === kept.key, "another provider's key changed");
+  })))
+];

package/dist/models/auth-store.conformance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/models/model-catalog.conformance.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from "effect";
+import type { ConformanceCheck } from "../conformance.entity.js";
+import type { ModelCatalog } from "../ports/model-catalog.port.js";
+type Catalog = Context.Service.Shape<typeof ModelCatalog>;
+/**
+ * The ModelCatalog contract: every entry is a `ModelCatalogEntry`, its
+ * `selection` is `"<provider>:<modelId>"` of the entry's own `provider`, no
+ * selection is listed twice, two lists with nothing changed between them
+ * agree, and the selections in `includes` (the models a host expects this
+ * catalog to offer) are listed. The kit only reads.
+ */
+export declare const modelCatalogConformance: (catalog: Catalog, options?: {
+    readonly includes?: ReadonlyArray<string>;
+}) => ReadonlyArray<ConformanceCheck>;
+export {};

package/dist/models/model-catalog.conformance.js

@@ -0,0 +1,27 @@
+import { Effect, Option, Schema } from "effect";
+import { check, expect } from "../conformance.functions.js";
+import { ModelCatalogEntry } from "../domain/model-catalog.entity.js";
+import { parseModelSelection } from "../domain/model-selection.entity.functions.js";
+const isEntry = Schema.is(ModelCatalogEntry);
+export const modelCatalogConformance = (catalog, options = {}) => [
+  check("every entry is a ModelCatalogEntry", "decode", () => Effect.gen(function* () {
+    const invalid = (yield* catalog.list).filter((entry) => !isEntry(entry));
+    yield* expect("decode", invalid.length === 0, `entries that do not decode: ${JSON.stringify(invalid.slice(0, 3))}`);
+  })),
+  check(`every selection is "<provider>:<modelId>" of the entry's provider`, "selection", () => Effect.gen(function* () {
+    const wrong = (yield* catalog.list).filter((entry) => !Option.exists(parseModelSelection(entry.selection), (parsed) => parsed.provider === entry.provider));
+    yield* expect("selection", wrong.length === 0, `selections that do not name their provider: ${wrong.slice(0, 3).map((entry) => `${entry.selection} (${entry.provider})`).join(", ")}`);
+  })),
+  check("no selection is listed twice", "unique", () => Effect.gen(function* () {
+    const selections = (yield* catalog.list).map((entry) => entry.selection), repeated = selections.filter((selection, index) => selections.indexOf(selection) !== index);
+    yield* expect("unique", repeated.length === 0, `listed more than once: ${[...new Set(repeated)].slice(0, 3).join(", ")}`);
+  })),
+  check("two lists with nothing changed between them agree", "stable", () => Effect.gen(function* () {
+    const first = JSON.stringify(yield* catalog.list);
+    yield* expect("stable", JSON.stringify(yield* catalog.list) === first, "two lists differ");
+  })),
+  check("the selections the caller expects are listed", "includes", () => Effect.gen(function* () {
+    const listed = new Set((yield* catalog.list).map((entry) => entry.selection)), missing = (options.includes ?? []).filter((selection) => !listed.has(selection));
+    yield* expect("includes", missing.length === 0, `not listed: ${missing.join(", ")}`);
+  }))
+];

package/dist/models/model-catalog.conformance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/models/settings-store.conformance.d.ts

@@ -0,0 +1,26 @@
+import type { Context } from "effect";
+import type { ConformanceCheck } from "../conformance.entity.js";
+import type { SettingsStore } from "../ports/settings-store.port.js";
+type Store = Context.Service.Shape<typeof SettingsStore>;
+/**
+ * The SettingsStore contract. Every store: `load` is stable. A writable
+ * store: each role reads back what `setRole` wrote and clearing it returns
+ * the value before the set; `set` accepts each key's canonical string form
+ * and `load` gives it typed; `None` clears a key back to the value before the
+ * set; a value that does not parse (a selection that is not
+ * `"<provider>:<modelId>"`, a count below 1, a switch that is not
+ * true/false, an unknown effort) fails with a `SettingsError` and changes
+ * nothing, through `set` and `setRole` alike. A read-only store refuses
+ * every write with a `SettingsError` and changes nothing.
+ *
+ * The kit writes the store's shared keys (settings have no per-check ids),
+ * and restores each key it touches; do not run it against settings that are
+ * in use. A key it would touch that holds a value the store must refuse (a
+ * selection that is not `"<provider>:<modelId>"`, a count below 1, left by
+ * an older, unchecked write) could not be put back, so the check that would
+ * touch it fails before writing anything.
+ */
+export declare const settingsStoreConformance: (store: Store, options: {
+    readonly writable: boolean;
+}) => ReadonlyArray<ConformanceCheck>;
+export {};

package/dist/models/settings-store.conformance.js

@@ -0,0 +1,80 @@
+import { Effect, Option } from "effect";
+import { check, expect, fail } from "../conformance.functions.js";
+import { parseModelSelection } from "../domain/model-selection.entity.functions.js";
+import { canonicalJson } from "../memory/memory-log.entity.functions.js";
+import { SETTINGS_KEYS } from "../ports/settings-store.port.js";
+const ROLE_FIELDS = { general: "model", code: "codeModel", fast: "fastModel" }, ROLES = ["general", "code", "fast"], FIELDS = ["model", "codeModel", "fastModel", ...SETTINGS_KEYS], fieldOf = (settings, field) => settings[field], valueOf = (settings, field) => Option.map(fieldOf(settings, field), String), snapshot = (settings) => canonicalJson(Object.fromEntries(FIELDS.map((field) => [field, Option.getOrNull(valueOf(settings, field))]))), others = (settings, except) => canonicalJson(Object.fromEntries(FIELDS.filter((field) => field !== except).map((field) => [field, Option.getOrNull(valueOf(settings, field))]))), selection = (label) => `conformance:${label}-${crypto.randomUUID()}`, SELECTIONS = new Set(["model", "codeModel", "fastModel", "fallbackModel"]), COUNTS = new Set(["maxAttempts"]), restorable = (field, value) => SELECTIONS.has(field) ? Option.isSome(parseModelSelection(value)) : COUNTS.has(field) ? Number.isInteger(Number(value)) && Number(value) >= 1 : !0, restoring = (store, id, field, write) => (body) => store.load.pipe(Effect.flatMap((before) => Option.match(Option.filter(valueOf(before, field), (value) => !restorable(field, value)), {
+  onSome: (value) => fail(id, `the store holds ${field} "${value}", which a conforming store refuses to write, so the kit could not put it back; it changed nothing. Correct the value, then run the kit`),
+  onNone: () => body.pipe(Effect.ensuring(store.load.pipe(Effect.flatMap((after) => Option.getOrNull(valueOf(after, field)) === Option.getOrNull(valueOf(before, field)) ? Effect.void : write(valueOf(before, field))), Effect.ignore)))
+}))), restoringRole = (store, id, role) => restoring(store, id, ROLE_FIELDS[role], (value) => store.setRole(role, value)), restoringKey = (store, id, key) => restoring(store, id, key, (value) => store.set(key, value)), refused = (store, id, what, write) => Effect.gen(function* () {
+  const before = snapshot(yield* store.load), result = yield* Effect.result(write);
+  if (result._tag === "Success")
+    return yield* fail(id, `${what} was accepted`);
+  const tag = typeof result.failure === "object" && result.failure !== null && "_tag" in result.failure ? String(result.failure._tag) : "an error";
+  yield* expect(id, tag === "SettingsError", `${what} failed with ${tag}, not a SettingsError`);
+  yield* expect(id, snapshot(yield* store.load) === before, `${what} changed the settings`);
+}), CANONICAL = [
+  { key: "maxAttempts", text: "3", reads: 3 },
+  { key: "sandbox", text: "true", reads: !0 },
+  { key: "reasoningEffort", text: "high", reads: "high" }
+], CLEARED = [
+  { key: "maxAttempts", texts: ["4", "5"] },
+  { key: "sandbox", texts: ["false", "true"] },
+  { key: "reasoningEffort", texts: ["low", "medium"] }
+], BAD = [
+  { key: "fallbackModel", text: "not-a-selection" },
+  { key: "maxAttempts", text: "0" },
+  { key: "maxAttempts", text: "two" },
+  { key: "sandbox", text: "maybe" },
+  { key: "reasoningEffort", text: "extreme" }
+];
+export const settingsStoreConformance = (store, options) => [
+  check("load is stable: two loads with no write between them agree", "load", () => Effect.gen(function* () {
+    const first = snapshot(yield* store.load);
+    yield* expect("load", snapshot(yield* store.load) === first, "two loads disagree");
+  })),
+  ...options.writable ? writableChecks(store) : readOnlyChecks(store)
+];
+const writableChecks = (store) => [
+  check("each role reads back what setRole wrote, and clearing it returns the value before the set", "role", () => Effect.forEach(ROLES, (role) => Effect.gen(function* () {
+    const field = ROLE_FIELDS[role];
+    yield* store.setRole(role, Option.none());
+    const base = yield* store.load, value = selection(role);
+    yield* store.setRole(role, Option.some(value));
+    const set = yield* store.load;
+    yield* expect("role", Option.getOrUndefined(valueOf(set, field)) === value, `the ${role} role reads ${Option.getOrElse(valueOf(set, field), () => "nothing")}, not what was set`);
+    yield* expect("role", others(set, field) === others(base, field), `setting the ${role} role changed another value`);
+    yield* store.setRole(role, Option.none());
+    yield* expect("role", snapshot(yield* store.load) === snapshot(base), `clearing the ${role} role did not return the value before the set`);
+  }).pipe(restoringRole(store, "role", role)), { discard: !0 })),
+  check("set accepts each key's canonical string form and load reads it back typed", "values", () => Effect.forEach([
+    ...CANONICAL,
+    { key: "fallbackModel", text: selection("fallback"), reads: void 0 }
+  ], ({ key, text, reads }) => Effect.gen(function* () {
+    const before = yield* store.load;
+    yield* store.set(key, Option.some(text));
+    const after = yield* store.load, expected = reads ?? text, read = Option.getOrNull(fieldOf(after, key));
+    yield* expect("values", read === expected, `${key} "${text}" reads back as ${JSON.stringify(read)}`);
+    yield* expect("values", others(after, key) === others(before, key), `setting ${key} changed another value`);
+  }).pipe(restoringKey(store, "values", key)), { discard: !0 })),
+  check("None clears a key back to the value before the set", "clear", () => Effect.forEach(CLEARED, ({ key, texts }) => Effect.gen(function* () {
+    yield* store.set(key, Option.none());
+    const base = yield* store.load, text = texts.find((candidate) => Option.getOrNull(valueOf(base, key)) !== candidate) ?? texts[0];
+    yield* store.set(key, Option.some(text));
+    yield* store.set(key, Option.none());
+    yield* expect("clear", snapshot(yield* store.load) === snapshot(base), `clearing ${key} did not return the value before the set`);
+  }).pipe(restoringKey(store, "clear", key)), { discard: !0 })),
+  check("set refuses a value that does not parse with a SettingsError and changes nothing", "bad-values", () => Effect.forEach(BAD, ({ key, text }) => refused(store, "bad-values", `${key} "${text}"`, store.set(key, Option.some(text))).pipe(restoringKey(store, "bad-values", key)), { discard: !0 })),
+  check('setRole refuses a selection that is not "<provider>:<modelId>" with a SettingsError and changes nothing', "bad-role", () => Effect.forEach(ROLES, (role) => Effect.forEach(["not-a-selection", ":model", "provider:"], (text) => refused(store, "bad-role", `the ${role} role "${text}"`, store.setRole(role, Option.some(text))), { discard: !0 }).pipe(restoringRole(store, "bad-role", role)), { discard: !0 }))
+], readOnlyChecks = (store) => [
+  check("a read-only store refuses every write with a SettingsError and changes nothing", "read-only", () => Effect.gen(function* () {
+    yield* Effect.forEach(ROLES, (role) => Effect.all([
+      refused(store, "read-only", `setRole ${role}`, store.setRole(role, Option.some(selection(role)))),
+      refused(store, "read-only", `clearing the ${role} role`, store.setRole(role, Option.none()))
+    ]), { discard: !0 });
+    yield* Effect.forEach(CANONICAL, ({ key, text }) => Effect.all([
+      refused(store, "read-only", `set ${key}`, store.set(key, Option.some(text))),
+      refused(store, "read-only", `clearing ${key}`, store.set(key, Option.none()))
+    ]), { discard: !0 });
+  }))
+];

package/dist/models/settings-store.conformance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ports/activity.port.d.ts

@@ -0,0 +1,35 @@
+import { Context } from "effect";
+import type { Effect } from "effect";
+import type { TurnsInFlight } from "../session/activity.entity.js";
+declare const TurnActivity_base: Context.ServiceClass<TurnActivity, "efferent/TurnActivity", {
+    /** The turns held open now (oldest first) and the begins in progress, read at one moment. */
+    readonly current: Effect.Effect<TurnsInFlight>;
+    /** Completes once no turn is held open and none is beginning (at once when so). */
+    readonly idle: Effect.Effect<void>;
+}>;
+/**
+ * The turns this process has in flight, from the Sessions service that opens
+ * them (`SessionsLive` provides it). A begin counts from the moment it is
+ * asked for, through the host's admission and the opening commit, until its
+ * writer is handed over (or it fails); the turn then counts as open until
+ * its writer's scope closes. Only this process's turns count: one held by
+ * another process over the same log does not. `processActivity` and
+ * `awaitIdle` read it, when it is there.
+ */
+export declare class TurnActivity extends TurnActivity_base {
+}
+declare const TaskActivity_base: Context.ServiceClass<TaskActivity, "efferent/TaskActivity", {
+    /** The pieces of work running now. */
+    readonly running: Effect.Effect<number>;
+    /** Completes once none runs (at once when none does). */
+    readonly idle: Effect.Effect<void>;
+}>;
+/**
+ * The background work this process runs, from the TaskRunner that runs it
+ * (`InProcessTaskRunnerLive` provides it). A piece of work counts from the
+ * moment `run` hands it over until it ends. `processActivity` and
+ * `awaitIdle` read it, when it is there.
+ */
+export declare class TaskActivity extends TaskActivity_base {
+}
+export {};