@openparachute/vault 0.7.3-rc.12 → 0.7.3-rc.2

package/src/storage.test.ts

@@ -30,7 +30,7 @@ const testDir = join(
 process.env.PARACHUTE_HOME = testDir;
 process.env.ASSETS_DIR = join(testDir, "assets");
 
-const { handleStorage, MAX_UPLOAD_BYTES, MAX_REQUEST_BODY_BYTES, parseByteRangeHeader } = await import("./routes.ts");
+const { handleStorage, MAX_UPLOAD_BYTES, MAX_REQUEST_BODY_BYTES } = await import("./routes.ts");
 const { expandTokenTagScope } = await import("./tag-scope.ts");
 
 // The upload-allowlist tests never touch the store (POST /upload writes to
@@ -564,202 +564,3 @@ describe("storage POST parity (finding D)", () => {
     expect(res.status).toBe(404);
   });
 });
-
-// ---------------------------------------------------------------------------
-// REST Range (206) — vault attachments-for-agents design D9, the REST twin
-// of MCP's content_offset/content_length.
-// ---------------------------------------------------------------------------
-
-describe("parseByteRangeHeader", () => {
-  test("no header → null (full response)", () => {
-    expect(parseByteRangeHeader(null, 100)).toBeNull();
-  });
-
-  test("bytes=0-99 on a 100-byte file → the whole file as one satisfiable range", () => {
-    expect(parseByteRangeHeader("bytes=0-99", 100)).toEqual({ start: 0, end: 99 });
-  });
-
-  test("bytes=10-19 → an inclusive mid-file window", () => {
-    expect(parseByteRangeHeader("bytes=10-19", 100)).toEqual({ start: 10, end: 19 });
-  });
-
-  test("bytes=90- (open-ended) → reads to EOF", () => {
-    expect(parseByteRangeHeader("bytes=90-", 100)).toEqual({ start: 90, end: 99 });
-  });
-
-  test("bytes=-10 (suffix range) → the last 10 bytes", () => {
-    expect(parseByteRangeHeader("bytes=-10", 100)).toEqual({ start: 90, end: 99 });
-  });
-
-  test("bytes=-1000 (suffix longer than the file) → clamps to the whole file", () => {
-    expect(parseByteRangeHeader("bytes=-1000", 100)).toEqual({ start: 0, end: 99 });
-  });
-
-  test("bytes=50-1000 (end past EOF) → clamps end to the last byte", () => {
-    expect(parseByteRangeHeader("bytes=50-1000", 100)).toEqual({ start: 50, end: 99 });
-  });
-
-  test("start past EOF → null (this function's own contract; a real Bun.serve() socket overrides with a native 416 — see doc comment)", () => {
-    expect(parseByteRangeHeader("bytes=100-200", 100)).toBeNull();
-    expect(parseByteRangeHeader("bytes=1000-", 100)).toBeNull();
-  });
-
-  test("start > end → null (malformed)", () => {
-    expect(parseByteRangeHeader("bytes=50-10", 100)).toBeNull();
-  });
-
-  test("bytes=- (both empty) → null", () => {
-    expect(parseByteRangeHeader("bytes=-", 100)).toBeNull();
-  });
-
-  test("a multi-range list (bytes=0-10,20-30) → null (ignored per D9, not an error)", () => {
-    expect(parseByteRangeHeader("bytes=0-10,20-30", 100)).toBeNull();
-  });
-
-  test("an unrecognized unit → null", () => {
-    expect(parseByteRangeHeader("items=0-10", 100)).toBeNull();
-  });
-
-  test("garbage value → null, not a throw", () => {
-    expect(parseByteRangeHeader("bytes=abc-def", 100)).toBeNull();
-    expect(parseByteRangeHeader("nonsense", 100)).toBeNull();
-  });
-
-  test("a zero-byte file → null regardless of header (nothing to range over)", () => {
-    expect(parseByteRangeHeader("bytes=0-0", 0)).toBeNull();
-  });
-});
-
-describe("storage GET Range support (vault attachments-for-agents design D9)", () => {
-  const VAULT = "range-vault";
-  // 26 bytes, byte-identical to its own index — content[i] === i (0x00..0x19)
-  // — so any slice's bytes can be asserted exactly by index, not just length.
-  const CONTENT = Buffer.from(Array.from({ length: 26 }, (_, i) => i));
-
-  async function setup(): Promise<{ store: SqliteStore; assets: string; relPath: string }> {
-    const store = freshStore();
-    const assets = join(testDir, "assets", VAULT, "data");
-    mkdirSync(join(assets, "2026-05-28"), { recursive: true });
-    process.env.ASSETS_DIR = assets;
-
-    const relPath = "2026-05-28/ranged.bin";
-    writeFileSync(join(assets, relPath), CONTENT);
-    const note = await store.createNote("range note", { tags: ["misc"] });
-    await store.addAttachment(note.id, relPath, "application/octet-stream");
-
-    return { store, assets, relPath };
-  }
-
-  function getReq(reqPath: string, range?: string): Request {
-    const headers: Record<string, string> = {};
-    if (range !== undefined) headers.range = range;
-    return new Request(`http://localhost:1940/storage/${reqPath}`, { method: "GET", headers });
-  }
-
-  test("no Range header → 200, full body, Accept-Ranges advertised", async () => {
-    const { store, relPath } = await setup();
-    const res = await handleStorage(getReq(relPath), `/${relPath}`, VAULT, store);
-    expect(res.status).toBe(200);
-    expect(res.headers.get("Accept-Ranges")).toBe("bytes");
-    expect(res.headers.get("Content-Length")).toBe("26");
-    expect(res.headers.has("Content-Range")).toBe(false);
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT)).toBe(true);
-  });
-
-  test("Range: bytes=0-9 → 206, first 10 bytes, correct Content-Range", async () => {
-    const { store, relPath } = await setup();
-    const res = await handleStorage(getReq(relPath, "bytes=0-9"), `/${relPath}`, VAULT, store);
-    expect(res.status).toBe(206);
-    expect(res.headers.get("Content-Range")).toBe("bytes 0-9/26");
-    expect(res.headers.get("Content-Length")).toBe("10");
-    expect(res.headers.get("Accept-Ranges")).toBe("bytes");
-    expect(res.headers.get("X-Content-Type-Options")).toBe("nosniff");
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT.subarray(0, 10))).toBe(true);
-  });
-
-  test("Range: bytes=16-25 (to EOF) → 206, correct tail bytes", async () => {
-    const { store, relPath } = await setup();
-    const res = await handleStorage(getReq(relPath, "bytes=16-25"), `/${relPath}`, VAULT, store);
-    expect(res.status).toBe(206);
-    expect(res.headers.get("Content-Range")).toBe("bytes 16-25/26");
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT.subarray(16, 26))).toBe(true);
-  });
-
-  test("Range: bytes=-5 (suffix) → 206, last 5 bytes", async () => {
-    const { store, relPath } = await setup();
-    const res = await handleStorage(getReq(relPath, "bytes=-5"), `/${relPath}`, VAULT, store);
-    expect(res.status).toBe(206);
-    expect(res.headers.get("Content-Range")).toBe("bytes 21-25/26");
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT.subarray(21, 26))).toBe(true);
-  });
-
-  test("paging the whole file via sequential ranges reassembles byte-identical content", async () => {
-    const { store, relPath } = await setup();
-    const chunkSize = 7; // doesn't divide 26 evenly — exercises a short final chunk
-    const chunks: Buffer[] = [];
-    for (let start = 0; start < 26; start += chunkSize) {
-      const end = Math.min(start + chunkSize - 1, 25);
-      const res = await handleStorage(getReq(relPath, `bytes=${start}-${end}`), `/${relPath}`, VAULT, store);
-      expect(res.status).toBe(206);
-      chunks.push(Buffer.from(await res.arrayBuffer()));
-    }
-    expect(Buffer.concat(chunks).equals(CONTENT)).toBe(true);
-  });
-
-  test("a malformed Range header → 200 full response, not an error (D9: ignore, don't fail)", async () => {
-    const { store, relPath } = await setup();
-    const res = await handleStorage(getReq(relPath, "not-a-range"), `/${relPath}`, VAULT, store);
-    expect(res.status).toBe(200);
-    expect(res.headers.has("Content-Range")).toBe(false);
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT)).toBe(true);
-  });
-
-  test("a multi-range Range header → 200 full response (multipart ranges unsupported, ignored per D9)", async () => {
-    const { store, relPath } = await setup();
-    const res = await handleStorage(getReq(relPath, "bytes=0-5,10-15"), `/${relPath}`, VAULT, store);
-    expect(res.status).toBe(200);
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT)).toBe(true);
-  });
-
-  test("an unsatisfiable Range (start past EOF) → handleStorage's OWN logic returns 200 (parseByteRangeHeader's null contract)", async () => {
-    // IMPORTANT — this is NOT the whole live story. `handleStorage` is
-    // called here directly, in-process, so this only exercises OUR
-    // fallback logic (parseByteRangeHeader → null → the unranged 200
-    // branch). Live-verified against a real `Bun.serve()` socket (not
-    // this harness): Bun's own runtime independently reinterprets the
-    // incoming `Range` header on a `Bun.file()`-backed response body and
-    // overrides an out-of-bounds range with a native
-    // **416 Range Not Satisfiable** — RFC 7233-correct, and kept, not
-    // fought. This in-process harness has no socket for Bun's native
-    // layer to intercept, so it can only ever observe the 200 our own
-    // code returns — see `parseByteRangeHeader`'s doc comment
-    // (`src/routes.ts`) for the full explanation.
-    const { store, relPath } = await setup();
-    const res = await handleStorage(getReq(relPath, "bytes=1000-2000"), `/${relPath}`, VAULT, store);
-    expect(res.status).toBe(200);
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT)).toBe(true);
-  });
-
-  test("Range is still honored for a tag-scoped in-scope request (206)", async () => {
-    const { store, relPath } = await setup();
-    const ctx = await tagScopeCtx(store, ["misc"]);
-    const res = await handleStorage(getReq(relPath, "bytes=0-3"), `/${relPath}`, VAULT, store, ctx);
-    expect(res.status).toBe(206);
-    const body = Buffer.from(await res.arrayBuffer());
-    expect(body.equals(CONTENT.subarray(0, 4))).toBe(true);
-  });
-
-  test("Range on an out-of-scope attachment still 404s (same confinement guard, byte-identical to the non-ranged path)", async () => {
-    const { store, relPath } = await setup();
-    const ctx = await tagScopeCtx(store, ["totally-unrelated-tag"]);
-    const res = await handleStorage(getReq(relPath, "bytes=0-3"), `/${relPath}`, VAULT, store, ctx);
-    expect(res.status).toBe(404);
-  });
-});

