@yeaft/webchat-agent 1.0.513 → 1.0.515

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.513",
+  "version": "1.0.515",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/conversation/persist.js

@@ -827,6 +827,20 @@ class SegmentStore {
       : out.sort(compareMessagesBySeq);
   }
 
+  /**
+   * Read physical rows without applying reflection tombstones. Session cloning
+   * needs the complete durable transcript, including rows hidden by folding.
+   */
+  readAllRaw({ includeCold = false } = {}) {
+    if (!this.hasData()) return [];
+    const idx = this.loadIndex();
+    return (idx.segments || [])
+      .slice()
+      .sort((a, b) => (a.firstSeq || 0) - (b.firstSeq || 0))
+      .flatMap(segment => this.#readSegment(segment.file, { includeCold }))
+      .sort(compareMessagesBySeq);
+  }
+
   *scan({ beforeSeq = Infinity, afterSeq = -Infinity, desc = false, includeCold = false, scanStats = null } = {}) {
     if (!this.hasData()) return;
     const idx = this.loadIndex();
@@ -1615,6 +1629,81 @@ export class ConversationStore {
     return this.loadRecentBySession(sessionId, Infinity);
   }
 
+  /**
+   * Copy the complete durable transcript to a new Session identity.
+   *
+   * Unlike visible history readers, this includes cold rows, internal rows,
+   * reflections, and the rows hidden by reflection tombstones. New persisted
+   * message ids are allocated in original order. References that point to a
+   * copied persisted message are remapped; external/client/tool identities are
+   * intentionally preserved.
+   *
+   * @returns {{ copiedCount: number, idMap: Map<string, string> }}
+   */
+  copySession(sourceSessionId, targetSessionId) {
+    if (!sourceSessionId || !targetSessionId || sourceSessionId === targetSessionId) {
+      return { copiedCount: 0, idMap: new Map() };
+    }
+    const primary = this.#segmentStoreForConversationDir(this.#sessionConversationDir(sourceSessionId));
+    const segmentedRows = primary.readAllRaw({ includeCold: true });
+    const legacyRows = this.#sessionFileEntries('all', sourceSessionId)
+      .map(entry => {
+        try { return this.readMessageFile(entry.path); } catch (err) {
+          if (isPermissionError(err)) return null;
+          throw err;
+        }
+      })
+      .filter(Boolean);
+    // Migration can temporarily leave the same durable row in both the legacy
+    // markdown layout and the segment store. Preserve legacy-only rows, but let
+    // the canonical segment copy win when both contain the same persisted id.
+    const rowsById = new Map();
+    for (const row of [...legacyRows, ...segmentedRows]) {
+      if (row?.sessionId !== sourceSessionId || typeof row.id !== 'string' || !row.id) continue;
+      rowsById.set(row.id, row);
+    }
+    const rows = [...rowsById.values()].sort(compareMessagesBySeq);
+    if (rows.length === 0) return { copiedCount: 0, idMap: new Map() };
+
+    const firstSeq = this.#getNextSeq();
+    const idMap = new Map(rows.map((row, index) => [
+      row.id,
+      `m${String(firstSeq + index).padStart(4, '0')}`,
+    ]));
+    const remapId = id => idMap.get(id) || id;
+    const copies = rows.map(row => {
+      const copy = { ...row, sessionId: targetSessionId };
+      delete copy.id;
+      if (idMap.has(row.causalRootId)) copy.causalRootId = remapId(row.causalRootId);
+      if (Array.isArray(row.foldedMessageIds)) {
+        copy.foldedMessageIds = row.foldedMessageIds.map(remapId);
+      }
+      if (Array.isArray(row.sourceMessageIds)) {
+        copy.sourceMessageIds = row.sourceMessageIds.map(remapId);
+      }
+      if (row.cold === true) delete copy.cold;
+      return copy;
+    });
+    const written = this.appendBatch(copies);
+    for (let index = 0; index < written.length; index += 1) {
+      if (rows[index].cold === true) this.moveToCold(written[index].id);
+    }
+
+    // append() intentionally treats permission failures as best-effort for live
+    // chat. A Session copy cannot: reporting success with a partial transcript
+    // would make the new Session irrecoverably incomplete. Verify the target's
+    // physical rows before the higher-level CRUD operation commits the clone.
+    const target = this.#segmentStoreForConversationDir(this.#sessionConversationDir(targetSessionId));
+    const persistedIds = new Set(target.readAllRaw({ includeCold: true }).map(row => row.id));
+    const expectedIds = [...idMap.values()];
+    if (written.length !== rows.length
+        || persistedIds.size !== expectedIds.length
+        || expectedIds.some(id => !persistedIds.has(id))) {
+      throw new Error(`Session transcript copy incomplete: expected ${rows.length}, persisted ${persistedIds.size}`);
+    }
+    return { copiedCount: written.length, idMap };
+  }
+
   /**
    * VP-scoped view of Session history, used to build a pair-safe provider
    * snapshot for one VP. It operates on what the VP can actually see, not

package/yeaft/engine.js

@@ -1250,8 +1250,8 @@ export class Engine {
   }
 
   /**
-   * Build the system prompt with the AMS-rendered Memory block, the
-   * Active Scope block, and skill content. The legacy multi-path
+   * Build the system prompt with the AMS-rendered Memory block, routing
+   * metadata, and skill content. The legacy multi-path
    * Memory injection (FTS-formatted + AMS snapshot + Layer-A summaries +
    * userProfile + coreMemory) was retired in DESIGN-PROMPT v1; callers
    * now thread a single `memoryInjection` string composed upstream from
@@ -1260,8 +1260,7 @@ export class Engine {
    * Routes through `buildWorkerPrompt`, which:
    *   - Lays in the persona-as-identity block (or Yeaft identity fallback)
    *   - Adds the Memory section (passed in as `memoryInjection`)
-   *   - Adds the structured Active Scope block (`activeScope`)
-   *   - Forwards optional `taskCtx` for the legacy task-context sub-block
+   *   - Adds multi-VP routing metadata from `activeScope` when applicable
    *
    * @param {object} args
    * @param {string} args.prompt — user prompt (for skill relevance matching)
@@ -1273,11 +1272,10 @@ export class Engine {
    * @param {string} [args.projectLabel] — current Project name and id for prompt attribution
    * @param {string} [args.workCenterInstructions] — frozen Agent-level Work Center policy
    * @param {string} [args.projectDoc] — resolved CLAUDE.md / AGENTS.md text (already truncated)
-   * @param {object} [args.taskCtx] — legacy task-context sub-block (optional)
    * @param {string} [args.explicitSkillName] — leading /skill:<name> command, if present
    * @returns {string}
    */
-  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, projectInstruction, projectLabel, workCenterInstructions, projectDoc, taskCtx, activeTasks, collabToolPolicy = null, activeToolNames = null, promptNotices = [], explicitSkillName, resolvedSkillContent = null } = {}) {
+  #buildSystemPrompt({ prompt, memoryInjection, vpPersona, activeScope, sessionAnnouncement, projectInstruction, projectLabel, workCenterInstructions, projectDoc, promptNotices = [], explicitSkillName, resolvedSkillContent = null } = {}) {
     // #runQuery resolves Skill selection at each provider-request boundary so
     // a live Plugin policy change cannot leave stale content in the next prompt.
     // Keep the local fallback for internal callers that do not need selection
@@ -1292,21 +1290,8 @@ export class Engine {
       }
     }
 
