@tangle-network/agent-app 0.44.8 → 0.44.10

package/dist/{types-XIZqIdX1.d.ts → types-DeEOhQbv.d.ts}

@@ -38,13 +38,35 @@ interface WorkProductArtifact {
     /** The structured field map lineage targets anchor to (tax: form-line ids). */
     fields?: Record<string, unknown>;
 }
-/** Point into a source document: page, free-form range, verbatim quote */
+/** A half-open `[start, end)` character range into the source document's text.
+ *  Offsets index exactly the string the product's `readSourceText` seam
+ *  returns for the same `sourceRef` — which is the string its document-reading
+ *  tool pages with an `offset`. The PLATFORM slices `locator.quote` out of it,
+ *  so a span citation cannot name text the document does not contain. */
+interface EvidenceSpan {
+    start: number;
+    end: number;
+}
+/** How `locator.quote` got there. Server-set on every path — never read from
+ *  model args, because the whole value of the distinction is that a reviewer
+ *  can trust it:
+ *   - `span`  the platform sliced it out of the source bytes (unfalsifiable)
+ *   - `model` the model supplied the text and the platform PROVED it occurs */
+type QuoteBasis = 'span' | 'model';
+/** Point into a source document: page, free-form range, span, verbatim quote */
 interface EvidenceLocator {
     page?: number;
     /** 'L120-L134' | 'B7' | '¶4' — free-form, non-empty when present. */
     range?: string;
-    /** Verbatim supporting quote from the source. */
+    /** Verbatim supporting quote from the source. Model-supplied and verified,
+     *  or platform-sliced from {@link EvidenceLocator.span} — read `quoteBasis`
+     *  to tell which. */
     quote?: string;
+    /** Character range the quote is sliced from. The preferred citation form:
+     *  two integers cannot be a fabricated quote. */
+    span?: EvidenceSpan;
+    /** Server-set provenance for `quote`; a model-supplied value is discarded. */
+    quoteBasis?: QuoteBasis;
 }
 /** One lineage row: a source document location supporting one artifact claim */
 interface EvidenceEntry {
@@ -265,4 +287,4 @@ declare function workProductToPersistedPart(record: WorkProductRecord): WorkProd
 /** Re-validate a stored/wire part into the typed anchor; null for junk. */
 declare function persistedPartToWorkProduct(part: Record<string, unknown>): WorkProductPersistedPart | null;
 
-export { type AgentCheckInput as A, type EvidenceEntry as E, type ProfileBacktestSummary as P, type QualityCheck as Q, type WorkProductRef as W, type WorkProductProvenance as a, type WorkProductRecord as b, type WorkProductPersistedPart as c, type WorkProductStorePort as d, type WorkProductAuditEvent as e, type WorkProductArtifact as f, type ExceptionEntry as g, type WorkProductStatus as h, type EvidenceLocator as i, type ExceptionSeverity as j, type WorkProductParseResult as k, type WorkProductPatch as l, type WorkProductUpdateGuard as m, type WorkProductVersionEntry as n, isWorkProductStatus as o, parseAgentCheckInput as p, parseArtifactInput as q, parseEvidenceInput as r, parseExceptionInput as s, persistedPartToWorkProduct as t, unresolvedBlockingExceptions as u, workProductToPersistedPart as w };
+export { type AgentCheckInput as A, type EvidenceEntry as E, type ProfileBacktestSummary as P, type QualityCheck as Q, type WorkProductRef as W, type WorkProductProvenance as a, type WorkProductRecord as b, type WorkProductPersistedPart as c, type WorkProductStorePort as d, type WorkProductAuditEvent as e, type WorkProductArtifact as f, type ExceptionEntry as g, type WorkProductStatus as h, type EvidenceLocator as i, type EvidenceSpan as j, type ExceptionSeverity as k, type QuoteBasis as l, type WorkProductParseResult as m, type WorkProductPatch as n, type WorkProductUpdateGuard as o, type WorkProductVersionEntry as p, isWorkProductStatus as q, parseAgentCheckInput as r, parseArtifactInput as s, parseEvidenceInput as t, parseExceptionInput as u, persistedPartToWorkProduct as v, unresolvedBlockingExceptions as w, workProductToPersistedPart as x };

package/dist/web-react/index.d.ts

@@ -5,17 +5,17 @@ export { f as ChatFreeTextField, g as ComposerAnswerDelivery, h as INTERACTION_C
 import { ChatPlan } from '../plans/index.js';
 import { InteractionData } from '@tangle-network/agent-interface';
 export { InteractionData, InteractionOutcome, InteractionRequest } from '@tangle-network/agent-interface';
-import { M as FileMention, g as ChatMentionPart, b as ChatAttachmentPart, a as ChatAttachmentKind, Q as ChatAttachmentInput } from '../parts-Co_lFgLI.js';
-export { f as ChatMentionKind, P as ChatTurnFilePartInput, O as ChatTurnPartInput, N as ChatTurnRequestPayload, U as DISPATCH_MAX_MEDIA_PARTS, V as DISPATCH_MAX_PARTS, W as DISPATCH_REQUEST_MAX_BYTES, X as DISPATCH_STRUCTURAL_RESERVE_BYTES, $ as ProducerErrorEvent, a0 as ProducerNoticeEvent, a1 as ProducerPassthroughEvent, a2 as ProducerPassthroughEventType, a3 as ProducerReasoningEvent, a4 as ProducerTextEvent, a5 as ProducerToolCallEvent, a6 as ProducerToolResultEvent, a7 as ProducerUsageEvent, a8 as ProducerWireEvent, u as attachmentInputToPart, v as attachmentKindForMime, w as attachmentPartsFromMessageParts, ab as base64WireLen, ac as buildMentionPromptBlock, ad as chatTurnRequestInit, ae as fileMentionsToParts, z as isChatAttachmentPart, ag as mediaTypeForMentionPath, J as mentionInputToPart, ah as mentionKindForPath, K as mentionPartsFromMessageParts } from '../parts-Co_lFgLI.js';
-import { E as EvidenceEntry, g as ExceptionEntry, a as WorkProductProvenance, P as ProfileBacktestSummary, Q as QualityCheck, c as WorkProductPersistedPart, h as WorkProductStatus } from '../types-XIZqIdX1.js';
+import { M as FileMention, g as ChatMentionPart, b as ChatAttachmentPart, a as ChatAttachmentKind, Q as ChatAttachmentInput } from '../parts-DIKcC1p6.js';
+export { f as ChatMentionKind, P as ChatTurnFilePartInput, O as ChatTurnPartInput, N as ChatTurnRequestPayload, U as DISPATCH_MAX_MEDIA_PARTS, V as DISPATCH_MAX_PARTS, W as DISPATCH_REQUEST_MAX_BYTES, X as DISPATCH_STRUCTURAL_RESERVE_BYTES, $ as ProducerErrorEvent, a0 as ProducerNoticeEvent, a1 as ProducerPassthroughEvent, a2 as ProducerPassthroughEventType, a3 as ProducerReasoningEvent, a4 as ProducerTextEvent, a5 as ProducerToolCallEvent, a6 as ProducerToolResultEvent, a7 as ProducerUsageEvent, a8 as ProducerWireEvent, u as attachmentInputToPart, v as attachmentKindForMime, w as attachmentPartsFromMessageParts, ab as base64WireLen, ac as buildMentionPromptBlock, ad as chatTurnRequestInit, ae as fileMentionsToParts, z as isChatAttachmentPart, ag as mediaTypeForMentionPath, J as mentionInputToPart, ah as mentionKindForPath, K as mentionPartsFromMessageParts } from '../parts-DIKcC1p6.js';
+import { E as EvidenceEntry, g as ExceptionEntry, a as WorkProductProvenance, P as ProfileBacktestSummary, Q as QualityCheck, c as WorkProductPersistedPart, h as WorkProductStatus } from '../types-DeEOhQbv.js';
 import { S as StepAgentActivity } from '../agent-activity-C8ZG0F0M.js';
 import { F as FlowTrace } from '../flow-types-CJxEmaRy.js';
-import { a as ReviewQueueItem, c as ReviewQueueState } from '../queue-CD5-_VTX.js';
-export { p as parseReviewQueueItem } from '../queue-CD5-_VTX.js';
+import { a as ReviewQueueItem, c as ReviewQueueState } from '../queue-DBkulxW1.js';
+export { p as parseReviewQueueItem } from '../queue-DBkulxW1.js';
 export { S as SandboxTerminalConnection, a as SandboxTerminalConnectionResponse, U as UseSandboxTerminalConnectionOptions, b as UseSandboxTerminalConnectionResult, t as tabTerminalConnectionId, u as useSandboxTerminalConnection } from '../sandbox-terminal-ChNEdHF8.js';
 import { CatalogModel } from '../catalog/index.js';
 import { Harness } from '../harness/index.js';
-export { a as ATTACHMENT_ACCEPT, e as FileIndexReadyResponse, f as FileIndexResponse, g as FileIndexWarmingResponse } from '../attachment-validation-DRuLEjAE.js';
+export { a as ATTACHMENT_ACCEPT, e as FileIndexReadyResponse, f as FileIndexResponse, g as FileIndexWarmingResponse } from '../attachment-validation-yJ6Id4pR.js';
 export { a as attachmentPartKey } from '../stream-normalizer-DnuqkZvw.js';
 
 /** Represent durable plan decisions as either approved or rejected */

package/dist/web-react/index.js

@@ -74,7 +74,7 @@ import {
   useSmoothText,
   useThinkingSeconds,
   waterfallLayout
-} from "../chunk-TKRI463Z.js";
+} from "../chunk-J6TNPRQN.js";
 import "../chunk-FBVLEGEG.js";
 import {
   EvidenceLineageTable,
@@ -87,17 +87,17 @@ import {
   reviewQueueStateLabel,
   workProductPartsFromMessageParts,
   workProductStatusLabel
-} from "../chunk-UDSY2F6N.js";
+} from "../chunk-72TPRENZ.js";
 import {
   parseReviewQueueItem
-} from "../chunk-UP33Z633.js";
+} from "../chunk-ZRSUCTST.js";
 import {
   tabTerminalConnectionId,
   useSandboxTerminalConnection
 } from "../chunk-HCOROIRT.js";
 import {
   ATTACHMENT_ACCEPT
-} from "../chunk-V55WJSR4.js";
+} from "../chunk-5GA3MKOC.js";
 import {
   DISPATCH_MAX_MEDIA_PARTS,
   DISPATCH_MAX_PARTS,
@@ -115,8 +115,8 @@ import {
   mentionInputToPart,
   mentionKindForPath,
   mentionPartsFromMessageParts
-} from "../chunk-AFNTRJQ7.js";
-import "../chunk-F2CBC4DY.js";
+} from "../chunk-FEUW4G2L.js";
+import "../chunk-V3HO43PG.js";
 import {
   attachmentPartKey
 } from "../chunk-5EPIPT4V.js";