package/src/transcription-worker.test.ts

@@ -1627,154 +1627,3 @@ describe("transcription worker — legacy in-body memo content safety (finding F
     expect(note!.content).toContain("retry text with $& and $0 and $$ literal");
   });
 });
-
-// ---------------------------------------------------------------------------
-// voice W2 — segmented recordings. The app slices a long recording into
-// ~10-min segments, each linked as its own attachment on ONE note carrying a
-// client-set `segment_index` (0-based). The legacy in-body path targets that
-// part's markers — `_Transcript pending (part N)._` / `_Transcription
-// unavailable (part N)._`, N = segment_index + 1 — so each transcript lands in
-// its own pre-allocated slot regardless of completion order. Marker strings
-// are a BYTE-EXACT cross-door + cross-repo contract (the cloud worker ships
-// the identical text), so these assertions pin the exact bytes.
-// ---------------------------------------------------------------------------
-
-describe("transcription worker — segmented recordings (voice W2)", () => {
-  test("three parts completing OUT OF ORDER (2 ok, 0 fails, 1 ok) each land in their own slot", async () => {
-    // One note, three pre-allocated part slots + the shared stub opt-in.
-    const body =
-      "# 🎙️ Voice memo\n\n" +
-      "_Transcript pending (part 1)._\n\n" +
-      "_Transcript pending (part 2)._\n\n" +
-      "_Transcript pending (part 3)._\n";
-    await store.createNote(body, { id: "seg-note", metadata: { transcribe_stub: true } });
-
-    seedAudio("memos/seg0.webm");
-    seedAudio("memos/seg1.webm");
-    seedAudio("memos/seg2.webm");
-    const seg0 = await store.addAttachment("seg-note", "memos/seg0.webm", "audio/webm", {
-      transcribe_status: "pending",
-      segment_index: 0,
-    });
-    const seg1 = await store.addAttachment("seg-note", "memos/seg1.webm", "audio/webm", {
-      transcribe_status: "pending",
-      segment_index: 1,
-    });
-    const seg2 = await store.addAttachment("seg-note", "memos/seg2.webm", "audio/webm", {
-      transcribe_status: "pending",
-      segment_index: 2,
-    });
-
-    // Complete part 3 (segment_index 2) FIRST — success.
-    const w2 = makeWorker({ fetchImpl: mkFetchMock([{ text: "part three text" }]) });
-    try { await w2.kick("default", seg2); } finally { await w2.stop(); }
-
-    // Then part 1 (segment_index 0) — terminal failure (maxAttempts=1).
-    const w0 = makeWorker({
-      fetchImpl: mkFetchMock([{ error: "scribe down", status: 500 }]),
-      maxAttempts: 1,
-    });
-    try { await w0.kick("default", seg0); } finally { await w0.stop(); }
-
-    // Finally part 2 (segment_index 1) — success.
-    const w1 = makeWorker({ fetchImpl: mkFetchMock([{ text: "part two text" }]) });
-    try { await w1.kick("default", seg1); } finally { await w1.stop(); }
-
-    const note = await store.getNote("seg-note");
-    // Each part landed in its own slot: part 1 → failure marker, part 2/3 →
-    // their transcripts, despite completing 3 → 1 → 2.
-    expect(note!.content).toBe(
-      "# 🎙️ Voice memo\n\n" +
-      "_Transcription unavailable (part 1)._\n\n" +
-      "part two text\n\n" +
-      "part three text\n",
-    );
-    // Shared stub SURVIVES — sibling parts each needed the gate open; a
-    // per-part clear (the un-segmented behavior) would have blocked parts 2 & 3.
-    expect((note!.metadata as any)?.transcribe_stub).toBe(true);
-
-    // Attachment rows reflect their individual outcomes.
-    const atts = await store.getAttachments("seg-note");
-    const byIndex = Object.fromEntries(atts.map((a) => [a.metadata?.segment_index, a]));
-    expect(byIndex[0]!.metadata?.transcribe_status).toBe("failed");
-    expect(byIndex[1]!.metadata?.transcribe_status).toBe("done");
-    expect(byIndex[1]!.metadata?.transcript).toBe("part two text");
-    expect(byIndex[2]!.metadata?.transcribe_status).toBe("done");
-    expect(byIndex[2]!.metadata?.transcript).toBe("part three text");
-  });
-
-  test("un-segmented attachment → BARE markers, one-shot stub cleared (regression pin)", async () => {
-    // No `segment_index` → byte-for-byte the pre-W2 behavior: replace the bare
-    // placeholder, clear the stub. A stray `(part N)` marker in the body is
-    // left untouched (the bare path never targets part markers).
-    await store.createNote(
-      "# 🎙️ Voice memo\n\n_Transcript pending._\n\n_Transcript pending (part 2)._\n",
-      { id: "unseg-note", metadata: { transcribe_stub: true } },
-    );
-    seedAudio("memos/unseg.webm");
-    const att = await store.addAttachment("unseg-note", "memos/unseg.webm", "audio/webm", {
-      transcribe_status: "pending",
-    });
-
-    const worker = makeWorker({ fetchImpl: mkFetchMock([{ text: "bare transcript" }]) });
-    try { await worker.kick("default", att); } finally { await worker.stop(); }
-
-    const note = await store.getNote("unseg-note");
-    // Bare marker replaced; the part-2 marker is NOT touched by the bare path.
-    expect(note!.content).toBe(
-      "# 🎙️ Voice memo\n\nbare transcript\n\n_Transcript pending (part 2)._\n",
-    );
-    // One-shot stub cleared, exactly as today.
-    expect((note!.metadata as any)?.transcribe_stub).toBeUndefined();
-  });
-
-  test("malformed segment_index falls back to bare markers (contract: integer ≥ 0)", async () => {
-    // A non-integer / negative `segment_index` must NOT fabricate a `(part N)`
-    // marker — it degrades to the bare path (fully backward compatible).
-    await store.createNote(
-      "# 🎙️ Voice memo\n\n_Transcript pending._\n",
-      { id: "seg-bad", metadata: { transcribe_stub: true } },
-    );
-    seedAudio("memos/segbad.webm");
-    const att = await store.addAttachment("seg-bad", "memos/segbad.webm", "audio/webm", {
-      transcribe_status: "pending",
-      segment_index: -1, // invalid → bare path
-    });
-
-    const worker = makeWorker({ fetchImpl: mkFetchMock([{ text: "fallback transcript" }]) });
-    try { await worker.kick("default", att); } finally { await worker.stop(); }
-
-    const note = await store.getNote("seg-bad");
-    expect(note!.content).toBe("# 🎙️ Voice memo\n\nfallback transcript\n");
-    expect((note!.metadata as any)?.transcribe_stub).toBeUndefined();
-  });
-
-  test("segmented part whose marker was edited away → transcript appended (graceful fallback)", async () => {
-    // The user rewrote part 2's slot by hand, removing its pending marker.
-    // Mirror the un-segmented replace-or-append policy scoped to the part:
-    // with neither of part 2's markers present, append the transcript
-    // (no `(part N)` prefix) rather than destroying the user's edit.
-    const editedBody =
-      "# 🎙️ Voice memo\n\n" +
-      "_Transcript pending (part 1)._\n\n" +
-      "User rewrote part two by hand.\n";
-    await store.createNote(editedBody, { id: "seg-edit", metadata: { transcribe_stub: true } });
-    seedAudio("memos/segedit.webm");
-    const seg1 = await store.addAttachment("seg-edit", "memos/segedit.webm", "audio/webm", {
-      transcribe_status: "pending",
-      segment_index: 1, // part 2
-    });
-
-    const worker = makeWorker({ fetchImpl: mkFetchMock([{ text: "the real part two" }]) });
-    try { await worker.kick("default", seg1); } finally { await worker.stop(); }
-
-    const note = await store.getNote("seg-edit");
-    // Part 2's transcript appended; the user's edit + part 1's pending slot
-    // both survive untouched.
-    expect(note!.content).toBe(`${editedBody}\n\nthe real part two`);
-    expect(note!.content).toContain("User rewrote part two by hand.");
-    expect(note!.content).toContain("_Transcript pending (part 1)._");
-    // Segmented → shared stub preserved (part 1 still needs the gate open).
-    expect((note!.metadata as any)?.transcribe_stub).toBe(true);
-  });
-});

