@sjawhar/pi-envoy 8.14.2 → 8.15.0

package/dist/dispatch.js

@@ -17297,22 +17297,31 @@ async function refuseOpenDecisionBlocks(client, tool, resolved) {
   const asks = new Map(documentAsks.map((ask) => [ask.block_id, ask]));
   const lines = version2.markdown.split(`
 `);
+  const stillOpen = (named, state) => {
+    const next = state === "answered" ? "fold the answer into the text" : "write the decision into the text";
+    return `${named}, ${state} but still open in version ${latest}: ${next} with dispatch doc-edit, which writes a version that carries it`;
+  };
   const open = blocks.flatMap((block) => {
     const ask = asks.get(block.id);
+    const openers = lines.filter((line) => line.includes(`ask{#${block.id} `) || line.includes(`ask{#${block.id}}`));
+    const states = openers.map((line) => /\bstate="(\w+)"/.exec(line)?.[1]);
     const named = ask === undefined ? `block ${block.id}` : `${JSON.stringify(ask.question)} (block ${block.id}, ask ${ask.id})`;
-    const states = lines.filter((line) => line.includes(`ask{#${block.id} `) || line.includes(`ask{#${block.id}}`)).map((line) => /\bstate="(\w+)"/.exec(line)?.[1]);
     if (states.length === 0)
       return [`${named}, which version ${latest} does not hold yet`];
     if (!states.includes("open") && states.some((state) => state !== undefined))
       return [];
-    if (ask === undefined)
+    if (ask !== undefined)
+      return ask.state === "open" ? [named] : [stillOpen(named, ask.state)];
+    const attribute = (name) => openers.map((line) => new RegExp(`\\b${name}="([^"]+)"`).exec(line)?.[1]).find((value) => value !== undefined);
+    const sourceId = attribute("copied_from");
+    const document = attribute("copied_from_document");
+    if (sourceId === undefined || document === undefined) {
       return [`${named}, whose ask Dispatch has not opened yet`];
-    if (ask.state === "open")
-      return [named];
-    const next = ask.state === "answered" ? "fold the answer into the text" : "write the decision into the text";
-    return [
-      `${named}, ${ask.state} but still open in version ${latest}: ${next} with dispatch doc-edit, which writes a version that carries it`
-    ];
+    }
+    const source = parseDispatchRef(document);
+    const where = source === null ? document : source.owner.kind === "project" ? documentLabel(source.owner.project, source.id) : `${source.owner.issue} ${source.id}`;
+    const ref = source?.owner.kind === "issue" ? dispatchChildRef(dispatchIssueRef(source.owner.issue), "ask", sourceId) : dispatchChildRef(document, "ask", sourceId);
+    return [`${named}, a copy of ask ${ref}, which is open on ${where}: answer it there`];
   });
   if (open.length === 0)
     return;

package/dist/skills/dispatch/references/documents.md

@@ -148,6 +148,20 @@ artifact by the slug the upload printed or by its filename, and a project docume
 slug also arrives on `artifact.created` events. Dispatch suffixes a slug two documents would share, so one document's
 filename can be another's slug (`plan v2` takes `plan-v2`, then a document named `plan-v2` takes `plan-v2-2`): a bare
 `--artifact` that names both is refused with each one's id, while a `dispatch://` reference's document part is always the slug.
+A document you upload holding a copy of another document's `:::ask` block, under the same `#id` and with the same
+question, options, `multiple` and urgency, on the same issue (or the same project for a project document), opens no
+ask: the copy shows the state and answer of the ask it was copied from, names it and its document in `copied_from` and
+`copied_from_document`, and cannot be answered there. Answer the original: its answer or resolution shows on the copy a
+few seconds later. A copy may hold the original's earlier wording, from before someone reworded it. It stays a copy
+while the original is open, and shows an answer or resolution given while the original still asked that wording; an
+answer or resolution given after the rewording decides a question the copy does not ask, so the copy opens its own ask
+instead. A copy whose text you change opens a new ask. Once the original's block leaves its document, its copies share
+one new ask: the first copy to settle opens it and the others name it.
+
+An answered or resolved ask's question is fixed. Editing its block's question, options, `multiple` or urgency in the
+document, or uploading a version that changes them, does not change the ask: a few seconds later the block is written
+back to the question the answer was given on, beside its answer. To ask something new, write a new ask block with its
+own `#id`. An open ask's block is its text: edit it and the ask changes with it.
 
 A picture meant to be seen inline in a message, comment or ask is not uploaded with `dispatch artifact`: pass its local
 path with that command's `--image`, once per picture (PNG, JPEG, GIF or WebP by its bytes, at most 25 MiB each). Each is uploaded to the issue (a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-envoy",
-  "version": "8.14.2",
+  "version": "8.15.0",
   "license": "Apache-2.0",
   "type": "module",
   "omp": {