-    // Prompt guidance must describe the same canonical capability
-    // intersection that reaches provider schemas and execution.
-    const registeredToolNames = this.#toolRegistry
-      ? this.#toolRegistry.getToolNames({
-          plugins: this.#config?.plugins,
-          collabToolPolicy,
-        })
-      : Array.from(this.#tools.keys());
-    const toolNames = activeToolNames instanceof Set
-      ? registeredToolNames.filter(name => activeToolNames.has(name))
-      : registeredToolNames;
-
     return buildWorkerPrompt({
       language: this.#config.language || 'en',
-      toolNames,
       memoryInjection,
       skillContent,
       vpPersona,
@@ -1317,8 +1302,6 @@ export class Engine {
       workCenterInstructions,
       projectDoc,
       runtimePlatform: getRuntimePlatformInfo(),
-      taskCtx,
-      activeTasks,
       promptNotices,
       // Worker-shape harness is descriptive metadata for human inspection;
       // production prompts skip it to save tokens. Re-enable via env when
@@ -2306,18 +2289,13 @@ export class Engine {
         }))
       : [];
 
-    // ─── Active Scope (DESIGN-PROMPT §3 ④) ──────────────────────
-    // Structured per-turn scope summary: session + vp + members + envelope routing
-    // info. Long-form scope content lives in AMS — this block carries
-    // only IDs + tiny labels. (Feature scope retired 2026-05-13.)
-    const activeSessionTopics = topicScopesForResident
-      .map(scope => scope.replace(/^sessions\/[^/]+\/topic\//, ''));
+    // ─── Multi-VP routing scope ──────────────────────────────────
+    // Only identity and peer membership affect the routing contract rendered in
+    // the system prompt. Session bookkeeping and inferred topics remain in their
+    // owning runtime/memory paths instead of being mirrored into prompt metadata.
     const activeScope = {
-      sessionId: sessionId || '',
-      sessionMember: ownVpIdForAms || '',
+      vpId: ownVpIdForAms || '',
       sessionMembers: Array.isArray(sessionMembers) ? sessionMembers : [],
-      sessionTopics: activeSessionTopics,
-      envelope: inboundEnvelope || null,
     };
 
     let projectDocSource = this.#getProjectDocBlock(workDir);
@@ -2332,11 +2310,6 @@ export class Engine {
       && typeof this.#taskManager.listActiveTasks === 'function'
       ? this.#taskManager.listActiveTasks(runtimeSessionId)
       : [];
-    let activeTasks = this.#taskManager
-      ? this.#taskManager.renderActiveTasksForPrompt(runtimeSessionId, {
-          language: this.#config.language || 'en',
-        })
-      : '';
     const registeredToolNames = this.#toolRegistry
       ? this.#toolRegistry.getToolNames({
           collabToolPolicy: effectiveCollabToolPolicy,
@@ -2407,9 +2380,6 @@ export class Engine {
       projectLabel,
       workCenterInstructions,
       projectDoc: projectDocContext.text,
-      activeTasks,
-      collabToolPolicy: effectiveCollabToolPolicy,
-      activeToolNames,
       promptNotices,
       explicitSkillName,
       resolvedSkillContent,
@@ -2825,17 +2795,18 @@ export class Engine {
         && typeof this.#taskManager.listActiveTasks === 'function'
         ? this.#taskManager.listActiveTasks(runtimeSessionId)
         : [];
-      activeTasks = this.#taskManager
-        ? this.#taskManager.renderActiveTasksForPrompt(runtimeSessionId, {
-            language: this.#config.language || 'en',
-          })
-        : '';
       activeToolNames = resolveCurrentActiveToolNames();
       for (const name of [...discoveredToolNames]) {
         if (this.#toolRegistry?.has(name)) activeToolNames?.add(name);
         else discoveredToolNames.delete(name);
       }
       toolDefs = this.#getToolDefs(effectiveCollabToolPolicy, activeToolNames);
+      // Only a child registry supplies this policy. Budget exhaustion closes
+      // investigation, not the evidence-bearing conversation: reserve one
+      // tool-free response for a useful handoff, under the existing signal.
+      const executionPolicy = isSubAgent
+        ? this.#toolRegistry?.prepareProviderRequest?.() : null;
+      if (executionPolicy?.finalize) toolDefs = [];
       ({ resolvedSkillContent, resolvedSkills, skillResolutionError } = resolveSkillPromptState({
         skillManager: this.#skillManager,
         prompt,
@@ -2853,6 +2824,7 @@ export class Engine {
       reportedSkillNames = currentSkillNames;
       reportedSkillError = skillResolutionError;
       systemPrompt = buildCurrentSystemPrompt();
+      if (executionPolicy?.prompt) systemPrompt += `\n\n${executionPolicy.prompt}`;
 
       try {
         // Resolve effort per provider request so a saved Session effort takes
@@ -2966,6 +2938,7 @@ export class Engine {
         const requestMaxOutputTokens = Math.max(1, Math.min(
           requestConfig.maxOutputTokens || resolveMaxOutputTokens(currentModel, requestConfig),
           resolveMaxOutputTokens(currentModel, requestConfig),
+          executionPolicy?.maxOutputTokens || Infinity,
         ));
         const toolSchemaTokens = toolDefs.length > 0
           ? approxTokens(JSON.stringify(toolDefs)) : 0;
@@ -3059,7 +3032,12 @@ export class Engine {
           retryLifecycle.pendingContinuation = null;
           continuationCommitted = true;
         };
+        let childDispatchReserved = false;
         const commitDispatch = () => {
+          if (isSubAgent && !childDispatchReserved) {
+            this.#toolRegistry?.reserveProviderRequest?.({ reporting: !!executionPolicy?.finalize });
+            childDispatchReserved = true;
+          }
           if (!activeProviderRequest && typeof prepareProviderRequest === 'function') {
             activeProviderRequest = prepareProviderRequest({
               turnNumber,
@@ -3166,6 +3144,9 @@ export class Engine {
               }
               break;
             case 'tool_call':
+              // No dispatch or orphan protocol rows during the reserved report,
+              // even if an adapter ignores the absence of tool definitions.
+              if (executionPolicy?.finalize) break;
               if (toolCalls.length === 0) {
                 traceRequest('llm.first_tool_call', {
                   durationMs: perfNowMs() - requestPerfStart,
@@ -3409,7 +3390,7 @@ export class Engine {
         // the caller. Replaying that request would publish a duplicate call and
         // leave ambiguous execution ownership, so only pre-tool failures are
         // eligible for transparent retry or model fallback.
-        const canReplayProviderRequest = toolCalls.length === 0;
+        const canReplayProviderRequest = toolCalls.length === 0 && !executionPolicy?.finalize;
         if (earlyIsContextOverflow && canReplayProviderRequest
           && contextOverflowRecoveryAttempts < 3) {
           contextOverflowRecoveryAttempts += 1;
@@ -3808,6 +3789,14 @@ export class Engine {
       conversationMessages.push(assistantMsg);
       fullResponseText += responseText;
 
+      // The reporting allowance is exactly one provider response, not another
+      // investigation loop. Ignore unsolicited calls even from a noncompliant
+      // adapter, and never auto-continue a truncated reporting response.
+      if (executionPolicy?.finalize) {
+        yield { type: 'turn_end', turnNumber, stopReason: 'budget_report', threadId, terminal: true };
+        break;
+      }
+
       // ─── Handle max_tokens → auto-continue ────────────
       // A suppressed call leaves a synthetic reminder as the latest user
       // message. Some models answer it with an empty end_turn. Continue exactly