package/dist/work-product/index.d.ts

@@ -1,9 +1,9 @@
-import { a as WorkProductProvenance, d as WorkProductStorePort, e as WorkProductAuditEvent, b as WorkProductRecord, f as WorkProductArtifact, Q as QualityCheck, E as EvidenceEntry, g as ExceptionEntry, h as WorkProductStatus, c as WorkProductPersistedPart } from '../types-XIZqIdX1.js';
-export { A as AgentCheckInput, i as EvidenceLocator, j as ExceptionSeverity, P as ProfileBacktestSummary, k as WorkProductParseResult, l as WorkProductPatch, W as WorkProductRef, m as WorkProductUpdateGuard, n as WorkProductVersionEntry, o as isWorkProductStatus, p as parseAgentCheckInput, q as parseArtifactInput, r as parseEvidenceInput, s as parseExceptionInput, t as persistedPartToWorkProduct, u as unresolvedBlockingExceptions, w as workProductToPersistedPart } from '../types-XIZqIdX1.js';
+import { a as WorkProductProvenance, d as WorkProductStorePort, e as WorkProductAuditEvent, b as WorkProductRecord, f as WorkProductArtifact, Q as QualityCheck, E as EvidenceEntry, g as ExceptionEntry, h as WorkProductStatus, c as WorkProductPersistedPart } from '../types-DeEOhQbv.js';
+export { A as AgentCheckInput, i as EvidenceLocator, j as EvidenceSpan, k as ExceptionSeverity, P as ProfileBacktestSummary, l as QuoteBasis, m as WorkProductParseResult, n as WorkProductPatch, W as WorkProductRef, o as WorkProductUpdateGuard, p as WorkProductVersionEntry, q as isWorkProductStatus, r as parseAgentCheckInput, s as parseArtifactInput, t as parseEvidenceInput, u as parseExceptionInput, v as persistedPartToWorkProduct, w as unresolvedBlockingExceptions, x as workProductToPersistedPart } from '../types-DeEOhQbv.js';
 import { a as AppToolContext, c as AppToolDefinition } from '../types-BCxK0wyS.js';
 import { JudgeVerdict } from '@tangle-network/agent-eval';
 import { T as TrustItem } from '../trust-gate-Dcm5xSva.js';
