@everfir/az8-cli 0.3.0-preview.1 → 0.3.0-preview.2

package/CHANGELOG.md

@@ -5,6 +5,29 @@ it does not inherit the Web application or monorepo root version.
 
 ## Unreleased
 
+## 0.3.0-preview.2 - 2026-07-23
+
+### Added
+
+- Cursor-only Awareness acknowledgement after a remote Canvas Watch delivery has been flushed and
+  internally acknowledged.
+- Advisory `data.createdByCli` provenance on every View Node created through the CLI.
+
+### Changed
+
+- CLI-created Notes retain the authenticated Actor id and display the current client suffix in
+  their visible creator label.
+- Ordinary Resource View Nodes no longer receive invented generic creator metadata.
+- The built-in agent Skill recommends early visible generation targets and empty Text Resources
+  when artifact type and placement are already unambiguous.
+
+### Safety and compatibility
+
+- Delivery Awareness never responds to the CLI's own changes, never publishes Selection, and does
+  not represent understanding or completion.
+- Editing an existing View Node preserves its creation provenance; duplicating stamps the new node
+  with the current client suffix.
+
 ## 0.3.0-preview.1 - 2026-07-23
 
 ### Added

package/README.md

@@ -18,7 +18,7 @@ az8 guide
 For a supplied preview artifact, install the exact immutable tarball instead:
 
 ```bash
-npm install --global ./everfir-az8-cli-0.3.0-preview.1.tgz
+npm install --global ./everfir-az8-cli-0.3.0-preview.2.tgz
 az8 --version
 ```
 

package/RELEASE.md

@@ -60,7 +60,7 @@ authorization:
 For a preview candidate, publish the exact retained artifact to the preview channel:
 
 ```bash
-npm publish ./tmp/az8-cli-release/everfir-az8-cli-0.3.0-preview.1.tgz --tag preview
+npm publish ./tmp/az8-cli-release/everfir-az8-cli-0.3.0-preview.2.tgz --tag preview
 npm view @everfir/az8-cli dist-tags versions --json
 ```
 

package/dist/main.js

@@ -14175,11 +14175,26 @@ var CANVAS_OPERATION_REGISTRY = [
     },
     required: ["referenceViewNodeId", "viewNodeId"]
   }),
+  write2("insertPromptReference", "Bind one visible image, text, or video View Node and place its platform At token in the Prompt", "silent", {
+    properties: {
+      placement: { enum: ["start", "end"], type: "string" },
+      referenceViewNodeId: stringSchema(),
+      viewNodeId: stringSchema()
+    },
+    required: ["referenceViewNodeId", "viewNodeId"]
+  }),
   write2("removeVisualReference", "Remove one Canvas View Node reference from a generation Draft", "silent", {
     properties: { referenceId: stringSchema(), viewNodeId: stringSchema() },
     required: ["referenceId", "viewNodeId"]
   }),
   write2("startGeneration", "Estimate current Draft inputs, start a Workflow Run, and acknowledge immediate Canvas writes", "barrier", { properties: { viewNodeId: stringSchema() }, required: ["viewNodeId"] }, "workflow-accepted"),