package/src/transcription-worker.ts

@@ -64,57 +64,41 @@ import {
 } from "../core/src/transcription/provider.ts";
 import { ScribeHttpProvider } from "./transcription/providers/scribe-http.ts";
 
+/** Placeholder pattern written by the voice-memo capture stub. */
+const TRANSCRIPT_PLACEHOLDER = /_Transcript pending\._/;
+
 /**
- * The in-body transcription markers.
- *
- * The BARE markers are the un-segmented default; voice W2 (segmented
- * recordings) targets per-part variants built by `markersFor`. Both are a
- * BYTE-EXACT cross-door + cross-repo contract — the cloud Workers-AI
- * transcription path ships the identical strings, and the notes-ui status
- * chip (parachute-surface TranscriptionStatus.tsx) keys off the failure
- * marker's exact copy. Don't change any of this text without a coordinated
- * change in both places. A friendlier "retry available" copy + chip
- * affordance is a tracked parachute-surface follow-up.
+ * Body written when transcription reaches a terminal failure (maxAttempts
+ * exhausted, or the audio file is missing). This used to be written by
+ * Lens's now-removed scribe client; owning it here means a failed upload
+ * stops reading "Transcript pending" forever regardless of which client
+ * uploaded the audio.
  *
- * Owning the failure marker here (it used to be written by Lens's now-removed
- * scribe client) means a failed upload stops reading "Transcript pending"
- * forever regardless of which client uploaded the audio.
+ * NOTE: the notes-ui status chip (parachute-surface TranscriptionStatus.tsx)
+ * keys off this exact string, so don't change the copy without a coordinated
+ * change there. A friendlier "retry available" copy + chip affordance is a
+ * tracked parachute-surface follow-up.
  */