-export { R as ReviewQueueInputs, a as ReviewQueueItem, b as ReviewQueuePendingAsk, c as ReviewQueueState, d as ReviewQueueThread, p as parseReviewQueueItem, e as projectReviewQueue } from '../queue-CD5-_VTX.js';
+export { R as ReviewQueueInputs, a as ReviewQueueItem, b as ReviewQueuePendingAsk, c as ReviewQueueState, d as ReviewQueueThread, p as parseReviewQueueItem, e as projectReviewQueue } from '../queue-DBkulxW1.js';
 
 /**
  * The guarded work-product status machine — the `/missions` service PATTERN
@@ -242,8 +242,22 @@ interface WorkProductToolConfig {
      *  Omit the seam entirely and no quote is checked. */
     readSourceText?: (ref: string, ctx: AppToolContext) => Promise<string | null>;
     /** The material targets the platform coverage check requires evidence for.
-     *  Product-owned vocabulary; omit to skip the coverage gate. */
+     *  Product-owned vocabulary; omit to skip the coverage gate.
+     *
+     *  Return ONLY targets a source document can actually evidence. A gate that
+     *  demands document lineage for a value the session COMPUTED is not
+     *  satisfiable by any honest answer, and an unsatisfiable gate does not stop
+     *  a submit — it selects for an invented one. Computed values belong to a
+     *  product's own computation check, where "matches what we already
+     *  calculated" is satisfiable by construction. */
     materialTargets?: (artifact: WorkProductArtifact) => string[];
