@yeaft/webchat-agent 1.0.612 → 1.0.615

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.612",
+  "version": "1.0.615",
   "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/person/capabilities.js

@@ -2,7 +2,7 @@ import { NATIVE_TOOL_MANIFESTS, NATIVE_TOOL_IDS, isNativeTool } from './native-t
 import { bytes, digest, fail, identifier, object, page, text } from './contracts.js';
 import { createdCapabilityRecord, validateCreatedDefinition } from './created-capability-contract.js';
 import { runPersonScript, scriptInput, testPersonScript } from './script-executor.js';
-import { createdSkillView, inspectionPage } from './inspection.js';
+import { chronologicalCursor, createdSkillView, inspectionCursor, inspectionPage, inspectionTime } from './inspection.js';
 
 // Intrinsic cognition, bounded pure scripts and supported native host tools.
 // No shell/filesystem/network/VP authority is exposed to generated code.
@@ -83,10 +83,19 @@ export function inspectCapabilities(created, { cursor, limit }, nativeToolIds =
     contract.evidence = item.evidence;
     entries.push(item);
   }
-  // IDs are ASCII identifiers. Binary ordering matches SQLite.
-  const matches = entries.filter(entry => cursor === null || entry.id > cursor)
-    .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-  return inspectionPage(matches, limit, 'id');
+  const boundary = inspectionCursor(cursor, 'skills');
+  // IDs are ASCII identifiers. Binary ordering matches SQLite. Only custom
+  // versions have creation dates; builtins follow as an undated ID catalogue.
+  const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  if (boundary?.legacy) return inspectionPage(entries.filter(entry => entry.id > boundary.id).sort(byId), limit, 'id');
+  const custom = entries.filter(entry => entry.source.kind === 'person-created')
+    .filter(entry => !boundary || (boundary.stage === 'c' && (inspectionTime(entry.createdAt) < boundary.time ||
+      (inspectionTime(entry.createdAt) === boundary.time && entry.id > boundary.id))))
+    .sort((a, b) => inspectionTime(b.createdAt) - inspectionTime(a.createdAt) || byId(a, b));
+  const builtin = entries.filter(entry => entry.source.kind !== 'person-created')
+    .filter(entry => boundary?.stage !== 'b' || entry.id > boundary.id).sort(byId);
+  return inspectionPage([...custom, ...builtin], limit,
+    record => chronologicalCursor('skills', record, record.source.kind === 'person-created' ? 'c' : 'b'));
 }
 
 export class PersonCapabilities {

package/yeaft/person/contracts.js

@@ -66,12 +66,39 @@ export function page(payload = {}) {
 }
 /** Task APIs are explicit owner actions, not cognitive admissions. Logs are raw
  * owner-scoped output; list/control responses never include native runtime/log/result.
- * Lists cap each collection at 100, preferring live records then recent history.
+ * Empty list payloads retain the legacy active-first capped inventory. Explicit
+ * {limit,cursor?} pages each collection newest-created first, with immutable
+ * creation-time/ID keysets and one scope-bound continuation for both collections.
+ * Paged responses also carry a bounded active control snapshot independent of
+ * history position (including terminal children with pending actual execution).
  * Log offsets count raw UTF-8 bytes; an omitted offset starts at the beginning.
  */
 export const PERSON_TASK_LIMITS = Object.freeze({ records: 100, logBytes: 16384, maxLogBytes: 65536 });
+export function taskInspectionCursor(cursor) {
+  if (typeof cursor !== 'string' || !/^t1:[A-Za-z0-9_-]{1,2048}$/.test(cursor)) fail('INVALID_REQUEST');
+  let value;
+  try { value = JSON.parse(Buffer.from(cursor.slice(3), 'base64url').toString('utf8')); } catch { fail('INVALID_REQUEST'); }
+  object(value, ['scope', 'tasks', 'agents']);
+  if (typeof value.scope !== 'string' || !/^[a-f0-9]{64}$/.test(value.scope)) fail('INVALID_REQUEST');
+  for (const key of ['tasks', 'agents']) {
+    const boundary = value[key];
+    if (boundary === null) continue;
+    object(boundary, ['time', 'id']);
+    if (!Number.isSafeInteger(boundary.time) || boundary.time < 0 || typeof boundary.id !== 'string' ||
+        !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(boundary.id)) fail('INVALID_REQUEST');
+  }
+  if ((value.tasks === null && value.agents === null) || Buffer.from(JSON.stringify(value)).toString('base64url') !== cursor.slice(3)) fail('INVALID_REQUEST');
+  return value;
+}
 export function personTaskRequest(op, payload = {}) {
-  if (op === 'tasks') { object(payload, []); return {}; }
+  if (op === 'tasks') {
+    object(payload, ['cursor', 'limit'], []);
+    if (!Object.keys(payload).length) return {};
+    const limit = payload.limit === undefined ? PERSON_TASK_LIMITS.records : payload.limit, cursor = payload.cursor ?? null;
+    if (!Number.isInteger(limit) || limit < 1 || limit > PERSON_TASK_LIMITS.records) fail('INVALID_REQUEST');
+    if (cursor !== null) taskInspectionCursor(cursor);
+    return { cursor, limit };
+  }
   const idKey = op === 'agent_close' ? 'agentId' : 'taskId';
   object(payload, op === 'task_log' ? ['taskId', 'offset', 'maxBytes'] : [idKey], [idKey]);
   // Native TaskStore normalizes punctuation. Reject aliases instead of letting

package/yeaft/person/inspection.js

@@ -1,12 +1,38 @@
 import { bytes, fail, identifier, object, page, text } from './contracts.js';
 
+/** Timestamp + binary ID keysets survive insertion, deletion of the boundary
+ * record and same-millisecond writes. Builtins have no invented chronology.
+ * Bare ID cursors remain readable for pre-keyset clients' ID-ascending pages. */
+export function inspectionCursor(value, section) {
+  if (value == null) return null;
+  if (typeof value !== 'string' || value.length > 512) fail('INVALID_REQUEST');
+  const prefix = section === 'memory' ? 'm1' : 's1';
+  const match = /^(m1|s1):(c|b):(\d{1,16}):([A-Za-z0-9_-]+)$/.exec(value);
+  if (!match) {
+    if (/^(m1|s1):/.test(value)) fail('INVALID_REQUEST');
+    identifier(value); return { legacy: true, id: value };
+  }
+  const [, type, stage, rawTime, encoded] = match;
+  const time = Number(rawTime), id = Buffer.from(encoded, 'base64url').toString('utf8');
+  identifier(id);
+  if (type !== prefix || (section === 'memory' && stage !== 'c') || !Number.isSafeInteger(time) || time < 0 ||
+      String(time) !== rawTime || (stage === 'b' && time !== 0) || Buffer.from(id).toString('base64url') !== encoded) fail('INVALID_REQUEST');
+  return { stage, time, id };
+}
+export const inspectionTime = value => {
+  const time = value == null ? NaN : new Date(value).getTime();
+  return Number.isSafeInteger(time) && time >= 0 ? time : 0;
+};
+export const chronologicalCursor = (section, record, stage = 'c') =>
+  `${section === 'memory' ? 'm1' : 's1'}:${stage}:${stage === 'b' ? 0 : inspectionTime(section === 'memory' ? record.updatedAt : record.createdAt)}:${Buffer.from(record.id).toString('base64url')}`;
+
 /** Public read APIs use keyset cursors, never offsets or model-ranked recall. */
 export function inspectRequest(payload = {}) {
   object(payload, ['section', 'cursor', 'limit'], ['section']);
   if (!['memory', 'skills'].includes(payload.section)) fail('INVALID_REQUEST');
   const { limit } = page({ limit: payload.limit });
   const cursor = payload.cursor ?? null;
-  if (cursor !== null) identifier(cursor);
+  inspectionCursor(cursor, payload.section);
   return { section: payload.section, cursor, limit };
 }
 export function searchRequest(payload = {}) {
@@ -48,13 +74,13 @@ export function createdSkillView(record, contract) {
 /** Complete records only. Continuation follows the last returned key even when the
  * byte budget, rather than the requested count, ends a page. No attachment bytes. */
 export function inspectionPage(records, limit, key, view = value => value) {
-  const items = []; let size = 0;
+  const items = []; let size = 0, lastRecord;
   for (const record of records) {
     if (items.length === limit) break;
     const item = view(record), cost = bytes(item);
     if (cost > 256 * 1024) fail('OUTPUT_LIMIT');
     if (items.length && size + cost > 256 * 1024) break;
-    items.push(item); size += cost;
+    items.push(item); size += cost; lastRecord = record;
   }
-  return { items, nextCursor: records.length > items.length ? String(items.at(-1)[key]) : null };
+  return { items, nextCursor: records.length > items.length ? (typeof key === 'function' ? key(lastRecord) : String(items.at(-1)[key])) : null };
 }

package/yeaft/person/sqlite-store.js

@@ -8,7 +8,7 @@ import { CREATED_CAPABILITY_LIMITS, createdCapabilityRecord, validateCreatedCapa
 import { SCHEMA, TABLES } from './sqlite-schema.js';
 import { attachmentMetadata, attachmentRequestHash, validateFiles } from './attachments.js';
 import { capabilityExperienceView, recordCapabilityExperience } from './capability-experience.js';
-import { conceptView, inspectionPage, inspectRequest, messageView, personName, searchRequest, settingsView, stateView } from './inspection.js';
+import { chronologicalCursor, conceptView, inspectionCursor, inspectionPage, inspectRequest, messageView, personName, searchRequest, settingsView, stateView } from './inspection.js';
 import { TOKEN_FIELDS, turnsPage, turnView } from './turn-diagnostics.js';
 import { inspectCapabilities } from './capabilities.js';
 
@@ -476,8 +476,15 @@ export class SqlitePersonStore {
     this.getPerson(ownerId);
     const scope = this.scope(ownerId);
     if (section === 'skills') return inspectCapabilities(this.rows('created_capabilities', scope, ' ORDER BY id ASC LIMIT 32'), { cursor, limit }, nativeToolIds);
-    const records = this.rows('concepts', scope, ' AND (? IS NULL OR id > ?) ORDER BY id ASC LIMIT ?', [cursor, cursor, limit + 1]);
-    return inspectionPage(records, limit, 'id', conceptView);
+    const boundary = inspectionCursor(cursor, section);
+    if (boundary?.legacy) {
+      const records = this.rows('concepts', scope, ' AND id > ? ORDER BY id ASC LIMIT ?', [boundary.id, limit + 1]);
+      return inspectionPage(records, limit, 'id', conceptView);
+    }
+    const records = this.rows('concepts', scope,
+      ' AND (? IS NULL OR updatedAt < ? OR (updatedAt = ? AND id > ?)) ORDER BY updatedAt DESC, id ASC LIMIT ?',
+      [boundary?.time ?? null, boundary?.time ?? null, boundary?.time ?? null, boundary?.id ?? null, limit + 1]);
+    return inspectionPage(records, limit, record => chronologicalCursor(section, record), conceptView);
   }
   search(ownerId, options) {
     const { query, cursor, limit } = searchRequest(options);

package/yeaft/person/task-host.js

@@ -13,7 +13,8 @@ import { isTerminalAgentStatus } from '../sub-agent/status.js';
 import { describeAgentOutcome } from '../sub-agent/outcome.js';
 import { NullTrace } from '../debug-trace.js';
 import { loadConfig } from '../config.js';
-import { digest, fail, PERSON_TASK_LIMITS, personTaskRequest } from './contracts.js';
+import { digest, fail, PERSON_TASK_LIMITS, personTaskRequest, taskInspectionCursor } from './contracts.js';
+import { inspectionPage, inspectionTime } from './inspection.js';
 
 // Deliberately not the full Session registry: no transcript search, routing,
 // interactive UI, MCP, Work Center, or nested orchestration authority.
@@ -77,13 +78,13 @@ function projectedTask(task) {
     sourceEpisodeId: task.source?.episodeId ?? null, agentId: task.runtime?.subAgentId ?? null,
     recoveryStatus: task.status === 'orphaned' ? 'orphaned' : null };
 }
-function projectedAgent(agent, executionPending) {
+function projectedAgent(agent, executionPending, taskId) {
   const usage = Object.fromEntries(['tokens', 'turns', 'startedAt'].map(key => [key,
     Number.isFinite(agent.usage?.[key]) && agent.usage[key] >= 0 ? agent.usage[key] : 0]));
   // Only the helper's fixed outcome vocabulary crosses this boundary, never the
   // native result, budget reason, final report, or partial output.
   const { status, complete, reason, truncated } = describeAgentOutcome(agent);
-  return { id: agent.id, name: summary(agent.name, 160), status: agent.status,
+  return { id: agent.id, taskId, name: summary(agent.name, 160), status: agent.status,
     outcome: { status, complete, reason, truncated }, executionPending,
     mission: summary(agent.mission ?? agent.task, 1024), usage, createdAt: agent.createdAt ?? null,
     sourceEpisodeId: agent.personEpisodeId ?? null, recoveryStatus: agent.recoveryStatus === 'orphaned' ? 'orphaned' : null };
@@ -440,6 +441,17 @@ class ScopedPersonTaskHost {
     return task;
   }
 
+  #projectAgent(agent, executionPending) {
+    // The persistent link is independent of either history page. Only canonical
+    // IDs of this Person's actual child tasks may become owner log controls.
+    const id = agent.taskId;
+    const task = typeof id === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(id)
+      ? this.taskManager.getTask(this.sessionId, id, this.parentVpId) : null;
+    const taskId = task && task.id === id && task.sessionId === this.sessionId && task.kind === 'sub_agent'
+      && task.runtime?.subAgentId === agent.id ? id : null;
+    return projectedAgent(agent, executionPending, taskId);
+  }
+
   /** Owner-facing inspection/control: never attach a provider, schedule cognition
    * or cancel unrelated work. Native snapshots remain private to evidence(). */
   async request({ ownerId, personId, namespace = this.scope.namespace, op, payload = {} } = {}) {
@@ -448,16 +460,46 @@ class ScopedPersonTaskHost {
     const args = personTaskRequest(op, payload);
     switch (op) {
       case 'tasks': {
+        const continuation = args.cursor ? taskInspectionCursor(args.cursor) : null;
+        if (continuation && continuation.scope !== this.scope.key) throw denied();
         this.#persistAgents();
         const tasks = jsonFiles(this.#manager.store.sessionDir(this.sessionId))
           .filter(task => task.sessionId === this.sessionId && task.ownerVpId === this.parentVpId && ['shell', 'sub_agent'].includes(task.kind));
         const agents = [...this.#agents.values()].filter(agent => agentBelongsToScope(agent, this.agentScope));
+        const byCreation = (a, b) => inspectionTime(b.createdAt) - inspectionTime(a.createdAt) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+        if (args.limit !== undefined) {
+          const readPage = (items, key, view) => {
+            const boundary = continuation?.[key];
+            if (continuation && boundary === null) return { items: [], nextCursor: null };
+            const records = items.filter(item => !boundary || inspectionTime(item.createdAt) < boundary.time ||
+              (inspectionTime(item.createdAt) === boundary.time && item.id > boundary.id))
+              .sort(byCreation)
+              .slice(0, args.limit + 1);
+            return inspectionPage(records, args.limit, item => ({ time: inspectionTime(item.createdAt), id: item.id }), view);
+          };
+          const taskPage = readPage(tasks, 'tasks', projectedTask);
+          const agentPage = readPage(agents, 'agents', agent => this.#projectAgent(agent, agent.executionPending));
+          const more = taskPage.nextCursor !== null || agentPage.nextCursor !== null;
+          const nextCursor = more ? `t1:${Buffer.from(JSON.stringify({ scope: this.scope.key,
+            tasks: taskPage.nextCursor, agents: agentPage.nextCursor })).toString('base64url')}` : null;
+          // History stays strictly newest-created first. A separate, bounded
+          // control snapshot keeps older live shells and terminal children with
+          // detached tools reachable without scrolling through settled history.
+          const activePage = (items, isActive, view) => inspectionPage(items.filter(isActive).sort(byCreation),
+            PERSON_TASK_LIMITS.records, 'id', view);
+          const activeTasks = activePage(tasks, task => !isTerminalTaskStatus(task.status), projectedTask);
+          const activeAgents = activePage(agents, agent => !isTerminalAgentStatus(agent.status) || agent.executionPending,
+            agent => this.#projectAgent(agent, agent.executionPending));
+          return { tasks: taskPage.items, agents: agentPage.items, nextCursor, truncated: more,
+            active: { tasks: activeTasks.items, agents: activeAgents.items,
+              truncated: activeTasks.nextCursor !== null || activeAgents.nextCursor !== null } };
+        }
         const recent = (items, settled) => items.sort((a, b) => Number(settled(a)) - Number(settled(b))
-          || String(b.updatedAt ?? b.createdAt ?? '').localeCompare(String(a.updatedAt ?? a.createdAt ?? ''))).slice(0, PERSON_TASK_LIMITS.records);
+          || byCreation(a, b)).slice(0, PERSON_TASK_LIMITS.records);
         // A terminal driver with actual tools still running is active work, not
         // disposable history: keep its cleanup control ahead of settled records.
         return { tasks: recent(tasks, task => isTerminalTaskStatus(task.status)).map(projectedTask),
-          agents: recent(agents, agent => isTerminalAgentStatus(agent.status) && !agent.executionPending).map(agent => projectedAgent(agent, agent.executionPending)),
+          agents: recent(agents, agent => isTerminalAgentStatus(agent.status) && !agent.executionPending).map(agent => this.#projectAgent(agent, agent.executionPending)),
           truncated: tasks.length > PERSON_TASK_LIMITS.records || agents.length > PERSON_TASK_LIMITS.records };
       }
       case 'task_log': {
@@ -483,7 +525,7 @@ class ScopedPersonTaskHost {
           parentEngineDeps: this.agentScope, taskManager: this.taskManager }));
         if (!result.success) fail('TASK_CONTROL_UNAVAILABLE');
         await this.#joinAgent(agent);
-        return { agent: projectedAgent(agent, this.#executionPending(agent)), pending: false };
+        return { agent: this.#projectAgent(agent, this.#executionPending(agent)), pending: false };
       }
       default: fail('INVALID_REQUEST');
     }