-const BARE_PENDING = "_Transcript pending._";
-const BARE_UNAVAILABLE = "_Transcription unavailable._";
-
-/** Escape a literal string for safe embedding in a `RegExp`. */
-function escapeRegExp(literal: string): string {
-  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+const TRANSCRIPT_UNAVAILABLE = "_Transcription unavailable._";
 
 /**
- * The pending + terminal-failure markers for an attachment, honoring
- * `segment_index` (voice W2 — segmented recordings). `undefined` yields the
- * bare markers (fully backward compatible — un-segmented flows are byte-
- * unchanged). An integer ≥ 0 yields this part's markers, with the human-
- * facing part number N = segment_index + 1 (1-based, decimal):
- *   `_Transcript pending (part N)._` / `_Transcription unavailable (part N)._`
- */
-function markersFor(segmentIndex: number | undefined): { pending: string; unavailable: string } {
-  if (segmentIndex === undefined) return { pending: BARE_PENDING, unavailable: BARE_UNAVAILABLE };
-  const n = segmentIndex + 1;
-  return {
-    pending: `_Transcript pending (part ${n})._`,
-    unavailable: `_Transcription unavailable (part ${n})._`,
-  };
-}
-
-/**
- * A valid segment index (integer ≥ 0) off attachment metadata, else
- * `undefined` — the un-segmented path. Client-set at link time; anything that
- * isn't a non-negative integer falls back to the bare markers rather than
- * fabricating a `(part N)`.
+ * On a successful (re)transcription of a legacy in-body memo, the transcript
+ * replaces whichever marker is currently in the body — the original
+ * `_Transcript pending._` on a first-try success, OR `_Transcription
+ * unavailable._` if a prior attempt failed and we're now retrying. Matching
+ * both means a retried success lands in the same spot a first-try success
+ * would, preserving the surrounding capture body (the `![[memo]]` embed,
+ * the `_Recorded …_` line, the header).
+ *
+ * Deliberately NO `/g` flag — `.replace` swaps only the FIRST match. A
+ * canonical capture body holds exactly one marker, so first-match is the
+ * correct target. `applyFailureMarker`'s includes-guard (no-op when the
+ * marker is already present) prevents markers accumulating across repeated
+ * terminal failures, so the body never carries two of the same marker. A
+ * hand-edited body that somehow contains both markers patches only the
+ * first — accepted (degenerate, operator-induced).
  */
-function segmentIndexOf(meta: { segment_index?: unknown }): number | undefined {
-  const raw = meta.segment_index;
-  return typeof raw === "number" && Number.isInteger(raw) && raw >= 0 ? raw : undefined;
-}
+const TRANSCRIPT_SUCCESS_TARGET = /_Transcript pending\._|_Transcription unavailable\._/;
 
 /**
  * Default sweep cadence (ms). The sweep is the safety net for backoff-
@@ -211,14 +195,6 @@ interface PendingMeta {
    * worker preserves the original stub-patching behavior (Lens flow).
    */
   transcribe_origin?: "auto" | "legacy";
-  /**
-   * Voice W2 (segmented recordings): a client-set 0-based index marking this
-   * attachment as one segment of a longer recording sliced into ~10-min parts,
-   * all linked on ONE note. When present, the legacy in-body path targets this
-   * part's markers (`… (part N)._`, N = segment_index + 1) rather than the bare
-   * ones — making per-part ordering structurally guaranteed. See `markersFor`.
-   */
-  segment_index?: number;
   [k: string]: unknown;
 }
 