+    /** Require every material target to carry a SOURCE ANCHOR — a span-sliced or
+     *  verified quote — not merely an evidence row. Off by default (a bare
+     *  `claim` is legitimate lineage for products with no readable sources);
+     *  turn it ON once `readSourceText` is wired and `materialTargets` names only
+     *  document-derived targets, and coverage stops being satisfiable by
+     *  assertion. */
+    requireAnchoredEvidence?: boolean;
     /** Per-turn provenance closure the ROUTE supplies (profileHash + runId are
      *  known at dispatch; trusted, never read from model args). */
     provenance: (ctx: AppToolContext) => WorkProductProvenanceBase;
@@ -292,6 +306,60 @@ declare function normalizeQuoteText(value: string): string;
  * substring of every document and pass the gate vacuously.
  */
 declare function sourceContainsQuote(sourceText: string, quote: string): boolean;
+/**
+ * Slice a citation out of the source text by character offset — the reason
+ * this module exists in its stronger form.
+ *
+ * Verification above is a REJECTION gate: the model retypes a quote and the
+ * shell refuses it when the characters do not occur. That gate is correct and
+ * it works, but a model that reproduces a line character-for-character only
+ * some of the time cannot USE it — every miss is a refusal, and the package
+ * ends up with no lineage at all rather than false lineage. A measured 9 of 59
+ * on the live tax surface is what "some of the time" meant in practice.
+ *
+ * A span inverts it. The model names two integers into text it just read; the
+ * PLATFORM produces the quote from the bytes it already holds. There is no
+ * retyping step to get wrong, so a fabricated quote is not rejected — it is
+ * unrepresentable. `sourceContainsQuote(text, sliceSourceSpan(text, span))` is
+ * true for every span this function returns, by construction.
+ *
+ * Offsets index the SAME string the product's document-reading tool pages
+ * with an offset, which is the same string its `readSourceText` seam returns.
+ * That is the one contract a product must keep; violate it and spans point at
+ * the wrong characters (still real characters of that document — never
+ * invented text, but the wrong line).
+ *
+ * Half-open `[start, end)`, matching `String.prototype.slice` and the
+ * `offset`/`offset + text.length` window a paged read already reports.
+ */
+type SourceSpanFailure = {
+    reason: 'not_integer';
+    field: 'start' | 'end';
+} | {
+    reason: 'negative';
+    field: 'start' | 'end';
+} | {
+    reason: 'inverted';
+} | {
+    reason: 'out_of_range';
+    totalChars: number;
+} | {
+    reason: 'blank';
+};
+type SourceSpanResult = {
+    ok: true;
+    quote: string;
+} | {
+    ok: false;
+    failure: SourceSpanFailure;
+};
+/** Resolve `[start, end)` against `sourceText`. Every rejection is a caller
+ *  mistake the model can correct from the paged read it already has, so each
+ *  carries the discriminator a tool layer turns into a specific message. */
+declare function sliceSourceSpan(sourceText: string, span: {
+    start: number;
+    end: number;
+}): SourceSpanResult;
 
 /**
  * Framework-neutral work-product review endpoints — the
@@ -382,4 +450,4 @@ interface WorkProductRoutes {
 /** Create the work-product review endpoints over the store port and product seams */
 declare function createWorkProductRoutes(options: WorkProductRoutesOptions): WorkProductRoutes;
 
