@vellumai/assistant 0.8.7 → 0.8.8

package/src/memory/v3/__tests__/selector.test.ts

@@ -4,9 +4,12 @@
  * Coverage matrix:
  *   - Returned IDs map to the right member slugs by 1-based index, with
  *     `pinned` driven by `pinned_ids`.
- *   - Omitted `ids` → ALL members of the leaf (recall-safe).
+ *   - Omitted `ids` → ALL members of the leaf (recall-safe; bounded to one
+ *     leaf, so this stays a select-all unlike the L1 router).
  *   - Explicit `ids: []` → no pages (deliberate abstention).
- *   - No provider / missing tool_use / schema mismatch / throw → ALL members.
+ *   - No provider / missing tool_use / schema mismatch / throw → no pages
+ *     (degrade to the deterministic lanes), the last three after a re-prompt
+ *     retry; a malformed response that recovers on retry returns its pages.
  *   - The per-leaf `<pages>` prefix is byte-identical across two calls with
  *     different turns (the cache invariant).
  *   - `selectAcrossLeaves` flattens per-leaf results and never exceeds the
@@ -83,6 +86,45 @@ function toolUseResponse(input: Record<string, unknown>): ProviderResponse {
   };
 }
 
+/** A 200 response that carries no tool_use — the malformed-but-successful case
+ * the re-prompt retry exists to recover from. */
+function noToolResponse(): ProviderResponse {
+  return {
+    model: "stub-model",
+    stopReason: "end_turn",
+    usage: { inputTokens: 0, outputTokens: 0 },
+    content: [{ type: "text", text: "no tool call" }],
+  };
+}
+
+/** Provider returning a different response per call (the i-th call returns
+ * responses[i], or the last entry once exhausted), recording each call so a
+ * test can assert how many attempts were made. */
+function makeSequenceProvider(responses: ProviderResponse[]): Provider {
+  let i = 0;
+  return {
+    name: "sequence",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      const response = responses[Math.min(i, responses.length - 1)];
+      i += 1;
+      return response;
+    },
+  };
+}
+
+/** Provider that records each call and then throws — for the throw-after-retries
+ * path (the provider's own RetryProvider has already exhausted its backoff). */
+function makeThrowingProvider(): Provider {
+  return {
+    name: "throwing",
+    sendMessage: async (messages, options) => {
+      providerCalls.push({ messages, options });
+      throw new Error("boom");
+    },
+  };
+}
+
 function makeLeaf(path: LeafPath, members: Slug[]): LeafNode {
   return {
     path,
@@ -206,10 +248,8 @@ describe("selectFromLeaf — id mapping", () => {
 // selectFromLeaf — recall-safe fallbacks.
 // ---------------------------------------------------------------------------
 
-describe("selectFromLeaf — recall-safe fallbacks", () => {
-  const allAlice = ALICE_MEMBERS.map((slug) => ({ slug, pinned: false }));
-
-  test("no provider → ALL members", async () => {
+describe("selectFromLeaf — degradation on failure", () => {
+  test("no provider → no pages, without calling the provider", async () => {
     providerStub = null;
     const result = await selectFromLeaf(
       "people/alice",
@@ -217,26 +257,23 @@ describe("selectFromLeaf — recall-safe fallbacks", () => {
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(0);
   });
 
-  test("missing tool_use → ALL members", async () => {
-    providerStub = makeProvider({
-      model: "stub-model",
-      stopReason: "end_turn",
-      usage: { inputTokens: 0, outputTokens: 0 },
-      content: [{ type: "text", text: "no tool call" }],
-    });
+  test("missing tool_use → no pages after retrying", async () => {
+    providerStub = makeProvider(noToolResponse());
     const result = await selectFromLeaf(
       "people/alice",
       makeTurn("x"),
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("schema mismatch → ALL members", async () => {
+  test("schema mismatch → no pages after retrying", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: "not-an-array" }));
     const result = await selectFromLeaf(
       "people/alice",
@@ -244,23 +281,35 @@ describe("selectFromLeaf — recall-safe fallbacks", () => {
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
   });
 
-  test("provider throw → ALL members", async () => {
-    providerStub = {
-      name: "throwing",
-      sendMessage: async () => {
-        throw new Error("boom");
-      },
-    };
+  test("provider throw → no pages after retrying", async () => {
+    providerStub = makeThrowingProvider();
     const result = await selectFromLeaf(
       "people/alice",
       makeTurn("x"),
       makeTree(),
       summaryOf,
     );
-    expect(result).toEqual(allAlice);
+    expect(result).toEqual([]);
+    expect(providerCalls).toHaveLength(3);
+  });
+
+  test("a malformed response that recovers on retry returns its pages", async () => {
+    providerStub = makeSequenceProvider([
+      noToolResponse(),
+      toolUseResponse({ ids: [2] }),
+    ]);
+    const result = await selectFromLeaf(
+      "people/alice",
+      makeTurn("the 1:1"),
+      makeTree(),
+      summaryOf,
+    );
+    expect(result).toEqual([{ slug: "alice-1on1", pinned: false }]);
+    expect(providerCalls).toHaveLength(2);
   });
 });
 
@@ -298,13 +347,13 @@ describe("selectFromLeaf — request shape", () => {
     const [blockA, blockB] = providerCalls[0].messages[0].content as Array<{
       type: string;
       text: string;
-      cache_control?: { type: string };
+      cache_control?: { type: string; ttl?: string };
     }>;
     expect(blockA.type).toBe("text");
     expect(blockA.text).toContain("<leaf>people/alice</leaf>");
     expect(blockA.text).toContain("<pages>");
     expect(blockA.text).toContain("[1] alice-bio — summary of alice-bio");
-    expect(blockA.cache_control).toEqual({ type: "ephemeral" });
+    expect(blockA.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
 
     expect(blockB.type).toBe("text");
     expect(blockB.text).toContain("<current_message>alice?</current_message>");
@@ -312,6 +361,23 @@ describe("selectFromLeaf — request shape", () => {
     expect(blockB.cache_control).toBeUndefined();
   });
 
+  test("situational context renders in the per-turn block when present", async () => {
+    providerStub = makeProvider(toolUseResponse({ ids: [1] }));
+    await selectFromLeaf(
+      "people/alice",
+      {
+        ...makeTurn("alice?"),
+        situationalContext: "Today is Saturday. Alice's anniversary is today.",
+      },
+      makeTree(),
+      summaryOf,
+    );
+    const blockB = providerCalls[0].messages[0].content[1] as { text: string };
+    expect(blockB.text).toContain(
+      "<situation>Today is Saturday. Alice's anniversary is today.</situation>",
+    );
+  });
+
   test("system prompt mentions pinned (locks the pinning commitment)", async () => {
     providerStub = makeProvider(toolUseResponse({ ids: [1] }));
     await selectFromLeaf("people/alice", makeTurn("x"), makeTree(), summaryOf);

package/src/memory/v3/__tests__/shadow-plugin.test.ts

@@ -68,6 +68,7 @@ const orchestrateSpy = mock(async () => ({
 let treeLoads = 0;
 let coreLoads = 0;
 let needleBuilds = 0;
+let configL2Concurrency = 16;
 
 // Shared in-memory DB so writes are observable from the test. We hold the raw
 // sqlite handle alongside the drizzle wrapper so the test can both read rows
@@ -105,7 +106,12 @@ mock.module("../../../config/assistant-feature-flags.js", () => ({
 
 mock.module("../../../config/loader.js", () => ({
   getConfig: () => ({
-    memory: { v3: { workingSet: { maxPages: 150, evictWindow: 5 } } },
+    memory: {
+      v3: {
+        workingSet: { maxPages: 150, evictWindow: 5 },
+        l2Concurrency: configL2Concurrency,
+      },
+    },
   }),
 }));
 
@@ -203,7 +209,7 @@ const {
   runShadowObservation,
   resetShadowLanesForTests,
   invalidateLanes,
-  memoryV3ShadowPlugin,
+  memoryV3Injector,
 } = await import("../shadow-plugin.js");
 
 // The module stubs above stay installed for the rest of the process (Bun can't
@@ -235,14 +241,14 @@ beforeEach(() => {
   treeLoads = 0;
   coreLoads = 0;
   needleBuilds = 0;
+  configL2Concurrency = 16;
   testDb = makeDb();
   resetShadowLanesForTests();
 });
 
-/** Invoke the plugin's single injector's `produce()` for a turn. */
+/** Invoke the memory-v3 injector's `produce()` for a turn. */
 function produce(conversationId: string, turnIndex: number) {
-  const injector = memoryV3ShadowPlugin.injectors![0]!;
-  return injector.produce({
+  return memoryV3Injector.produce({
     requestId: "r1",
     conversationId,
     turnIndex,
@@ -289,6 +295,18 @@ describe("memory-v3 shadow plugin", () => {
     expect(turn.currentMessage).toBe("hello world");
   });
 
+  test("orchestrate receives the configured L2 concurrency", async () => {
+    shadowEnabled = true;
+    configL2Concurrency = 9;
+    await runShadowObservation("conv-1", 0);
+    const deps = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![1] as {
+      l2Concurrency?: number;
+    };
+    expect(deps.l2Concurrency).toBe(9);
+  });
+
   test("both flags OFF → produce returns null, no orchestrate, no writes", async () => {
     liveEnabled = false;
     shadowEnabled = false;

package/src/memory/v3/llm-retry.ts

@@ -0,0 +1,32 @@
+/**
+ * Memory v3 — shared retry helper for the L1 router and L2 selector model calls.
+ *
+ * The configured provider is already wrapped in `RetryProvider`
+ * (`../../providers/retry.ts`), which retries transient transport failures
+ * (network errors, 429s, 5xx, stream aborts) with exponential backoff before it
+ * ever throws. This helper therefore adds NO backoff of its own; it exists to:
+ *   (a) re-prompt on a malformed-but-successful response — a 200 whose body has
+ *       no usable forced `tool_use`, or whose tool input fails schema validation
+ *       (the provider's retry never re-runs these, since nothing threw); and
+ *   (b) cheaply re-attempt a call that threw after the provider exhausted its
+ *       own retries, before the lane degrades to its deterministic fallback.
+ *
+ * `attempt` signals "unusable, retry me" by returning `null` (or throwing). The
+ * first non-null result wins; `null` after `maxAttempts` tells the caller to
+ * degrade to the deterministic recall lanes.
+ */
+export async function retryForResult<T>(
+  attempt: () => Promise<T | null>,
+  maxAttempts = 3,
+): Promise<T | null> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const result = await attempt();
+      if (result !== null) return result;
+    } catch {
+      // Treat a throw like an unusable result and retry. The provider layer has
+      // already backed off transient errors, so there is nothing to wait for.
+    }
+  }
+  return null;
+}

package/src/memory/v3/orchestrate.ts

@@ -13,11 +13,16 @@
  *      then dedup by slug (a page assigned to multiple opened leaves comes back
  *      once per leaf) ORing the pinned flag so a page pinned anywhere stays
  *      pinned.
- *   4. Record each deduped selection into the carry-forward working set and
- *      evict (core slugs, stale non-pinned entries, then the cap).
- *   5. Final injection = unique union of this turn's selected slugs and the
- *      working-set union, so pages selected on earlier turns carry forward even
- *      when this turn does not re-select them.
+ *   4. Age the carry-forward working set to this turn (evict core slugs, stale
+ *      non-pinned entries, then the cap) and snapshot it — the pages carried in
+ *      from EARLIER turns.
+ *   5. Final injection = unique union of this turn's selected slugs and that
+ *      carried-forward set, so pages selected on earlier turns carry forward
+ *      even when this turn does not re-select them.
+ *   6. Record this turn's selections into the working set for LATER turns. This
+ *      runs AFTER the snapshot so the cap is spent on genuinely carried pages,
+ *      not on this turn's selections (which are injected directly) — otherwise a
+ *      turn selecting more pages than the cap would evict the entire carry.
  */
 
 import type { NeedleIndex } from "./needle.js";
@@ -48,7 +53,8 @@ export interface OrchestrateResult {
   openedLeaves: LeafPath[];
   /** This turn's L2 selections, deduped by slug (pinned flags ORed). */
   currentSelections: SelectedPage[];
-  /** Snapshot of the working-set union after record + evict. */
+  /** The carried-forward set: selections from EARLIER turns, aged to this turn
+   *  (snapshotted before this turn's selections are recorded). */
   workingSetUnion: Set<Slug>;
   /** Slugs to inject: this turn's selections ∪ the carried-forward working set. */
   finalInjection: Slug[];
@@ -95,20 +101,26 @@ export async function orchestrate(
   }
   const currentSelections = [...bySlug.values()];
 
-  // Step 4: record this turn's selections into the carry-forward working set.
-  for (const sel of currentSelections) {
-    deps.workingSet.recordSelection(sel.slug, turn.turnNumber, sel.pinned);
-  }
-
-  // Step 5: evict. Core slugs are owned by core, not the working set.
+  // Step 4: age the carry-forward set to this turn (drop core slugs, stale
+  // non-pinned entries, then the cap) and snapshot it. This is the set carried
+  // in from EARLIER turns; recording this turn happens afterward (step 6) so the
+  // cap is spent on genuinely carried pages, not on this turn's selections
+  // (which are injected directly anyway).
   deps.workingSet.evict(turn.turnNumber, coreSlugs(deps.tree, deps.core));
-
-  // Step 6: final injection = this turn's selections ∪ carried-forward set.
   const workingSetUnion = deps.workingSet.union();
+
+  // Step 5: final injection = this turn's selections ∪ the carried-forward set,
+  // so pages selected on earlier turns carry forward even when this turn does
+  // not re-select them.
   const finalInjection = unique<Slug>([
     ...currentSelections.map((s) => s.slug),
     ...workingSetUnion,
   ]);
 
+  // Step 6: record this turn's selections so they carry forward to LATER turns.
+  for (const sel of currentSelections) {
+    deps.workingSet.recordSelection(sel.slug, turn.turnNumber, sel.pinned);
+  }
+
   return { openedLeaves, currentSelections, workingSetUnion, finalInjection };
 }

package/src/memory/v3/provider-blocks.ts

@@ -1,16 +1,26 @@
 import type { ContentBlock } from "../../providers/types.js";
 
 /**
- * Text content block carrying an ephemeral `cache_control` breakpoint. Our
- * internal `TextContent` type omits the field (only the Anthropic provider
- * transforms it onto the wire), so we reach through a `Record` cast — this
- * keeps the core types provider-agnostic. Shared by the v3 router and selector,
- * whose STATIC numbered blocks are stable across turns and so cache well.
+ * Text content block carrying a `cache_control` breakpoint with a 1-hour TTL.
+ * Shared by the v3 router (the static leaf-tree block) and selector (each
+ * leaf's static `<pages>` block): these prefixes are stable across turns — the
+ * leaf tree is byte-identical every turn, and a leaf's pages block changes only
+ * when its pages/summaries do — while v3 turns are frequently more than the
+ * default 5-minute cache window apart. A 1h TTL keeps the prefix warm across
+ * those gaps so it is read from cache rather than re-created every turn; the
+ * volatile current-message block is rendered after this one and left un-cached.
+ * Haiku does not support the extended-cache-ttl beta, so the Anthropic provider
+ * strips this `ttl` for Haiku models.
+ *
+ * Our internal `TextContent` type omits `cache_control` (only the Anthropic
+ * provider transforms it onto the wire), so we reach through a `Record` cast to
+ * keep the core types provider-agnostic.
  */
 export function cachedTextBlock(text: string): ContentBlock {
   const block: ContentBlock = { type: "text", text };
   (block as unknown as Record<string, unknown>).cache_control = {
     type: "ephemeral",
+    ttl: "1h",
   };
   return block;
 }

package/src/memory/v3/router.ts

@@ -15,12 +15,17 @@
  * cache turn after turn. The trailing recent-context / current-message block
  * changes every turn, so it carries no breakpoint.
  *
- * Recall-safe fallbacks. The router exists to widen recall, so every failure
- * mode degrades toward opening MORE leaves, never fewer:
- *   - omitted `ids` (model didn't pass the field) → open ALL leaves,
- *   - missing/failed tool_use, provider unavailable, or any throw → ALL leaves.
- * The one path that returns nothing is an explicit empty array (`ids: []`),
- * which is the model deliberately abstaining.
+ * Failure handling. A *model-call* failure is not the same as the model
+ * choosing to open everything, so the two no longer share an outcome:
+ *   - explicit `ids` → open exactly those leaves,
+ *   - explicit empty array (`ids: []`) → open nothing (deliberate abstention),
+ *   - omitted `ids` → open nothing: the router must name the leaves it wants,
+ *     never the whole tree (~137 leaves would fan out a full L2 pass per turn),
+ *   - infrastructure failure (provider unavailable, a throw that survived the
+ *     provider's own retries, no usable `tool_use`, or a schema mismatch) →
+ *     open nothing after a short re-prompt retry, degrading to the deterministic
+ *     recall lanes (always-on core, the BM25 needle, the carry-forward working
+ *     set) that the orchestrator unions in regardless.
  */
 
 import { z } from "zod";
@@ -31,6 +36,7 @@ import {
 } from "../../providers/provider-send-message.js";
 import type { Message, ToolDefinition } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
+import { retryForResult } from "./llm-retry.js";
 import { cachedTextBlock } from "./provider-blocks.js";
 import type { LeafPath, LeafTree, TurnContext } from "./types.js";
 
@@ -40,8 +46,8 @@ const log = getLogger("memory-v3-router");
 const OPEN_LEAVES_TOOL_NAME = "open_leaves";
 
 const OpenLeavesSchema = z.object({
-  // Optional: an omitted `ids` field is the recall-safe "open everything"
-  // signal, distinct from an explicit empty array (deliberate abstention).
+  // Optional so the field can be absent on the wire, but an omitted `ids` opens
+  // nothing — the router must name the leaves it wants, never the whole tree.
   ids: z.array(z.number().int()).optional(),
 });
 
@@ -50,8 +56,8 @@ const OPEN_LEAVES_TOOL: ToolDefinition = {
   description:
     "Open the leaves whose contents could plausibly bear on the next reply. " +
     "Lean toward inclusion — a missed relevant leaf is a worse error than an " +
-    "unused one. Omit `ids` entirely to open every leaf; return `[]` only " +
-    "when nothing in the tree could possibly help.",
+    "unused one. Pass the chosen IDs explicitly; return `[]` only when nothing " +
+    "in the tree could possibly help.",
   input_schema: {
     type: "object",
     properties: {
@@ -65,13 +71,14 @@ const OPEN_LEAVES_TOOL: ToolDefinition = {
 
 const SYSTEM_PROMPT = `You route a conversation turn to the leaves of a topic tree that should be opened for the next reply.
 
-Each leaf has a numbered ID, a path, and a description of what it holds. Decide which leaves to open by weighing three signals:
+Each leaf has a numbered ID, a path, and a description of what it holds. Decide which leaves to open by weighing four signals:
 
 - Topic — entities, projects, and events named or implied by the turn.
 - Register — the affect and mode of the message (e.g. playful, distressed, formal). A register signal is enough to open a leaf even when no entity is named.
 - Recent context — the immediately preceding exchange, which resolves references like "this", "that", or "the same thing" to concrete topics.
+- Situation — the current date and a live scratchpad of what is salient right now. A date or state cue can make a leaf relevant even when the message never names it (e.g. a person whose anniversary is today, an active thread).
 
-Include on doubt: open every leaf that could plausibly hold something useful. Missing a relevant leaf is a worse error than opening an unused one. Call \`open_leaves\` with the chosen IDs. Omit \`ids\` to open every leaf; return \`[]\` only when nothing in the tree could possibly help.`;
+Include on doubt: open every leaf that could plausibly hold something useful. Missing a relevant leaf is a worse error than opening an unused one. Call \`open_leaves\` with the chosen IDs explicitly; return \`[]\` only when nothing in the tree could possibly help.`;
 
 /** Leaves sorted deterministically by path so the numbered block is stable. */
 function sortedLeaves(tree: LeafTree): LeafPath[] {
@@ -104,10 +111,10 @@ export function renderLeafBlock(tree: LeafTree): string {
 }
 
 /**
- * Run the L1 router for one turn. Returns the leaf paths to open.
- *
- * Recall-safe: any failure to obtain an explicit selection returns ALL leaves.
- * Only an explicit empty `ids` array returns no leaves.
+ * Run the L1 router for one turn. Returns the leaf paths to open — only ever the
+ * leaves the model names explicitly. An omitted `ids`, an explicit `[]`, or an
+ * infrastructure failure (after a short re-prompt retry) all open nothing,
+ * degrading to the deterministic recall lanes the orchestrator unions in.
  */
 export async function routeL1(
   turn: TurnContext,
@@ -118,8 +125,10 @@ export async function routeL1(
 
   const provider = await getConfiguredProvider("memoryV3RouteL1");
   if (!provider) {
-    log.warn("memoryV3RouteL1 provider unavailable; opening all leaves");
-    return paths;
+    log.warn(
+      "L1 router provider unavailable; degrading to deterministic lanes",
+    );
+    return [];
   }
 
   const userMsg: Message = {
@@ -129,15 +138,21 @@ export async function routeL1(
       {
         type: "text",
         text:
+          (turn.situationalContext
+            ? `<situation>${turn.situationalContext}</situation>\n`
+            : "") +
           `<recent_context>${turn.recentContext}</recent_context>\n` +
           `<current_message>${turn.currentMessage}</current_message>`,
       },
     ],
   };
 
-  let response;
-  try {
-    response = await provider.sendMessage([userMsg], {
+  // One forced-tool call, retried a few times so a transient malformed response
+  // (no usable tool_use, or tool input that fails the schema) re-prompts before
+  // we give up. `null` from an attempt means "unusable, retry"; the provider
+  // layer already backs off transient throws, so this loop adds no delay.
+  const parsed = await retryForResult(async () => {
+    const response = await provider.sendMessage([userMsg], {
       tools: [OPEN_LEAVES_TOOL],
       systemPrompt: SYSTEM_PROMPT,
       config: {
@@ -145,37 +160,28 @@ export async function routeL1(
         tool_choice: { type: "tool" as const, name: OPEN_LEAVES_TOOL_NAME },
       },
     });
-  } catch (err) {
-    log.warn({ err }, "L1 router call threw; opening all leaves");
-    return paths;
-  }
-
-  const toolBlock = extractToolUse(response);
-  if (!toolBlock || toolBlock.name !== OPEN_LEAVES_TOOL_NAME) {
-    log.warn(
-      { stopReason: response.stopReason },
-      "L1 router returned no open_leaves tool_use; opening all leaves",
-    );
-    return paths;
-  }
+    const toolBlock = extractToolUse(response);
+    if (!toolBlock || toolBlock.name !== OPEN_LEAVES_TOOL_NAME) return null;
+    const result = OpenLeavesSchema.safeParse(toolBlock.input);
+    return result.success ? result.data : null;
+  });
 
-  const parsed = OpenLeavesSchema.safeParse(toolBlock.input);
-  if (!parsed.success) {
+  if (parsed === null) {
     log.warn(
-      { error: parsed.error.message },
-      "L1 router tool input did not match schema; opening all leaves",
+      "L1 router could not obtain a selection after retries; degrading to deterministic lanes",
     );
-    return paths;
+    return [];
   }
 
-  // Omitted `ids` is the recall-safe "open everything" signal.
-  if (parsed.data.ids === undefined) return paths;
+  // An omitted `ids` field means the model named no leaves — open nothing rather
+  // than the whole tree. Only explicitly listed IDs open leaves.
+  if (parsed.ids === undefined) return [];
 
   // Map 1-based IDs back to leaf paths, dropping out-of-range IDs without
   // throwing. De-duplicate while preserving model-returned order.
   const seen = new Set<number>();
   const selected: LeafPath[] = [];
-  for (const id of parsed.data.ids) {
+  for (const id of parsed.ids) {
     if (id < 1 || id > paths.length || seen.has(id)) continue;
     seen.add(id);
     selected.push(paths[id - 1]);