@@ -381,28 +357,17 @@ export function startTranscriptionWorker(opts: TranscriptionWorkerOpts): Transcr
    * attachment failure we're trying to record.
    *
    * Body policy (finding F — never destroy content):
-   *   - Pending marker PRESENT → surgical replace of the pending marker with
-   *     the failure marker. The `![[memo]]` embed + any surrounding text
-   *     survive. For a segmented attachment (`segment_index` set) this is the
-   *     per-part `_Transcript pending (part N)._`; otherwise the bare marker.
-   *   - Failure marker ALREADY PRESENT → no-op (idempotent; a double-terminal-
-   *     failure must not stack markers).
-   *   - Otherwise (pending marker absent — the user edited the note while it
-   *     was pending) → APPEND `\n\n` + failure marker to the existing content.
-   *     The old code full-replaced the body here, destroying the embed AND the
-   *     user's edits. We append instead so nothing is lost. If the content is
-   *     empty, the marker alone becomes the body (avoids a leading blank line).
+   *   - Placeholder PRESENT → surgical replace of `_Transcript pending._`
+   *     with the marker. The `![[memo]]` embed + any surrounding text survive.
+   *   - Marker ALREADY PRESENT → no-op (idempotent; a double-terminal-failure
+   *     must not stack markers).
+   *   - Otherwise (placeholder absent — the user edited the note while it was
+   *     pending) → APPEND `\n\n` + marker to the existing content. The old
+   *     code full-replaced the body here, destroying the embed AND the user's
+   *     edits. We append instead so nothing is lost. If the content is empty,
+   *     the marker alone becomes the body (avoids a leading blank line).
    */