-export { type CreateWorkProductInput, EVIDENCE_COVERAGE_CHECK, EvidenceEntry, ExceptionEntry, type FinalizeWorkProductProvenanceInput, type InMemoryWorkProductStore, MAX_WORK_PRODUCT_BATCH, QUOTE_VERIFICATION_CHECK, QualityCheck, type SubmitWorkProductInput, TrustItem, WorkProductArtifact, WorkProductAuditEvent, type WorkProductAuthorizeArgs, type WorkProductOutcome, WorkProductPersistedPart, WorkProductProvenance, type WorkProductProvenanceBase, WorkProductRecord, type WorkProductRouteAuthorization, type WorkProductRoutes, type WorkProductRoutesOptions, type WorkProductService, type WorkProductServiceOptions, WorkProductStatus, WorkProductStorePort, type WorkProductToolConfig, type WorkProductVerdictBody, type WorkProductVerdictInput, buildWorkProductTools, canTransitionWorkProduct, createInMemoryWorkProductStore, createWorkProductRoutes, createWorkProductService, finalizeWorkProductProvenance, isWorkProductTerminal, normalizeQuoteText, sourceContainsQuote, stampProvenance, validateWorkProductVerdictBody, workProductTrustInputs };
+export { type CreateWorkProductInput, EVIDENCE_COVERAGE_CHECK, EvidenceEntry, ExceptionEntry, type FinalizeWorkProductProvenanceInput, type InMemoryWorkProductStore, MAX_WORK_PRODUCT_BATCH, QUOTE_VERIFICATION_CHECK, QualityCheck, type SourceSpanFailure, type SourceSpanResult, type SubmitWorkProductInput, TrustItem, WorkProductArtifact, WorkProductAuditEvent, type WorkProductAuthorizeArgs, type WorkProductOutcome, WorkProductPersistedPart, WorkProductProvenance, type WorkProductProvenanceBase, WorkProductRecord, type WorkProductRouteAuthorization, type WorkProductRoutes, type WorkProductRoutesOptions, type WorkProductService, type WorkProductServiceOptions, WorkProductStatus, WorkProductStorePort, type WorkProductToolConfig, type WorkProductVerdictBody, type WorkProductVerdictInput, buildWorkProductTools, canTransitionWorkProduct, createInMemoryWorkProductStore, createWorkProductRoutes, createWorkProductService, finalizeWorkProductProvenance, isWorkProductTerminal, normalizeQuoteText, sliceSourceSpan, sourceContainsQuote, stampProvenance, validateWorkProductVerdictBody, workProductTrustInputs };

package/dist/work-product/index.js

@@ -1,7 +1,7 @@
 import {
   parseReviewQueueItem,
   projectReviewQueue
-} from "../chunk-UP33Z633.js";
+} from "../chunk-ZRSUCTST.js";
 import {
   isWorkProductStatus,
   parseAgentCheckInput,
@@ -11,7 +11,7 @@ import {
   persistedPartToWorkProduct,
   unresolvedBlockingExceptions,
   workProductToPersistedPart
-} from "../chunk-F2CBC4DY.js";
+} from "../chunk-V3HO43PG.js";
 import {
   ToolInputError,
   defineAppTool
@@ -403,6 +403,20 @@ function sourceContainsQuote(sourceText, quote) {
   if (normalizedQuote.length === 0) return false;
   return normalizeQuoteText(sourceText).includes(normalizedQuote);
 }
+function sliceSourceSpan(sourceText, span) {
+  for (const field of ["start", "end"]) {
+    const value = span[field];
+    if (!Number.isInteger(value)) return { ok: false, failure: { reason: "not_integer", field } };
+    if (value < 0) return { ok: false, failure: { reason: "negative", field } };
+  }
+  if (span.end <= span.start) return { ok: false, failure: { reason: "inverted" } };
+  if (span.end > sourceText.length) {
+    return { ok: false, failure: { reason: "out_of_range", totalChars: sourceText.length } };
+  }
+  const quote = sourceText.slice(span.start, span.end);
+  if (quote.trim().length === 0) return { ok: false, failure: { reason: "blank" } };
+  return { ok: true, quote };
+}
 
 // src/work-product/tools.ts
 var MAX_WORK_PRODUCT_BATCH = 50;
@@ -452,17 +466,61 @@ async function resolveDraft(service, config, scopeKey, ctx) {
     provenance: stampProvenance(config.provenance(ctx), config.now)
   });
 }