+  write2("reconcileGenerationStart", "Reconcile one known Workflow Run with its target without starting another Run", "barrier", {
+    properties: {
+      viewNodeId: stringSchema(),
+      workflowRunId: stringSchema()
+    },
+    required: ["viewNodeId", "workflowRunId"]
+  }),
   read("getWorkflowRun", "Read one Workflow Run", {
     properties: { workflowRunId: stringSchema() },
     required: ["workflowRunId"]
@@ -14246,10 +14261,25 @@ function sizeSchema() {
 }
 
 // ../../packages/project-canvas-runtime/dist/operation-usage.js
+function attachCanvasOperationIndeterminateResult(value, result3) {
+  const cause = value instanceof Error ? value : new Error("Unexpected Canvas Operation failure.");
+  const error51 = new Error(cause.message, { cause });
+  return Object.assign(error51, {
+    indeterminate: true,
+    operationResult: structuredClone(result3),
+    ..."timedOut" in cause && cause.timedOut === true ? { timedOut: true } : {}
+  });
+}
 function attachCanvasOperationUsage(value, usage) {
   const error51 = value instanceof Error ? value : new Error("Unexpected Canvas Operation failure.");
   return Object.assign(error51, { operationUsage: usage });
 }
+function readCanvasOperationIndeterminateResult(value) {
+  if (typeof value !== "object" || value === null || !("operationResult" in value))
+    return void 0;
+  const result3 = value.operationResult;
+  return typeof result3 === "object" && result3 !== null && !Array.isArray(result3) ? result3 : void 0;
+}
 function readCanvasOperationUsage(value) {
   if (typeof value !== "object" || value === null || !("operationUsage" in value))
     return void 0;
@@ -15022,6 +15052,37 @@ function addVisualReferenceToDraft(draft, definition, reference, sourceDataType,
   }
   return appendPromptReferenceToken(nextDraft, slot.name, reference.id, reference.viewNodeId, now);
 }
+function insertPromptReferenceIntoDraft(draft, definition, reference, sourceDataType, placement, now) {
+  const withReference = addVisualReferenceToDraft(draft, definition, reference, sourceDataType, now);
+  const binding = Object.entries(withReference.inputs.slots).flatMap(([slotName, values]) => values.flatMap((value, index) => value.kind === "view-node" && value.id === reference.id ? [{ index, slotName, value }] : []))[0];
+  if (!binding)
+    throw new Error(`Generation Reference ${reference.id} does not exist in the Draft.`);
+  if (binding.value.sourceDataType !== "image" && binding.value.sourceDataType !== "text" && binding.value.sourceDataType !== "video") {
+    throw new Error("Prompt References must resolve to image, text, or video content.");
+  }
+  const promptSlot = requirePromptSlot(definition);
+  const withoutExistingToken = removePromptReferenceToken(withReference, reference.id);
+  const promptValues = withoutExistingToken.inputs.slots[promptSlot.name] ?? [];
+  const existingLiteral = promptValues.find((value) => value.kind === "literal" && value.assetType === "text");
+  const promptInput = existingLiteral ?? literal(withoutExistingToken, promptSlot.name, "text", "");
+  const prompt = promptInput.content;
+  const token = `{{@${binding.value.sourceDataType}:${binding.slotName}:${binding.index}:${reference.id}|view-node|${encodeURIComponent(reference.viewNodeId)}}}`;
+  const content = placement === "start" ? prompt.trim() ? `${token}
+${prompt}` : token : prompt.trim() ? `${prompt}${prompt.endsWith("\n") ? "" : "\n"}${token}` : token;
+  return {
+    ...structuredClone(withoutExistingToken),
+    inputs: {
+      slots: {
+        ...structuredClone(withoutExistingToken.inputs.slots),
+        [promptSlot.name]: [
+          { ...promptInput, content },
+          ...promptValues.filter((value) => value.id !== promptInput.id)
+        ]
+      }
+    },
+    updatedAt: now
+  };
+}
 function removeVisualReferenceFromDraft(draft, referenceId, now) {
   let removed = false;
   let removedTextReference = false;
@@ -15322,7 +15383,8 @@ function createGenerationExecutionOperations(input) {
   if (definitionChanges || Object.keys(editInput).length > 2) {
     operations.push({ input: editInput, name: "editGenerationDraft" });
   }
-  const currentReferences = definitionChanges ? [] : readGenerationDraftReferences(input.currentDraft);
+  const promptSlotName = resolvePromptSlot(input.definition)?.name;
+  const currentReferences = (definitionChanges ? [] : readGenerationDraftReferences(input.currentDraft)).filter((reference) => editInput.prompt === void 0 || reference.sourceSlotName !== promptSlotName);
   const desiredKeys = new Set(input.assignments.map((item) => referenceKey(item.reference)));
   for (const current of currentReferences) {
     if (!current.draftInputId || desiredKeys.has(referenceKey(current)))
@@ -15823,7 +15885,14 @@ async function resolveEffectiveTextInputContent(input) {
   if (!literal3)
     return null;
   const fragmentsByBindingId = /* @__PURE__ */ new Map();
-  for (const reference of input.references) {
+  const bindingsById = /* @__PURE__ */ new Map();
+  for (const [slotName, references] of Object.entries(input.allReferencesBySlot)) {
+    for (const reference of references) {
+      if (reference.kind !== "literal")
+        bindingsById.set(reference.id, { reference, slotName });
+    }
+  }
+  for (const reference of Object.values(input.allReferencesBySlot).flat()) {
     if (reference.kind !== "view-node" || reference.sourceDataType !== "text")
       continue;
     const content = await input.resolveViewNodeTextContent(reference.viewNodeId);
@@ -15831,8 +15900,17 @@ async function resolveEffectiveTextInputContent(input) {
       fragmentsByBindingId.set(reference.id, content.trim());
   }
   const positionedBindingIds = /* @__PURE__ */ new Set();
-  const positionedContent = literal3.content.replace(new RegExp(PROMPT_REFERENCE_TOKEN_PATTERN2, "g"), (token, _contentType, _slotName, _index, bindingId) => {
+  const positionedContent = literal3.content.replace(new RegExp(PROMPT_REFERENCE_TOKEN_PATTERN2, "g"), (token, contentType, slotName, _rawIndex, bindingId, encodedViewNodeId) => {
     if (!bindingId)
+      throw new Error("Prompt contains an At token without a binding identity.");
+    const binding = bindingsById.get(bindingId);
+    if (!binding || binding.slotName !== slotName || binding.reference.sourceDataType !== contentType) {
+      throw new Error(`Prompt At token ${bindingId} does not match its Generation binding.`);
+    }
+    if (encodedViewNodeId && (binding.reference.kind !== "view-node" || binding.reference.viewNodeId !== decodePromptViewNodeId(encodedViewNodeId))) {
+      throw new Error(`Prompt At token ${bindingId} does not match its View Node.`);
+    }
+    if (contentType !== "text")
       return token;
     const content = fragmentsByBindingId.get(bindingId);
     if (content === void 0)
@@ -15841,11 +15919,21 @@ async function resolveEffectiveTextInputContent(input) {
     return content;
   });
   const trailingFragments = [...fragmentsByBindingId.entries()].flatMap(([bindingId, content]) => positionedBindingIds.has(bindingId) ? [] : [content]);
-  if (new RegExp(PROMPT_REFERENCE_TOKEN_PATTERN2).test(positionedContent)) {
+  const unresolvedTextToken = [
+    ...positionedContent.matchAll(new RegExp(PROMPT_REFERENCE_TOKEN_PATTERN2, "g"))
+  ].some((match) => match[1] === "text");
+  if (unresolvedTextToken) {
     throw new Error("Prompt contains an unresolved Text View Node reference.");
   }
   return appendUniqueTextFragments(positionedContent, trailingFragments);
 }
+function decodePromptViewNodeId(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    throw new Error("Prompt At token contains an invalid View Node identity.");
+  }
+}
 function appendUniqueTextFragments(base, fragments) {
   let result3 = base;
   for (const fragment of fragments) {
@@ -15865,6 +15953,7 @@ async function prepareGenerationInput(input) {
   for (const slot of input.definition.inputSchema) {
     const references = input.draft.inputs.slots[slot.name] ?? [];
     const effectiveText = slot.name === promptSlot?.name ? await resolveEffectiveTextInputContent({
+      allReferencesBySlot: input.draft.inputs.slots,
       references,
       resolveViewNodeTextContent: input.resolveViewNodeTextContent
     }) : null;
@@ -15981,10 +16070,15 @@ var CoreNodeCreativeLoop = class {
       return this.editDraft(input, timeoutMs);
     if (name === "addVisualReference")
       return this.addVisualReference(input, timeoutMs);
+    if (name === "insertPromptReference")
+      return this.insertPromptReference(input, timeoutMs);
     if (name === "removeVisualReference")
       return this.removeVisualReference(input, timeoutMs);
     if (name === "startGeneration")
       return this.startGeneration(input, timeoutMs);
+    if (name === "reconcileGenerationStart") {
+      return this.reconcileGenerationStart(input, timeoutMs);
+    }
     if (name === "getWorkflowRun")
       return this.getWorkflowRun(input);
     if (name === "waitWorkflowRun")
@@ -16160,23 +16254,28 @@ var CoreNodeCreativeLoop = class {
     const draft = requireDraft(target);
     const definition = await this.requireDefinition(draft.definitionId);
     const referenceViewNodeId = requireString3(input.referenceViewNodeId, "referenceViewNodeId");
-    const referenceViewNode = this.requireViewNode(referenceViewNodeId);
-    if (referenceViewNode.type !== "resource") {
-      throw new Error("Generation References require a resource View Node.");
-    }
-    let sourceDataType = referenceViewNode.contentType ?? "";
-    const referenceCoreNodeId = this.resolveViewNodeCoreNodeId(referenceViewNode);
-    if (sourceDataType !== "text" || asRecord3(referenceViewNode.data).mode === "content") {
-      if (!referenceCoreNodeId)
-        throw new Error("Referenced View Node has no current Core Node.");
-      const coreNode = await this.requireCoreNode(referenceCoreNodeId);
-      sourceDataType = readCoreNodeDataType2(coreNode);
-    }
+    const sourceDataType = await this.resolveReferenceDataType(referenceViewNodeId);
     const referenceId = `input_ref_${crypto.randomUUID().replaceAll("-", "")}`;
     const nextDraft = addVisualReferenceToDraft(draft, definition, { id: referenceId, kind: "view-node", viewNodeId: referenceViewNodeId }, sourceDataType, this.context.now());
     await this.replaceDraft(target, nextDraft, "Add Visual Reference", timeoutMs);
     return attention(target.id, { referenceId, viewNodeId: target.id });
   }
+  async insertPromptReference(input, timeoutMs) {
+    assertOnlyKeys3(input, ["placement", "referenceViewNodeId", "viewNodeId"]);
+    const target = this.requireTarget(requireString3(input.viewNodeId, "viewNodeId"));
+    const draft = requireDraft(target);
+    const definition = await this.requireDefinition(draft.definitionId);
+    const referenceViewNodeId = requireString3(input.referenceViewNodeId, "referenceViewNodeId");
+    const sourceDataType = await this.resolveReferenceDataType(referenceViewNodeId);
+    const existing = Object.values(draft.inputs.slots).flat().find((reference) => reference.kind === "view-node" && reference.viewNodeId === referenceViewNodeId);
+    const referenceId = existing?.id ?? `input_ref_${crypto.randomUUID().replaceAll("-", "")}`;
+    const placement = input.placement === void 0 ? "end" : input.placement === "start" || input.placement === "end" ? input.placement : null;
+    if (!placement)
+      throw new Error("placement must be start or end.");
+    const nextDraft = insertPromptReferenceIntoDraft(draft, definition, { id: referenceId, kind: "view-node", viewNodeId: referenceViewNodeId }, sourceDataType, placement, this.context.now());
+    await this.replaceDraft(target, nextDraft, "Insert Prompt Reference", timeoutMs);
+    return attention(target.id, { placement, referenceId, viewNodeId: target.id });
+  }
   async removeVisualReference(input, timeoutMs) {
     assertOnlyKeys3(input, ["referenceId", "viewNodeId"]);
     const target = this.requireTarget(requireString3(input.viewNodeId, "viewNodeId"));
@@ -16187,7 +16286,8 @@ var CoreNodeCreativeLoop = class {
   }
   async startGeneration(input, timeoutMs) {
     let estimate;
-    let runAccepted = false;
+    let acceptedRun;
+    let acceptedTargetId;
     try {
       assertOnlyKeys3(input, ["viewNodeId"]);
       const target = this.requireTarget(requireString3(input.viewNodeId, "viewNodeId"));
@@ -16200,6 +16300,10 @@ var CoreNodeCreativeLoop = class {
         resolveViewNodeCoreNodeId: (id2) => this.resolveViewNodeCoreNodeId(this.requireViewNode(id2)),
         resolveViewNodeTextContent: (id2) => this.resolveViewNodeTextContent(this.requireViewNode(id2))
       });
+      const targetSnapshot = structuredClone(target);
+      const targetData = normalizeOptionalRecord(target.data, "View Node data");
+      const targetHistory = readGenerationHistory(target.history);
+      const effectivePrompt = readPrompt(prepared.effectiveDraft);
       estimate = await this.systems.workflowRuntime.estimateRun({ definitionId: definition.id, inputs: prepared.estimateInputs }, { timeoutMs });
       if (!estimate.canAfford)
         throw new Error("Insufficient credits to start this generation.");
@@ -16218,7 +16322,8 @@ var CoreNodeCreativeLoop = class {
           { slotName: output.slotName, targetId: target.id, targetSlot: draft.id }
         ]
       }, { timeoutMs });
-      runAccepted = true;
+      acceptedRun = run;
+      acceptedTargetId = target.id;
       this.runs.set(run.id, run);
       const timestamp = this.context.now();
       const historyEntry = {
@@ -16234,15 +16339,15 @@ var CoreNodeCreativeLoop = class {
         },
         updatedAt: timestamp
       };
-      const { creationIntent: _creationIntent, ...data } = asRecord3(target.data);
+      const { creationIntent: _creationIntent, ...data } = targetData;
       const after = {
-        ...structuredClone(target),
+        ...targetSnapshot,
         data: {
           ...data,
-          ...readPrompt(prepared.effectiveDraft) === null ? {} : { prompt: readPrompt(prepared.effectiveDraft) }
+          ...effectivePrompt === null ? {} : { prompt: effectivePrompt }
         },
         draft: null,
-        history: toDocumentJson([...readGenerationHistory(target.history), historyEntry]),
+        history: toDocumentJson([...targetHistory, historyEntry]),
         updatedAt: timestamp
       };
       await this.context.commit({
@@ -16264,8 +16369,15 @@ var CoreNodeCreativeLoop = class {
         usage: estimatedUsage(estimate)
       };
     } catch (error51) {
-      const usage = runAccepted && estimate ? estimatedUsage(estimate) : isIndeterminateWrite(error51) ? unknownUsage(estimate) : notConsumedUsage(estimate);
-      throw attachCanvasOperationUsage(error51, usage);
+      const failure = acceptedRun && acceptedTargetId ? attachCanvasOperationIndeterminateResult(error51, {
+        canvasAcknowledged: false,
+        reconciliationRequired: true,
+        status: acceptedRun.status,
+        viewNodeId: acceptedTargetId,
+        workflowRunId: acceptedRun.id
+      }) : error51;
+      const usage = acceptedRun && estimate ? estimatedUsage(estimate) : isIndeterminateWrite(error51) ? unknownUsage(estimate) : notConsumedUsage(estimate);
+      throw attachCanvasOperationUsage(failure, usage);
     }
   }
   async getWorkflowRun(input) {
@@ -16273,6 +16385,133 @@ var CoreNodeCreativeLoop = class {
     const run = await this.refreshRun(requireString3(input.workflowRunId, "workflowRunId"), 15e3);
     return { result: { workflowRun: run } };
   }
+  async reconcileGenerationStart(input, timeoutMs) {
+    assertOnlyKeys3(input, ["viewNodeId", "workflowRunId"]);
+    const target = this.requireTarget(requireString3(input.viewNodeId, "viewNodeId"));
+    const workflowRunId = requireString3(input.workflowRunId, "workflowRunId");
+    const run = await this.systems.workflowRuntime.getRun(workflowRunId);
+    if (!run)
+      throw new Error(`Workflow Run ${workflowRunId} does not exist.`);
+    this.recordRun(run);
+    const sync = await this.systems.projectContent.syncProject(this.context.projectId, 0, {
+      timeoutMs
+    });
+    this.projection.merge(sync.contents);
+    const history = readGenerationHistory(target.history);
+    const existing = history.find((entry) => entry.runtime.instanceIds.includes(run.id));
+    if (existing) {
+      if (existing.definitionId !== run.definitionId) {
+        return reconciliationResult(target.id, run.id, "conflict", {
+          reason: "The existing History entry and Workflow Run use different Definitions."
+        });
+      }
+      const repairedPendingState = !isTerminalWorkflowRunStatus(run.status) && !this.isPending(run.id);
+      if (isTerminalWorkflowRunStatus(run.status))
+        await this.settleRun(run, timeoutMs);
+      else if (repairedPendingState) {
+        await this.context.commit({
+          addPendingWorkflowInstanceIds: [run.id],
+          after: [],
+          before: [],
+          history: "barrier",
+          label: "Reconcile generation start",
+          timeoutMs
+        });
+        this.watchRun(run.id, timeoutMs);
+      }
+      return reconciliationResult(target.id, run.id, "consistent", {
+        repairedPendingState,
+        workflowStatus: run.status
+      });
+    }
+    const draft = readGenerationDraft(target.draft);
+    if (!draft) {
+      return reconciliationResult(target.id, run.id, "conflict", {
+        reason: "The target has neither a matching History entry nor its original Draft.",
+        workflowStatus: run.status
+      });
+    }
+    if (draft.definitionId !== run.definitionId) {
+      return reconciliationResult(target.id, run.id, "conflict", {
+        reason: "The target Draft and Workflow Run use different Definitions.",
+        workflowStatus: run.status
+      });
+    }
+    if (!isTerminalWorkflowRunStatus(run.status)) {
+      return reconciliationResult(target.id, run.id, "running-insufficient", {
+        reason: "The running Workflow does not yet expose authoritative target output evidence. Wait for a terminal state; do not start another Run.",
+        workflowStatus: run.status
+      });
+    }
+    if (run.status !== "completed") {
+      return reconciliationResult(target.id, run.id, "terminal", {
+        reason: "The Workflow ended without a completed output, so no History entry was invented.",
+        workflowStatus: run.status
+      });
+    }
+    const submittedAt = parseWorkflowTimestamp(run.createdAt);
+    if (submittedAt === null) {
+      return reconciliationResult(target.id, run.id, "insufficient", {
+        reason: "The completed Workflow Run has no trustworthy submission timestamp.",
+        workflowStatus: run.status
+      });
+    }
+    if ((draft.updatedAt ?? draft.createdAt) > submittedAt) {
+      return reconciliationResult(target.id, run.id, "conflict", {
+        reason: "The target Draft changed after the Workflow Run was submitted.",
+        workflowStatus: run.status
+      });
+    }
+    const definition = await this.requireDefinition(run.definitionId);
+    const primaryOutput = requirePrimaryOutput(definition, target.contentType);
+    const targetOutputs = sync.contents.filter((content) => content.sourceId === run.id || content.workflowInstanceId === run.id).flatMap((content) => content.outputs).filter((output) => output.targetId === target.id && output.targetSlot === draft.id && output.slotName === primaryOutput.slotName);
+    if (targetOutputs.length === 0) {
+      return reconciliationResult(target.id, run.id, "insufficient", {
+        reason: "The completed Workflow Run has no Project Content output bound to this target and Draft.",
+        workflowStatus: run.status
+      });
+    }
+    const outputCoreNodeIds = new Set(run.outputs.map((output) => output.coreNodeId));
+    if (outputCoreNodeIds.size > 0 && targetOutputs.every((output) => !outputCoreNodeIds.has(output.coreNodeId))) {
+      return reconciliationResult(target.id, run.id, "conflict", {
+        reason: "Workflow and Project Content outputs disagree.",
+        workflowStatus: run.status
+      });
+    }
+    const timestamp = this.context.now();
+    const historyEntry = {
+      ...draft,
+      runtime: {
+        ...run.definitionVersion === void 0 ? {} : { expectedDefinitionVersion: run.definitionVersion },
+        instanceIds: [run.id],
+        materializedInputs: inferReconciledMaterializedInputs(draft, run),
+        originClientId: "unknown",
+        submittedAt
+      },
+      updatedAt: timestamp
+    };
+    const { creationIntent: _creationIntent, ...data } = normalizeOptionalRecord(target.data, "View Node data");
+    const prompt = readPrompt(draft);
+    const after = {
+      ...structuredClone(target),
+      data: { ...data, ...prompt === null ? {} : { prompt } },
+      draft: null,
+      history: toDocumentJson([...history, historyEntry]),
+      updatedAt: timestamp
+    };
+    await this.context.commit({
+      after: [after],
+      before: [target],
+      history: "barrier",
+      label: "Reconcile generation start",
+      ...this.isPending(run.id) ? { removePendingWorkflowInstanceIds: [run.id] } : {},
+      timeoutMs
+    });
+    return reconciliationResult(target.id, run.id, "repaired", {
+      outputCoreNodeIds: [...new Set(targetOutputs.map((output) => output.coreNodeId))],
+      workflowStatus: run.status
+    });
+  }
   async waitWorkflowRun(input, timeoutMs) {
     assertOnlyKeys3(input, ["workflowRunId"]);
     const id2 = requireString3(input.workflowRunId, "workflowRunId");
@@ -16479,6 +16718,21 @@ var CoreNodeCreativeLoop = class {
     this.definitions.set(id2, definition);
     return definition;
   }
+  async resolveReferenceDataType(referenceViewNodeId) {
+    const referenceViewNode = this.requireViewNode(referenceViewNodeId);
+    if (referenceViewNode.type !== "resource") {
+      throw new Error("Generation References require a resource View Node.");
+    }
+    let sourceDataType = referenceViewNode.contentType ?? "";
+    const referenceCoreNodeId = this.resolveViewNodeCoreNodeId(referenceViewNode);
+    if (sourceDataType !== "text" || asRecord3(referenceViewNode.data).mode === "content") {
+      if (!referenceCoreNodeId)
+        throw new Error("Referenced View Node has no current Core Node.");
+      const coreNode = await this.requireCoreNode(referenceCoreNodeId);
+      sourceDataType = readCoreNodeDataType2(coreNode);
+    }
+    return sourceDataType;
+  }
   requireTarget(id2) {
     const viewNode = this.requireViewNode(id2);
     requireSupportedContentType(viewNode.contentType);
@@ -16524,8 +16778,6 @@ var CoreNodeCreativeLoop = class {
       data: {
         ...contentType === "text" ? { mode: "content" } : {},
         ...data,
-        creator_id: this.context.actor.id,
-        creator_name: this.context.actor.displayName,
         ...name ? { label: name } : {}
       },
       draft: null,
@@ -16563,6 +16815,14 @@ function createEstimatedCompletionTimes(estimate, submittedAt) {
 function attention(viewNodeId, result3) {
   return { attention: { kind: "view-nodes", viewNodeIds: [viewNodeId] }, result: result3 };
 }
+function reconciliationResult(viewNodeId, workflowRunId, reconciliationStatus, detail) {
+  return attention(viewNodeId, {
+    ...detail,
+    reconciliationStatus,
+    viewNodeId,
+    workflowRunId
+  });
+}
 function requireDraft(viewNode) {
   const draft = readGenerationDraft(viewNode.draft);
   if (!draft)
@@ -16588,6 +16848,38 @@ function readPrompt(draft) {
   }
   return null;
 }
+function inferReconciledMaterializedInputs(draft, run) {
+  const materialized = {};
+  for (const [slotName, bindings] of Object.entries(draft.inputs.slots)) {
+    const references = bindings.filter((binding) => binding.kind !== "literal");
+    if (references.length === 0)
+      continue;
+    const input = run.inputs[slotName];
+    if (typeof input !== "object" || input === null || Array.isArray(input) || !("coreNodeIds" in input) || !Array.isArray(input.coreNodeIds)) {
+      continue;
+    }
+    const coreNodeIds = input.coreNodeIds.filter((coreNodeId) => typeof coreNodeId === "string" && Boolean(coreNodeId));
+    if (references.length === 1) {
+      const reference = references[0];
+      if (reference)
+        materialized[slotName] = [{ coreNodeIds, inputRefId: reference.id }];
+      continue;
+    }
+    if (references.length !== coreNodeIds.length)
+      continue;
+    materialized[slotName] = references.map((reference, index) => ({
+      coreNodeIds: [coreNodeIds[index]],
+      inputRefId: reference.id
+    }));
+  }
+  return materialized;
+}
+function parseWorkflowTimestamp(value) {
+  if (!value)
+    return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
 function parseConfig2(value) {
   const record2 = asRecord3(value);
   for (const item of Object.values(record2)) {
@@ -16616,6 +16908,14 @@ function asRecord3(value) {
   }
   return value;
 }
+function normalizeOptionalRecord(value, field) {
+  if (value === void 0 || value === null)
+    return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${field} must be an object when present.`);
+  }
+  return structuredClone(value);
+}
 function requireString3(value, field) {
   if (typeof value !== "string" || !value.trim())
     throw new Error(`${field} must be non-empty.`);
@@ -16775,8 +17075,6 @@ var ExternalMediaImporter = class {
         data: {
           contentBindingError: null,
           contentBindingStatus: "pending",
-          creator_id: this.context.actor.id,
-          creator_name: this.context.actor.displayName,
           [IMPORT_INTENT_DATA_KEY]: structuredClone(intent),
           label: intent.name
         },
@@ -17201,8 +17499,6 @@ var MediaUploader = class {
         data: {
           contentBindingError: null,
           contentBindingStatus: "pending",
-          creator_id: this.context.actor.id,
-          creator_name: this.context.actor.displayName,
           label: intent.name,
           [UPLOAD_INTENT_DATA_KEY]: structuredClone(intent)
         },
@@ -17991,6 +18287,7 @@ var SemanticCanvasRuntime = class {
   unsubscribeRemote;
   commands;
   contentProjection;
+  creationProvenanceSuffix;
   creativeLoop;
   externalMediaImporter;
   mediaUploader;
@@ -18000,12 +18297,12 @@ var SemanticCanvasRuntime = class {
   constructor(options) {
     this.options = options;
     this.now = options.now ?? Date.now;
+    this.creationProvenanceSuffix = normalizeCreationProvenanceSuffix(options.clientName);
     this.commands = createProjectCanvasCommandExecutor(options.document, this.now);
     this.contentProjection = new ProjectContentProjection(options.projectContents);
     this.projectionRevision = options.initialRevision ?? 1;
     this.snapshot = options.document.getSnapshot();
     const operationContext = {
-      actor: options.actor,
       canWrite: options.role !== "viewer",
       clientInstanceId: options.clientInstanceId ?? "unknown",
       commit: async (input) => {
@@ -18342,15 +18639,18 @@ var SemanticCanvasRuntime = class {
     };
   }
   async commit(entry, timeoutMs) {
-    await this.applyHistoryState(entry.after, entry.viewNodeIds, entry.label, timeoutMs);
-    this.undoStack.push({ ...entry, kind: "reversible" });
+    const after = this.stampCreatedViewNodes(entry.after, entry.before);
+    await this.applyHistoryState(after, entry.viewNodeIds, entry.label, timeoutMs);
+    this.undoStack.push({ ...entry, after, kind: "reversible" });
     this.redoStack.length = 0;
   }
   async applyOperationPlan(plan, timeoutMs) {
     if (plan.changes.length > 0) {
+      const before = plan.changes.map((change) => change.before);
+      const after = this.stampCreatedViewNodes(plan.changes.map((change) => change.after), before);
       const entry = {
-        after: plan.changes.map((change) => change.after),
-        before: plan.changes.map((change) => change.before),
+        after,
+        before,
         kind: "reversible",
         label: plan.label,
         viewNodeIds: plan.changes.map((change) => change.viewNodeId)
@@ -18387,16 +18687,23 @@ var SemanticCanvasRuntime = class {
     });
   }
   async applySemanticChanges(changes, label, timeoutMs, history, addPendingWorkflowInstanceIds, removePendingWorkflowInstanceIds) {
+    const preparedChanges = changes.map((change) => ({
+      ...change,
+      after: change.before === null ? this.stampCreatedViewNode(change.after) : structuredClone(change.after)
+    }));
     const previous = this.snapshot;
     this.snapshot = await this.commands.changeViewNodes({
       ...addPendingWorkflowInstanceIds ? { addPendingWorkflowInstanceIds } : {},
-      changes: changes.map((change) => ({ state: change.after, viewNodeId: change.viewNodeId })),
+      changes: preparedChanges.map((change) => ({
+        state: change.after,
+        viewNodeId: change.viewNodeId
+      })),
       operationName: label,
       ...removePendingWorkflowInstanceIds ? { removePendingWorkflowInstanceIds } : {},
       timeoutMs
     });
     this.projectionRevision += 1;
-    const viewNodeIds = changes.map((change) => change.viewNodeId);
+    const viewNodeIds = preparedChanges.map((change) => change.viewNodeId);
     const viewNodeChanges = diffSemanticViewNodes(previous.viewNodes, this.snapshot.viewNodes, viewNodeIds);
     this.emit({
       changedViewNodeIds: viewNodeIds,
@@ -18406,8 +18713,8 @@ var SemanticCanvasRuntime = class {
     });
     if (history === "undoable") {
       this.undoStack.push({
-        after: changes.map((change) => change.after),
-        before: changes.map((change) => change.before),
+        after: preparedChanges.map((change) => change.after),
+        before: preparedChanges.map((change) => change.before),
         kind: "reversible",
         label,
         viewNodeIds
@@ -18418,6 +18725,22 @@ var SemanticCanvasRuntime = class {
       this.redoStack.length = 0;
     }
   }
+  stampCreatedViewNodes(after, before) {
+    return after.map((viewNode, index) => viewNode !== null && before[index] === null ? this.stampCreatedViewNode(viewNode) : structuredClone(viewNode));
+  }
+  stampCreatedViewNode(viewNode) {
+    if (!this.creationProvenanceSuffix)
+      return structuredClone(viewNode);
+    const data = typeof viewNode.data === "object" && viewNode.data !== null && !Array.isArray(viewNode.data) ? structuredClone(viewNode.data) : {};
+    delete data.creator_id;
+    delete data.creator_name;
+    data.createdByCli = this.creationProvenanceSuffix;
+    if (viewNode.type === "note") {
+      data.creator_id = this.options.actor.id;
+      data.creator_name = `${this.options.actor.displayName} (${this.creationProvenanceSuffix})`;
+    }
+    return { ...structuredClone(viewNode), data };
+  }
   nextNotePosition() {
     const count = this.snapshot.viewNodes.length;
     return { x: 160 + count % 4 * 348, y: 160 + Math.floor(count / 4) * 348 };
@@ -18472,7 +18795,7 @@ function duplicateInputContainsResource(snapshot, input) {
   return snapshot.viewNodes.some((viewNode) => ids.has(viewNode.id) && viewNode.type === "resource");
 }
 function isCreativeLoopOperation(name) {
-  return name === "getCoreNode" || name === "placeCoreNode" || name === "createGenerationTarget" || name === "createMediaTarget" || name === "planGeneration" || name === "editGenerationDraft" || name === "addVisualReference" || name === "removeVisualReference" || name === "startGeneration" || name === "getWorkflowRun" || name === "waitWorkflowRun";
+  return name === "getCoreNode" || name === "placeCoreNode" || name === "createGenerationTarget" || name === "createMediaTarget" || name === "planGeneration" || name === "editGenerationDraft" || name === "addVisualReference" || name === "insertPromptReference" || name === "removeVisualReference" || name === "startGeneration" || name === "reconcileGenerationStart" || name === "getWorkflowRun" || name === "waitWorkflowRun";
 }
 function createViewNodeId() {
   return `view_node_${crypto.randomUUID().replaceAll("-", "")}`;
@@ -18510,6 +18833,17 @@ function requireString6(value, field) {
     throw new Error(`${field} must be a string.`);
   return value;
 }
+function normalizeCreationProvenanceSuffix(value) {
+  if (value === void 0)
+    return null;
+  const normalized = value.trim();
+  if (!normalized)
+    throw new Error("clientName must be non-empty when provided.");
+  if (normalized.includes("(") || normalized.includes(")")) {
+    throw new Error("clientName must not contain parentheses.");
+  }
+  return normalized;
+}
 
 // src/integrations/backend.ts
 var BackendRequestError = class extends Error {
@@ -23716,6 +24050,7 @@ var AgentCollaborationWatch = class {
   now;
   pending = [];
   recent = [];
+  workflowWatermarks = /* @__PURE__ */ new Map();
   activeWait = null;
   continuityLost = false;
   constructor(options = {}) {
@@ -23728,7 +24063,13 @@ var AgentCollaborationWatch = class {
     this.now = options.now ?? Date.now;
   }
   patchInterests(input) {
-    return this.interests.patch(input);
+    const result3 = this.interests.patch(input);
+    for (const key of result3.changedKeys) {
+      for (const watermarkKey of this.workflowWatermarks.keys()) {
+        if (watermarkKey.startsWith(`${key}\0`)) this.workflowWatermarks.delete(watermarkKey);
+      }
+    }
+    return result3;
   }
   getInterests() {
     return this.interests.getAll();
@@ -23752,10 +24093,24 @@ var AgentCollaborationWatch = class {
   recordMany(facts) {
     if (this.continuityLost) return;
     for (const fact of facts) {
-      for (const interest of this.interests.matching(fact)) this.enqueue(interest.key, fact);
+      for (const interest of this.interests.matching(fact)) {
+        this.recordWorkflowWatermark(interest.key, fact);
+        this.enqueue(interest.key, fact);
+      }
     }
     if (this.activeWait && (this.pending.length > 0 || this.continuityLost)) this.deliverActive();
   }
+  recordAuthoritativeWorkflow(fact) {
+    if (fact.domain !== "workflow" || this.continuityLost) return;
+    for (const interest of this.interests.matching(fact)) {
+      const key = workflowWatermarkKey(interest.key, fact.ref);
+      const fingerprint = workflowFingerprint(fact);
+      if (this.workflowWatermarks.get(key) === fingerprint) continue;
+      this.workflowWatermarks.set(key, fingerprint);
+      this.enqueue(interest.key, fact);
+    }
+    if (this.activeWait && this.pending.length > 0) this.deliverActive();
+  }
   wait(options) {
     const timeoutMs = positive(options.timeoutMs, "timeoutMs");
     if (this.activeWait)
@@ -23789,6 +24144,11 @@ var AgentCollaborationWatch = class {
   resynchronize() {
     this.continuityLost = false;
     this.pending.length = 0;
+    this.workflowWatermarks.clear();
+  }
+  recordWorkflowWatermark(interest, fact) {
+    if (fact.domain !== "workflow") return;
+    this.workflowWatermarks.set(workflowWatermarkKey(interest, fact.ref), workflowFingerprint(fact));
   }
   enqueue(interest, fact) {
     const terminalPending = this.pending.find(
@@ -23832,6 +24192,7 @@ var AgentCollaborationWatch = class {
       merged: entry.merged,
       quietForMs: Math.max(0, now - entry.lastObservedAt),
       ref: entry.fact.ref,
+      ...entry.fact.domain === "canvas" ? { source: entry.fact.source } : {},
       summary: structuredClone(entry.fact.summary)
     }));
     const result3 = {
@@ -23908,6 +24269,18 @@ function positive(value, field) {
 function watchError(code, message) {
   return Object.assign(new Error(message), { code });
 }
+function workflowWatermarkKey(interest, runId) {
+  return `${interest}\0${runId}`;
+}
+function workflowFingerprint(fact) {
+  return JSON.stringify({
+    changeKind: fact.changeKind,
+    kind: fact.kind,
+    status: fact.status,
+    summary: fact.summary,
+    terminal: fact.terminal
+  });
+}
 
 // src/canvas/session.ts
 var CanvasSession = class {
@@ -23934,6 +24307,7 @@ var CanvasSession = class {
   runtime = null;
   unsubscribeRuntime = null;
   observationListeners = /* @__PURE__ */ new Set();
+  knownWorkflowRunIds = /* @__PURE__ */ new Set();
   projectionRevision = 0;
   actorId = null;
   collaborationContext = null;
@@ -23983,6 +24357,7 @@ var CanvasSession = class {
       const connectionId = this.health.connectionId;
       const runtime = new SemanticCanvasRuntime({
         actor: { displayName: actor.displayName, id: actor.accountId },
+        clientName: normalizedClientName,
         clientInstanceId: this.clientInstanceId,
         document: document2,
         foundationData,
@@ -24001,6 +24376,9 @@ var CanvasSession = class {
         workflowRuntime
       });
       this.runtime = runtime;
+      for (const workflowRunId of runtime.getSnapshot().pendingWorkflowInstanceIds) {
+        this.knownWorkflowRunIds.add(workflowRunId);
+      }
       this.projectionRevision = runtime.revision;
       this.unsubscribeRuntime = runtime.subscribe((observation) => {
         this.projectionRevision = observation.revision;
@@ -24024,11 +24402,58 @@ var CanvasSession = class {
   }
   async execute(name, input, timeoutMs) {
     const runtime = this.requireRuntime();
+    if (typeof input.workflowRunId === "string" && input.workflowRunId) {
+      this.knownWorkflowRunIds.add(input.workflowRunId);
+    }
     const result3 = await runtime.execute(name, input, timeoutMs);
+    if (typeof result3.result.workflowRunId === "string" && result3.result.workflowRunId) {
+      this.knownWorkflowRunIds.add(result3.result.workflowRunId);
+    }
     this.projectionRevision = result3.revision;
     if (result3.attention) this.publishAttention(result3.attention);
     return result3;
   }
+  async catchUpWorkflowInterests(timeoutMs) {
+    const runtime = this.requireRuntime();
+    const deadline = Date.now() + timeoutMs;
+    const knownWorkflowRunIds = [...this.knownWorkflowRunIds];
+    const runIds = [
+      ...new Set(
+        this.watch.getInterests().filter((interest) => interest.kind === "workflow").flatMap((interest) => interest.filter.runIds ?? knownWorkflowRunIds)
+      )
+    ];
+    for (const workflowRunId of runIds) {
+      const remainingMs = deadline - Date.now();
+      if (remainingMs < 1) break;
+      try {
+        const result3 = await runtime.execute("getWorkflowRun", { workflowRunId }, remainingMs);
+        const workflowRun = result3.result.workflowRun;
+        if (!isWorkflowRun(workflowRun)) continue;
+        for (const fact of projectCanvasObservation(
+          { kind: "workflow", revision: result3.revision, workflowRun },
+          Date.now()
+        )) {
+          this.watch.recordAuthoritativeWorkflow(fact);
+        }
+      } catch {
+      }
+    }
+  }
+  acknowledgeWatchDelivery(result3) {
+    if (result3.status !== "ready") return;
+    for (const change of result3.changes) {
+      if (change.source !== "remote" || !change.kind.startsWith("note.") && !change.kind.startsWith("view-node.")) {
+        continue;
+      }
+      const bounds = this.requireRuntime().resolveAttentionBounds({
+        kind: "view-nodes",
+        viewNodeIds: [change.ref]
+      });
+      if (!bounds) continue;
+      this.publishAttentionBounds(bounds);
+      return;
+    }
+  }
   getCapabilities(detail) {
     return this.requireRuntime().capabilities.map(
       (descriptor2) => detail ? descriptor2 : {
@@ -24142,6 +24567,9 @@ function isIndeterminateWrite4(value) {
 function isWorkflowRecoveryExhausted(value) {
   return typeof value === "object" && value !== null && "workflowRecoveryExhausted" in value && value.workflowRecoveryExhausted === true;
 }
+function isWorkflowRun(value) {
+  return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string" && "status" in value && typeof value.status === "string" && "definitionId" in value && typeof value.definitionId === "string" && "outputs" in value && Array.isArray(value.outputs);
+}
 
 // src/canvas/client.ts
 var CANVAS_QUERY_TARGETS = [
@@ -24236,6 +24664,7 @@ var CanvasClient = class {
       });
       return { receipt };
     } catch (error51) {
+      const operationResult2 = readCanvasOperationIndeterminateResult(error51);
       const operationUsage = readCanvasOperationUsage(error51);
       const indeterminate = isIndeterminateError(error51);
       const timedOut = indeterminate && (error51 instanceof IndeterminateBackendWriteError && error51.timedOut || readTimedOut(error51) || error51 instanceof Error && /timed out/i.test(error51.message));
@@ -24247,6 +24676,7 @@ var CanvasClient = class {
           message: safeCanvasMessage(error51),
           outcome: indeterminate ? "indeterminate" : "failed"
         },
+        ...operationResult2 ? { result: redactCanvasRecord(operationResult2) } : {},
         status: timedOut ? "timed-out" : "failed",
         ...operationUsage ? { usage: operationUsage } : {}
       });
@@ -24856,7 +25286,16 @@ async function startAgentSessionDaemon(spec, dependencies = {}) {
       }
       if (request.kind === "delivery.ack") {
         const acknowledged = outstandingDelivery?.deliveryId === request.deliveryId;
-        if (acknowledged) outstandingDelivery = void 0;
+        if (acknowledged) {
+          const result3 = outstandingDelivery?.result;
+          outstandingDelivery = void 0;
+          if (result3) {
+            try {
+              client.session.acknowledgeWatchDelivery?.(result3);
+            } catch {
+            }
+          }
+        }
         return { acknowledged };
       }
       if (request.kind === "interests.get") return watch.getInterests();
@@ -24882,7 +25321,10 @@ async function startAgentSessionDaemon(spec, dependencies = {}) {
       }
       if (request.kind === "watch.wait") {
         if (outstandingDelivery) return outstandingDelivery;
-        const result3 = await watch.wait({ signal: context.signal, timeoutMs: request.timeoutMs });
+        const startedAt = Date.now();
+        await client.session.catchUpWorkflowInterests?.(Math.min(request.timeoutMs, 15e3));
+        const remainingMs = Math.max(1, request.timeoutMs - (Date.now() - startedAt));
+        const result3 = await watch.wait({ signal: context.signal, timeoutMs: remainingMs });
         if (result3.status !== "ready") return { result: result3 };
         outstandingDelivery = { deliveryId: crypto.randomUUID(), result: result3 };
         return outstandingDelivery;
@@ -24949,6 +25391,8 @@ async function createCanvasClient(spec, dependencies) {
     executeOperation: (input) => client.executeOperation(input),
     query: (input) => client.query(input),
     session: {
+      acknowledgeWatchDelivery: (result3) => session.acknowledgeWatchDelivery(result3),
+      catchUpWorkflowInterests: (timeoutMs) => session.catchUpWorkflowInterests(timeoutMs),
       getContext: () => session.getCollaborationContext(),
       getHealth: () => session.getHealth(),
       getIdentity: () => session.getIdentity(),
@@ -44620,7 +45064,7 @@ function registerCanvasCommands(program2, dependencies, setResult) {
 // package.json
 var package_default = {
   name: "@everfir/az8-cli",
-  version: "0.3.0-preview.1",
+  version: "0.3.0-preview.2",
   description: "Semantic Project Canvas client for AZ8 Studio agents.",
   license: "UNLICENSED",
   type: "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everfir/az8-cli",
-  "version": "0.3.0-preview.1",
+  "version": "0.3.0-preview.2",
   "description": "Semantic Project Canvas client for AZ8 Studio agents.",
   "license": "UNLICENSED",
   "type": "module",

package/skills/az8-cli/SKILL.md

@@ -230,12 +230,20 @@ one-shot processes.
 
 1. Query `canvas.summary`; query selected details only as needed.
 2. Query `capabilities.detail` and validate the planned Operation input against its schema.
-3. Pick explicit absolute Canvas coordinates. Public move positions remain absolute even for group
+3. When artifact type and placement are already clear, make the first meaningful Canvas state
+   visible before doing lengthy prompt refinement or generation planning:
+   - create the empty generation target first, then plan and edit its Draft;
+   - create an empty manual Text Resource with `text: ""`, then fill it with
+     `editTextContent`;
+   - create a Note with its useful content directly rather than creating an empty sticky.
+   Do not create a placeholder while its type or placement is still ambiguous. Watch and the
+   Session daemon never create placeholders automatically.
+4. Pick explicit absolute Canvas coordinates. Public move positions remain absolute even for group
    children.
-4. Submit one Operation with a new request ID and wait for its terminal Receipt.
-5. Confirm the Receipt outcome and affected IDs, then query the changed View Node when subsequent
+5. Submit one Operation with a new request ID and wait for its terminal Receipt.
+6. Confirm the Receipt outcome and affected IDs, then query the changed View Node when subsequent
    work depends on its exact state.
-6. Only then plan the next interaction.
+7. Only then plan the next interaction.
 
 Common capabilities include notes, manual Text Resources, move/resize/rename, duplicate/remove,
 groups and stacking, Core Node placement, and generation targets. The runtime catalog is
@@ -270,6 +278,11 @@ Generation is an explicit sequence, never one transaction:
    plan.
 4. Execute `plan.operations` exactly in order, one Operation at a time. Each step revalidates
    current facts. Stop after the first non-success.
+   When a reference must also appear at a meaningful Prompt position, use
+   `insertPromptReference` with the target View Node, visible reference View Node, and
+   `placement: "start"` or `"end"`. The CLI creates and validates the binding and At token
+   atomically. Do not write `{{@...}}`, choose an input slot/index, or allocate a binding ID
+   yourself. `addVisualReference` remains the connection-only operation.
 5. `startGeneration` succeeds when the Workflow Run is accepted and immediate Canvas effects are
    acknowledged. This completes the start interaction; it does not mean generation finished.
 6. Retain the Workflow Run ID. After the successful start Receipt, continue any work that does not
@@ -283,6 +296,19 @@ Generation is an explicit sequence, never one transaction:
 8. On terminal success, query the target detail and resolve its current output Core Node through
    Project Content before downloading or placing it elsewhere.
 
+If `startGeneration` returns an indeterminate Receipt after the Workflow was accepted, retain
+`receipt.result.workflowRunId` and `receipt.result.viewNodeId`, reconnect the Session, and invoke
+`reconcileGenerationStart` with those two identities. Never call `startGeneration` again for that
+intent. `running-insufficient` means the Run is still authoritative but does not yet expose enough
+target evidence: wait and reconcile later. `repaired` means the CLI restored the missing Canvas
+launch facts through the semantic Command path. `conflict` or `insufficient` requires inspection;
+neither authorizes a retry.
+
+A Workflow Interest performs an authoritative status catch-up for Run IDs already known to the
+Session; explicit `filter.runIds` narrows or restores that set when needed. This closes
+missed-live-event races and delivers each unchanged terminal fact once. Keep explicit Run ID filters
+current across handoffs; the daemon does not scan unrelated Workflow Runs.
+
 Workflow Definitions change over time. Query `workflowDefinitions.summary`, then
 `workflowDefinition.detail` only when planning detail is insufficient. Never guess a Definition,
 configuration option, modality, cost, or media compatibility from its display name.