-  async function applyFailureMarker(
-    store: Store,
-    noteId: string,
-    segmentIndex: number | undefined,
-  ): Promise<void> {
-    // Bare markers by default; this segment's `(part N)` markers when the
-    // attachment carries a `segment_index` (voice W2). String-search replace
-    // targets the FIRST occurrence (a canonical body holds exactly one), and
-    // the includes-guard below keeps a repeated terminal failure from stacking.
-    const { pending, unavailable } = markersFor(segmentIndex);
+  async function applyFailureMarker(store: Store, noteId: string): Promise<void> {
     // OC-guarded (vault#435): the read-transform-write below is re-run against
     // fresh content on a conflict so a concurrent user edit isn't clobbered.
     // The transform is pure w.r.t. the note it's handed; the stub-set and
@@ -416,24 +381,17 @@ export function startTranscriptionWorker(opts: TranscriptionWorkerOpts): Transcr
         if (noteMeta.transcribe_stub !== true) return null;
 
         let body: string;
-        if (note.content.includes(pending)) {
-          // Function replacer so the search string is treated literally and the
-          // (fixed) failure marker is inserted verbatim.
-          body = note.content.replace(pending, () => unavailable);
-        } else if (note.content.includes(unavailable)) {
+        if (TRANSCRIPT_PLACEHOLDER.test(note.content)) {
+          body = note.content.replace(TRANSCRIPT_PLACEHOLDER, TRANSCRIPT_UNAVAILABLE);
+        } else if (note.content.includes(TRANSCRIPT_UNAVAILABLE)) {
           // Marker already present — nothing to do. Clear the stub and
           // return without rewriting the body so we don't stack markers.
           body = note.content;
         } else {
           body = note.content.length > 0
-            ? `${note.content}\n\n${unavailable}`
-            : unavailable;
+            ? `${note.content}\n\n${TRANSCRIPT_UNAVAILABLE}`
+            : TRANSCRIPT_UNAVAILABLE;
         }
-        // Segmented: the stub is SHARED across this note's parts — keep it set
-        // so sibling parts still resolve their own slots. Return content only
-        // (leave note metadata untouched). Un-segmented: clear the one-shot
-        // stub as before (byte-unchanged).
-        if (segmentIndex !== undefined) return { content: body };
         const { transcribe_stub: _drop, ...restMeta } = noteMeta;
         return { content: body, metadata: restMeta };
       },
@@ -491,12 +449,6 @@ export function startTranscriptionWorker(opts: TranscriptionWorkerOpts): Transcr
     // vs. the legacy stub-patching path (Lens flow). Auto-write notes also
     // surface failures so the user can retry from the transcript note.
     const isAutoOrigin = meta.transcribe_origin === "auto";
-    // Voice W2: when this attachment is one segment of a longer recording
-    // (client-set `segment_index`), the legacy in-body path targets this
-    // part's markers instead of the bare ones. Undefined for un-segmented
-    // attachments — byte-unchanged behavior. Only the legacy path consults it;
-    // the auto/transcript-note path is untouched (segments are a memo concern).
-    const segmentIndex = segmentIndexOf(meta);
 
     // Honor backoff — we re-check here in case another tick queued this
     // attachment between the listing and now.
@@ -517,7 +469,7 @@ export function startTranscriptionWorker(opts: TranscriptionWorkerOpts): Transcr
       if (isAutoOrigin) {
         await writeFailureTranscriptNote(store, attachment, "audio file not found", undefined, undefined);
       } else {
-        await applyFailureMarker(store, attachment.noteId, segmentIndex);
+        await applyFailureMarker(store, attachment.noteId);
       }
       return;
     }
@@ -575,7 +527,7 @@ export function startTranscriptionWorker(opts: TranscriptionWorkerOpts): Transcr
         if (isAutoOrigin) {
           await writeFailureTranscriptNote(store, attachment, errMsg, apiErr?.code, undefined);
         } else {
-          await applyFailureMarker(store, attachment.noteId, segmentIndex);
+          await applyFailureMarker(store, attachment.noteId);
         }
         // retention=never drops the audio on any terminal state, including
         // failure. The user opted in to "I don't want the audio kept around
@@ -626,16 +578,6 @@ export function startTranscriptionWorker(opts: TranscriptionWorkerOpts): Transcr
       // before the transcript arrives opts out of the overwrite. OC-guarded
       // (vault#435): re-applied against fresh content on a conflict so a
       // concurrent user edit isn't clobbered.
-      //
-      // Success replaces whichever of THIS part's markers is present (bare, or
-      // `(part N)` when segmented). Built with no `/g` flag so `.replace`
-      // swaps only the FIRST match — a canonical capture body holds exactly
-      // one marker per part; alternation preserves positional-first semantics
-      // (a retried success replaces the failure marker where a first-try
-      // success replaced the pending one) so byte-for-byte matching today's
-      // un-segmented behavior.
-      const { pending, unavailable } = markersFor(segmentIndex);
-      const successTarget = new RegExp(`${escapeRegExp(pending)}|${escapeRegExp(unavailable)}`);
       await applyNoteTransformWithOC(
         store,
         attachment.noteId,
@@ -644,31 +586,28 @@ export function startTranscriptionWorker(opts: TranscriptionWorkerOpts): Transcr
           const noteMeta = (note.metadata as Record<string, unknown> | undefined) ?? {};
           if (noteMeta.transcribe_stub !== true) return null;
           // Body policy (finding F — never destroy content):
-          //   - pending OR failure marker present → surgical replace in place.
-          //     The embed + surrounding capture body survive.
+          //   - placeholder OR failure-marker present → surgical replace in
+          //     place (a retried success replaces the `_Transcription
+          //     unavailable._` marker, landing exactly where a first-try
+          //     success would). The embed + surrounding capture body survive.
           //   - neither present (user edited the note while pending) → APPEND
           //     the transcript instead of full-replacing the body, so the
           //     user's edits + the `![[memo]]` embed are preserved. The old
           //     code full-replaced here, which destroyed both.
           let body: string;
-          if (successTarget.test(note.content)) {
+          if (TRANSCRIPT_SUCCESS_TARGET.test(note.content)) {
             // Function replacer, NOT a string — speech-to-text is arbitrary
             // user content, and String.replace treats `$&`, `$\``, `$'`,
             // `$1`-`$9` as special patterns in a string replacement. A
             // transcript containing `$&` would otherwise inject the matched
             // marker text into the body. `() => transcript` returns the text
             // verbatim.
-            body = note.content.replace(successTarget, () => transcript);
+            body = note.content.replace(TRANSCRIPT_SUCCESS_TARGET, () => transcript);
           } else {
             body = note.content.length > 0
               ? `${note.content}\n\n${transcript}`
               : transcript;
           }
-          // Segmented: the stub is SHARED across this note's parts — keep it
-          // set so sibling parts still resolve their own slots. Return content
-          // only (leave note metadata untouched). Un-segmented: clear the
-          // one-shot stub as before (byte-unchanged).
-          if (segmentIndex !== undefined) return { content: body };
           const { transcribe_stub: _drop, ...restMeta } = noteMeta;
           return { content: body, metadata: restMeta };
         },