-async function assertQuotesOccurInSources(config, entries, ctx) {
+function spanErrorDetail(failure) {
+  switch (failure.reason) {
+    case "not_integer":
+      return `${failure.field} must be a whole character offset.`;
+    case "negative":
+      return `${failure.field} must not be negative.`;
+    case "inverted":
+      return "end must be greater than start \u2014 the range is half-open [start, end).";
+    case "out_of_range":
+      return `end is past the end of the document, which is ${failure.totalChars} characters. Offsets are absolute in the whole document: when you read with an offset, add that offset to the position within the returned text.`;
+    case "blank":
+      return "that range is only whitespace. Widen it to the characters that carry the value.";
+  }
+}
+async function resolveEvidenceQuotes(config, entries, ctx) {
   const readSourceText = config.readSourceText;
-  if (!readSourceText) return;
   const texts = /* @__PURE__ */ new Map();
+  const readText = async (ref) => {
+    if (!texts.has(ref)) texts.set(ref, await readSourceText(ref, ctx));
+    return texts.get(ref) ?? null;
+  };
   for (let index = 0; index < entries.length; index += 1) {
     const entry = entries[index];
+    const span = entry.locator.span;
     const quote = entry.locator.quote;
+    if (span) {
+      if (!readSourceText) {
+        throw new ToolInputError(
+          "span_unsupported",
+          `entries[${index}].locator.span: this deployment cannot read source text, so a span cannot be resolved into a quote. Record the entry without locator.span.`,
+          500
+        );
+      }
+      const text2 = await readText(entry.sourceRef);
+      if (text2 === null) {
+        throw new ToolInputError(
+          "unverifiable_quote",
+          `entries[${index}].locator.span: "${entry.sourceRef}" has no readable text, so the span cannot be resolved. Record the entry without locator.span or locator.quote and state the basis in claim.`
+        );
+      }
+      const sliced = sliceSourceSpan(text2, span);
+      if (!sliced.ok) {
+        throw new ToolInputError(
+          "invalid_span",
+          `entries[${index}].locator.span [${span.start}, ${span.end}) into "${entry.sourceRef}": ${spanErrorDetail(sliced.failure)}`
+        );
+      }
+      entry.locator.quote = sliced.quote;
+      entry.locator.quoteBasis = "span";
+      continue;
+    }
     if (quote === void 0 || quote.trim().length === 0) continue;
-    if (!texts.has(entry.sourceRef)) texts.set(entry.sourceRef, await readSourceText(entry.sourceRef, ctx));
-    const text = texts.get(entry.sourceRef);
-    if (text === null || text === void 0) {
+    if (!readSourceText) continue;
+    const text = await readText(entry.sourceRef);
+    if (text === null) {
       throw new ToolInputError(
         "unverifiable_quote",
         `entries[${index}].locator.quote: "${entry.sourceRef}" has no readable text, so the quote cannot be verified. Record the entry without locator.quote and state the basis in claim.`
@@ -471,9 +529,10 @@ async function assertQuotesOccurInSources(config, entries, ctx) {
     if (!sourceContainsQuote(text, quote)) {
       throw new ToolInputError(
         "quote_not_found",
-        `entries[${index}].locator.quote: ${JSON.stringify(quote)} does not occur in "${entry.sourceRef}". Copy the supporting line character-for-character out of that document, or \u2014 if this value is COMPUTED rather than read \u2014 omit locator.quote and state the computation in claim.`
+        `entries[${index}].locator.quote: ${JSON.stringify(quote)} does not occur in "${entry.sourceRef}". Cite locator.span {start, end} instead \u2014 the character range you read it at, which this platform slices out of the document itself so the text is right by construction. If the value is COMPUTED rather than read, omit both and state the computation in claim.`
       );
     }
+    entry.locator.quoteBasis = "model";
   }
 }
 async function summarizeQuoteVerification(config, evidence, ctx) {
@@ -481,6 +540,7 @@ async function summarizeQuoteVerification(config, evidence, ctx) {
   if (!readSourceText) return void 0;
   const texts = /* @__PURE__ */ new Map();
   let verified = 0;
+  let spanAnchored = 0;
   let withoutQuote = 0;
   const failed = [];
   for (const entry of evidence) {
@@ -491,10 +551,23 @@ async function summarizeQuoteVerification(config, evidence, ctx) {
     }
     if (!texts.has(entry.sourceRef)) texts.set(entry.sourceRef, await readSourceText(entry.sourceRef, ctx));
     const text = texts.get(entry.sourceRef);
-    if (typeof text === "string" && sourceContainsQuote(text, quote)) verified += 1;
+    if (typeof text !== "string") {
+      failed.push(entry.id);
+      continue;
+    }
+    const span = entry.locator.span;
+    if (span) {
+      const sliced = sliceSourceSpan(text, span);
+      if (sliced.ok && sliced.quote === quote) {
+        verified += 1;
+        spanAnchored += 1;
+      } else failed.push(entry.id);
+      continue;
+    }
+    if (sourceContainsQuote(text, quote)) verified += 1;
     else failed.push(entry.id);
   }
-  return { verified, withoutQuote, failed };
+  return { verified, spanAnchored, withoutQuote, failed };
 }
 function buildWorkProductTools(config) {
   const service = createWorkProductService({
@@ -504,7 +577,7 @@ function buildWorkProductTools(config) {
   });
   const upsertEvidence = defineAppTool({
     name: "upsert_evidence",
-    description: "Record source\u2192field lineage for the current work product, incrementally as you find it. Each entry links a source document (sourceRef + locator) to one artifact target and states the claim it supports. Re-emitting an entry id replaces that entry. Address the work product by scopeKey; the first call creates the draft.",
+    description: "Record source\u2192field lineage for the current work product, incrementally as you find it. Each entry links a source document (sourceRef + locator) to one artifact target and states the claim it supports. Cite by locator.span {start, end} \u2014 the character range you read the value at \u2014 and the platform slices the supporting quote out of the document for you. Re-emitting an entry id replaces that entry. Address the work product by scopeKey; the first call creates the draft.",
     parameters: {
       type: "object",
       properties: {
@@ -523,9 +596,18 @@ function buildWorkProductTools(config) {
                 properties: {
                   page: { type: "number" },
                   range: { type: "string", description: "Free-form location: 'L120-L134' | 'B7' | '\xB64'." },
+                  span: {
+                    type: "object",
+                    description: "PREFERRED. The character range you read the value at, as absolute offsets into the whole document: start is the first character, end is one past the last. If you read with an offset, add that offset to the position within the text you got back. The platform slices the quote out of the document itself and stores it, and returns it to you \u2014 you never retype source text, so the citation cannot be wrong. Use this whenever the value was READ from a document.",
+                    properties: {
+                      start: { type: "integer", minimum: 0 },
+                      end: { type: "integer", minimum: 1 }
+                    },
+                    required: ["start", "end"]
+                  },
                   quote: {
                     type: "string",
-                    description: "Verbatim supporting quote \u2014 copied character-for-character out of the source, not retyped, reformatted, or summarised. The platform checks it occurs in the document and REFUSES the entry if it does not. For a value you COMPUTED rather than read, omit this field and state the computation in claim."
+                    description: "Fallback for sources that cannot give you character offsets: the supporting text copied character-for-character. The platform checks it occurs in the document and REFUSES the entry if it does not. Prefer span. For a value you COMPUTED rather than read, omit both and state the computation in claim."
                   }
                 }
               },
@@ -557,10 +639,24 @@ function buildWorkProductTools(config) {
           );
         }
       }
-      await assertQuotesOccurInSources(config, entries, ctx);
+      await resolveEvidenceQuotes(config, entries, ctx);
       const draft = await resolveDraft(service, config, scopeKey, ctx);
       const record = await unwrap(() => service.upsertEvidence(draft.id, entries), "evidence_rejected");
-      return { workProductId: record.id, version: record.version, evidenceCount: record.evidence.length };
+      return {
+        workProductId: record.id,
+        version: record.version,
+        evidenceCount: record.evidence.length,
+        // Echo what was actually STORED for the entries in this call. A span
+        // citation's quote is produced here, not sent here, so the model must
+        // be able to see the text its offsets selected — that is how it
+        // notices an off-by-a-line span without a second read.
+        entries: entries.map((entry) => ({
+          id: entry.id,
+          target: entry.target,
+          ...entry.locator.quote === void 0 ? {} : { quote: entry.locator.quote },
+          ...entry.locator.quoteBasis === void 0 ? {} : { quoteBasis: entry.locator.quoteBasis }
+        }))
+      };
     }
   });
   const flagException = defineAppTool({
@@ -692,7 +788,7 @@ function buildWorkProductTools(config) {
           id: QUOTE_VERIFICATION_CHECK,
           name: QUOTE_VERIFICATION_CHECK,
           passed: quotes.failed.length === 0,
-          detail: quotes.failed.length === 0 ? `${quotes.verified}/${quoted} quoted evidence entries verified against their source; ${quotes.withoutQuote} recorded without a quote` : `Unverifiable quotes on: ${quotes.failed.join(", ")}`,
+          detail: quotes.failed.length === 0 ? `${quotes.verified}/${quoted} quoted evidence entries verified against their source (${quotes.spanAnchored} platform-sliced from a source span, ${quotes.verified - quotes.spanAnchored} model-quoted and proved to occur); ${quotes.withoutQuote} recorded without a quote` : `Unverifiable quotes on: ${quotes.failed.join(", ")}`,
           source: "platform"
         });
         if (quotes.failed.length > 0) {
@@ -707,11 +803,21 @@ function buildWorkProductTools(config) {
         const targets = config.materialTargets(artifact);
         const covered = new Set(draft.evidence.map((entry) => entry.target));
         const missing = targets.filter((target) => !covered.has(target));
+        const anchoredTargets = new Set(
+          draft.evidence.filter((entry) => entry.locator.quoteBasis !== void 0).map((entry) => entry.target)
+        );
+        const spanTargets = new Set(
+          draft.evidence.filter((entry) => entry.locator.quoteBasis === "span").map((entry) => entry.target)
+        );
+        const present = targets.filter((target) => covered.has(target));
+        const unanchored = present.filter((target) => !anchoredTargets.has(target));
+        const spanCount = present.filter((target) => spanTargets.has(target)).length;
+        const breakdown = `${spanCount} span-anchored, ${present.length - spanCount - unanchored.length} quote-verified, ${unanchored.length} claim-only`;
         const coverage = {
           id: EVIDENCE_COVERAGE_CHECK,
           name: EVIDENCE_COVERAGE_CHECK,
-          passed: missing.length === 0,
-          detail: missing.length === 0 ? `${targets.length}/${targets.length} material targets evidenced` : `Missing evidence for: ${missing.join(", ")}`,
+          passed: missing.length === 0 && !(config.requireAnchoredEvidence && unanchored.length > 0),
+          detail: missing.length > 0 ? `Missing evidence for: ${missing.join(", ")}` : config.requireAnchoredEvidence && unanchored.length > 0 ? `No source anchor for: ${unanchored.join(", ")}` : `${targets.length}/${targets.length} material targets evidenced (${breakdown})`,
           source: "platform"
         };
         checks.unshift(coverage);
@@ -722,6 +828,13 @@ function buildWorkProductTools(config) {
             `Cannot submit: material targets lack evidence: ${missing.join(", ")}. Add upsert_evidence entries targeting each, then resubmit.`
           );
         }
+        if (config.requireAnchoredEvidence && unanchored.length > 0) {
+          await unwrap(() => service.recordChecks(draft.id, checks), "checks_rejected");
+          throw new ToolInputError(
+            "evidence_not_anchored",
+            `Cannot submit: these material targets have an evidence row but no source anchor: ${unanchored.join(", ")}. Re-emit each with locator.span {start, end} \u2014 the character range in the document you read the value at. The platform slices the quote out of the document itself, so you never retype source text.`
+          );
+        }
       }
       const provenance = stampProvenance(config.provenance(ctx), config.now);
       const record = await unwrap(
@@ -851,6 +964,7 @@ export {
   parseReviewQueueItem,
   persistedPartToWorkProduct,
   projectReviewQueue,
+  sliceSourceSpan,
   sourceContainsQuote,
   stampProvenance,
   unresolvedBlockingExceptions,