@thready-web/dsh-bot-plugin 0.1.0-beta.5 → 0.1.0-beta.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/context.js CHANGED
@@ -13,12 +13,16 @@ export const RULES = [
13
13
  ].join('\n');
14
14
  export const CHAT = [
15
15
  'You are talking with the user. Finish this turn in the first person.',
16
- 'The latest user message is the current intent. If the previous sentence stopped halfway, answer the new one directly. Do not finish the old sentence.',
16
+ 'Keep each visible reply around 200 characters, in the language the user is using. A report, a long explanation, or any answer that would run past that is a file: use write, then reply with the path and one or two sentences. That single write is the reply itself, not a task to dispatch. Stay in the chat only when that same message explicitly asks for a longer reply and forbids tools.',
17
+ 'The latest user message is the current intent. If the previous assistant message was interrupted, answer the new one and do not finish the old sentence. If that earlier message finished, it is already on screen: do not write it again.',
18
+ 'A user message that arrives after an assistant message in the same turn is an interjection. The in-flight step is not cancelled. On the next step, add only what the new message asks, in a few sentences. "Do not drop the earlier text" means leave the earlier message where it is, not paste it into the new reply.',
19
+ 'Example, same turn. Step 1 already delivered the recursive DNS path. The user then interjects: add the difference between recursive and iterative resolution, and do not drop the recursive path. Step 2 is only the difference: recursive resolution means you run the whole lookup for the client; iterative resolution means you say whom to ask next. A recursive resolver is recursive toward the client and iterative toward the root, the TLD, and the authoritative servers. Step 2 does not repeat the path.',
17
20
  'When the user did not ask you to look something up, edit files, dispatch work, or contact another bot, do not call tools and do not mention steps or system state.',
18
21
  'Default: hand every non-trivial task to a worker with foundations_dispatch. The main session plans, estimates budget, waits for ticket notices, reviews results, and replies to the user.',
19
22
  'Direct execution is allowed only for a short reply that needs no tools; a tiny read-only check (one or two reads) needed to write a briefing or answer a simple question; or when the user clearly asked you to do the work yourself in this session and no worker owns that work. Do not run a multi-step shell, edit, or write chain in the main session without one of those exceptions. A task already handed to a worker stays with that worker.',
20
23
  "Prefer foundations_dispatch over bash, write, edit, and any official subagent tool for this bot's work. Official subagent is not the ticket worker.",
21
24
  'If an unfinished ticket can take the new work, call foundations_redirect and reuse that worker. Independent tasks may run in parallel up to the host slot cap. Dependent steps stay serial on the same ticket. Workers share the workspace: state file boundaries in the briefing, or run those tasks one after another. There is no filesystem isolation between workers.',
25
+ 'The host attaches recent main-session dialogue to the ticket, and the worker reads that log directly with no authorization prompt. Write the task in the briefing. Do not paste the transcript.',
22
26
  'Workers usually have file tools (read, write, edit, working_directory) and foundations_report. They often do not have bash or other command tools. Assign work the worker can actually do. If a worker reports it is blocked because it has no command tools, do not dispatch that same command-only task to another worker with the same tools, and do not silently finish the job in the main session; tell the user the blockage.',
23
27
  'foundations_dispatch may return status=accepted (received, and possibly waiting for a slot), status=enqueued (placed on the execution queue, not started), or a BUDGET error when both the slot cap and the queue cap are full. accepted or enqueued is not completion and not started. Say in one sentence that the work is in the background, then end the turn. Do not sleep, poll, or keep calling tools while waiting.',
24
28
  "A ticket notice is not something the user said. On progress or artifact notices, do not take over the work and do not poll. On a question, answer or call foundations_supply. On a budget-extension notice, call foundations_grant with enough to exceed current usage, then end the turn. You cannot refuse a worker budget. Do not take over the worker's task: do not inspect, edit, or build its files, and do not run its commands. On a successful result, call foundations_publish, then write the user-visible reply. On a failed result, tell the user the reason and stop. Do not take over the task. Do not treat a later failed status after a published result as if the worker never delivered. Do not invent a final answer or accept the work on the user's behalf before a result. Do not call foundations_retry unless the user explicitly asks.",
package/dist/desk.js CHANGED
@@ -33,11 +33,16 @@ const SECRET_KEY = /token|secret|password|authorization|api[-_]?key|cookie/i;
33
33
  * @param {object} options
34
34
  * @param {string} options.ledgerFile
35
35
  * @param {string} options.profileDir
36
+ * @param {string} [options.sessionsRoot] JSONL persistence root. Defaults to <profileDir>/sessions.
37
+ * @param {string} [options.stateRoot] Directory that holds storages/. Defaults to profileDir.
36
38
  * @param {string} options.sessionCwd
37
39
  * @param {(sessionId: string) => boolean} options.isBot
38
40
  * @param {(sessionId: string) => { kind?: string } | null | undefined} options.mark
39
41
  * @param {(sessionId: string) => void | Promise<void>} options.hold
40
42
  * @param {(sessionId: string) => void | Promise<void>} options.release
43
+ * @param {(sessionId: string) => void | Promise<void>} [options.releaseLoaded]
44
+ * @param {(sessionId: string) => void | Promise<void>} [options.releaseAttached]
45
+ * @param {(sessionId: string) => boolean} [options.stillAttached]
41
46
  * @param {(endpoint: string, args: Record<string, unknown>, req: DeskRequest) => Promise<{ status: number, body: RpcEnvelope }>} options.rpc
42
47
  * @param {(req: DeskRequest) => Promise<Record<string, unknown>>} options.usage
43
48
  */
@@ -46,7 +51,10 @@ export function createDesk(options) {
46
51
  const sessionPreviews = openSessionPreviews(join(dirname(options.ledgerFile), 'session-previews.json'));
47
52
  /** @type {Map<string, Promise<void>>} */
48
53
  const promptLocks = new Map();
49
- const sessionsRoot = join(options.profileDir, 'sessions');
54
+ const sessionsRoot = options.sessionsRoot !== undefined && options.sessionsRoot !== ''
55
+ ? options.sessionsRoot
56
+ : join(options.profileDir, 'sessions');
57
+ const stateRoot = options.stateRoot !== undefined && options.stateRoot !== '' ? options.stateRoot : options.profileDir;
50
58
  return {
51
59
  /**
52
60
  * @param {string} method
@@ -61,7 +69,7 @@ export function createDesk(options) {
61
69
  return true;
62
70
  if (method === 'POST' && (sub === '/sessions' || sub === '/sessions/previews' || sub === '/tasks'))
63
71
  return true;
64
- if (method === 'POST' && /^\/sessions\/session-[A-Za-z0-9-]+\/(?:archive|purge)$/.test(sub))
72
+ if (method === 'POST' && /^\/sessions\/session-[A-Za-z0-9-]+\/(?:archive|purge|delete)$/.test(sub))
65
73
  return true;
66
74
  if (method === 'POST' && /^\/tasks\/[0-9a-f-]{36}\/cancel$/.test(sub))
67
75
  return true;
@@ -92,6 +100,9 @@ export function createDesk(options) {
92
100
  const purge = sub.match(/^\/sessions\/(session-[A-Za-z0-9-]+)\/purge$/);
93
101
  if (method === 'POST' && purge)
94
102
  return purgeBlank(req, purge[1]);
103
+ const remove = sub.match(/^\/sessions\/(session-[A-Za-z0-9-]+)\/delete$/);
104
+ if (method === 'POST' && remove)
105
+ return deleteSession(req, remove[1]);
95
106
  if (method === 'GET' && sub === '/tasks')
96
107
  return { status: 200, body: { items: ledger.tasks() } };
97
108
  if (method === 'POST' && sub === '/tasks')
@@ -214,24 +225,84 @@ export function createDesk(options) {
214
225
  * @param {string} sessionId
215
226
  */
216
227
  async function purgeBlank(req, sessionId) {
228
+ const found = await findListedSession(req, sessionId);
229
+ if (found.error)
230
+ return found.error;
231
+ const item = found.item;
232
+ if (item.blank !== true || item.running === true || typeof item.cwd !== 'string' || item.cwd === '') {
233
+ return { status: 409, body: { error: 'not_blank' } };
234
+ }
235
+ const erased = await eraseSession(sessionId, item.cwd);
236
+ if (erased)
237
+ return erased;
238
+ return { status: 200, body: { sessionId, purged: true } };
239
+ }
240
+ /**
241
+ * Hard-delete any listed session, including one that already has messages.
242
+ * An idle session still open in this process is detached first, then its log
243
+ * is removed. A running turn is refused so its writer cannot recreate the log.
244
+ * @param {DeskRequest} req
245
+ * @param {string} sessionId
246
+ */
247
+ async function deleteSession(req, sessionId) {
248
+ const found = await findListedSession(req, sessionId);
249
+ if (found.error)
250
+ return found.error;
251
+ const item = found.item;
252
+ if (item.running === true)
253
+ return { status: 409, body: { error: 'running' } };
254
+ if (typeof item.cwd !== 'string' || item.cwd === '')
255
+ return { status: 409, body: { error: 'no_cwd' } };
256
+ try {
257
+ await options.releaseLoaded?.(sessionId);
258
+ if (options.stillAttached?.(sessionId) === true)
259
+ await options.releaseAttached?.(sessionId);
260
+ }
261
+ catch (error) {
262
+ return {
263
+ status: 500,
264
+ body: { error: 'delete_failed', message: error instanceof Error ? error.message : 'delete failed' },
265
+ };
266
+ }
267
+ if (options.stillAttached?.(sessionId) === true)
268
+ return { status: 409, body: { error: 'attached' } };
269
+ const erased = await eraseSession(sessionId, item.cwd);
270
+ if (erased)
271
+ return erased;
272
+ return { status: 200, body: { sessionId, deleted: true } };
273
+ }
274
+ /**
275
+ * @param {DeskRequest} req
276
+ * @param {string} sessionId
277
+ */
278
+ async function findListedSession(req, sessionId) {
217
279
  const listed = await options.rpc('session/list', { _request: {} }, req);
218
280
  const items = listed.body?.result?.value?.items;
219
281
  if (listed.body?.result?.ok !== true || !Array.isArray(items)) {
220
- return { status: 502, body: { error: 'session_list_failed', upstream: listed.body?.result?.error ?? null } };
282
+ return {
283
+ error: {
284
+ status: 502,
285
+ body: { error: 'session_list_failed', upstream: listed.body?.result?.error ?? null },
286
+ },
287
+ };
221
288
  }
222
289
  const item = items.find(entry => entry?.sessionId === sessionId);
223
290
  if (!item)
224
- return { status: 404, body: { error: 'session_not_found' } };
225
- if (item.blank !== true || item.running === true || typeof item.cwd !== 'string' || item.cwd === '') {
226
- return { status: 409, body: { error: 'not_blank' } };
227
- }
291
+ return { error: { status: 404, body: { error: 'session_not_found' } } };
292
+ return { item, error: undefined };
293
+ }
294
+ /**
295
+ * @param {string} sessionId
296
+ * @param {string} cwd
297
+ */
298
+ async function eraseSession(sessionId, cwd) {
228
299
  try {
229
300
  purgeSessionFiles({
230
301
  sessionsRoot,
231
- cacheFile: join(options.profileDir, 'storages', 'session_projcache', 'sessions', `${sessionId}.json`),
232
- workspaceFile: join(options.profileDir, 'storages', 'workspace.json'),
302
+ cacheFile: join(stateRoot, 'storages', 'session_projcache', 'sessions', `${sessionId}.json`),
303
+ workspaceFile: join(stateRoot, 'storages', 'workspace.json'),
233
304
  sessionId,
234
- cwd: item.cwd,
305
+ cwd,
235
306
  });
236
307
  }
237
308
  catch (error) {
@@ -241,7 +312,7 @@ export function createDesk(options) {
241
312
  };
242
313
  }
243
314
  sessionPreviews.forget(sessionId);
244
- return { status: 200, body: { sessionId, purged: true } };
315
+ return null;
245
316
  }
246
317
  /**
247
318
  * @param {unknown} body
@@ -8,7 +8,7 @@ import { approvalAnswererFor } from "./approvals.js";
8
8
  import { authorizationFor } from "./authorization.js";
9
9
  import { runtimeFor, workRuntimeFor } from "./runtime-registry.js";
10
10
  export const name = 'session-foundations-http';
11
- export const inject = ['webServer', 'agents', 'sessionPersistence', 'sessionQuery'];
11
+ export const inject = ['webServer', 'agents', 'sessionPersistence', 'sessionQuery', 'sessions'];
12
12
  /**
13
13
  * Local management routes for the same SQLite the main plugin uses.
14
14
  * Loaded only on profiles that have a web server, so headless does not need it.
package/dist/http.js CHANGED
@@ -8,6 +8,7 @@ import { permissionView, setPermission } from "./permissions.js";
8
8
  import { cuaAction, cuaSnapshot } from "./cua-access.js";
9
9
  import { provisionSession } from "./provision.js";
10
10
  import { handleWorkApi, openPageLive, openWorkLive } from "./work-http.js";
11
+ import { releaseLoadedAgent } from "./inbox.js";
11
12
  import { createLogSource } from "./log/source.js";
12
13
  import { createLogSnapshotService } from "./log/snapshot-service.js";
13
14
  import { dispatchLogRequest, probeConnection, registerLogRoutes } from "./log/routes.js";
@@ -26,11 +27,14 @@ export function registerHttp(ctx, engine, getRuntime = () => null, getWork = ()
26
27
  const profileDir = ctx.profileContext?.dir || (storeDir !== '' ? dirname(storeDir) : '');
27
28
  const logService = createLogSnapshotService(createLogSource(ctx));
28
29
  const logOnConnection = registerLogRoutes(ctx, logService);
30
+ const persistence = ctx.sessionPersistence;
31
+ const sessionsRoot = typeof persistence?.root === 'string' ? persistence.root : '';
29
32
  const desk = profileDir === ''
30
33
  ? null
31
34
  : createDesk({
32
35
  ledgerFile: join(storeDir, 'desk-ledger.json'),
33
36
  profileDir,
37
+ ...(sessionsRoot !== '' ? { sessionsRoot, stateRoot: dirname(sessionsRoot) } : {}),
34
38
  sessionCwd: defaultSessionCwd(process.env),
35
39
  isBot: sessionId => engine.isBot(sessionId),
36
40
  mark: sessionId => engine.markBot(sessionId),
@@ -40,6 +44,9 @@ export function registerHttp(ctx, engine, getRuntime = () => null, getWork = ()
40
44
  release: sessionId => {
41
45
  getWork()?.releaseHold(sessionId);
42
46
  },
47
+ releaseLoaded: sessionId => releaseLoadedAgent(sessionId),
48
+ releaseAttached: sessionId => unloadAttachedSession(ctx, sessionId),
49
+ stillAttached: sessionId => attachedSession(ctx, sessionId),
43
50
  rpc: (endpoint, args, req) => hostRpc(req, endpoint, args),
44
51
  usage: req => hostUsage(req),
45
52
  });
@@ -500,6 +507,84 @@ export function memoryView(engine, sessionId) {
500
507
  state: engine.statePayload(sessionId),
501
508
  };
502
509
  }
510
+ /**
511
+ * A live store entry means some fiber still has the session open.
512
+ * The caller must inject `sessions`. Reading it without inject throws.
513
+ * @param {import('./host.ts').HostContext} ctx
514
+ * @param {string} sessionId
515
+ */
516
+ export function attachedSession(ctx, sessionId) {
517
+ const sessions = ctx.sessions;
518
+ return typeof sessions?.get === 'function' && sessions.get(sessionId) != null;
519
+ }
520
+ /**
521
+ * Drop an idle session another fiber still has open, then let the caller delete its log.
522
+ * The host has no delete RPC. The store entry's detach is the same disposer `enter` keeps,
523
+ * and it emits `session/disposed`, which closes the JSONL writer.
524
+ * @param {import('./host.ts').HostContext} ctx
525
+ * @param {string} sessionId
526
+ */
527
+ export async function unloadAttachedSession(ctx, sessionId) {
528
+ const agent = liveAgentOf(ctx, sessionId);
529
+ if (agent && typeof agent.cancel === 'function') {
530
+ try {
531
+ agent.cancel({ kind: 'hook', reason: 'session-delete' }, { keepInbox: false });
532
+ }
533
+ catch {
534
+ /* already idle */
535
+ }
536
+ }
537
+ if (agent && typeof agent.whenIdle === 'function')
538
+ await agent.whenIdle();
539
+ const writer = sessionWriter(ctx, sessionId);
540
+ if (writer && typeof writer.close === 'function')
541
+ await writer.close();
542
+ detachAgentEntry(ctx, sessionId);
543
+ detachSessionEntry(ctx, sessionId);
544
+ }
545
+ /**
546
+ * @param {import('./host.ts').HostContext} ctx
547
+ * @param {string} sessionId
548
+ */
549
+ function liveAgentOf(ctx, sessionId) {
550
+ try {
551
+ return ctx.agents?.get?.(sessionId) ?? null;
552
+ }
553
+ catch {
554
+ return null;
555
+ }
556
+ }
557
+ /**
558
+ * @param {import('./host.ts').HostContext} ctx
559
+ * @param {string} sessionId
560
+ */
561
+ function sessionWriter(ctx, sessionId) {
562
+ const writers = ctx.sessionPersistence?.tracker?.writers;
563
+ if (!writers || typeof writers.get !== 'function')
564
+ return null;
565
+ const writer = writers.get(sessionId);
566
+ return writer && typeof writer === 'object' ? writer : null;
567
+ }
568
+ /**
569
+ * @param {import('./host.ts').HostContext} ctx
570
+ * @param {string} sessionId
571
+ */
572
+ function detachAgentEntry(ctx, sessionId) {
573
+ const agents = ctx.agents;
574
+ const entry = agents?.store?.get?.(sessionId);
575
+ if (!entry || typeof agents.detachEntered !== 'function')
576
+ return;
577
+ agents.detachEntered(entry);
578
+ }
579
+ /**
580
+ * @param {import('./host.ts').HostContext} ctx
581
+ * @param {string} sessionId
582
+ */
583
+ function detachSessionEntry(ctx, sessionId) {
584
+ const entry = ctx.sessions?.store?.get?.(sessionId);
585
+ if (entry && typeof entry.detach === 'function')
586
+ entry.detach();
587
+ }
503
588
  /**
504
589
  * @param {import('@deepseek-ai/cordis').Context} ctx
505
590
  * @param {import('node:http').IncomingMessage} req
package/dist/inbox.js CHANGED
@@ -25,6 +25,28 @@ export function liveAgent(ctx, sessionId) {
25
25
  }
26
26
  return handles.get(sessionId)?.agent ?? null;
27
27
  }
28
+ /**
29
+ * Close a session this module resumed, so its writer drains before a hard delete.
30
+ * A session owned by another fiber is left alone.
31
+ * @param {string} sessionId
32
+ */
33
+ export async function releaseLoadedAgent(sessionId) {
34
+ const pending = loading.get(sessionId);
35
+ if (pending) {
36
+ try {
37
+ await pending;
38
+ }
39
+ catch {
40
+ return;
41
+ }
42
+ }
43
+ const owned = handles.get(sessionId);
44
+ if (!owned || typeof owned.dispose !== 'function')
45
+ return;
46
+ await owned.dispose();
47
+ if (handles.get(sessionId) === owned)
48
+ handles.delete(sessionId);
49
+ }
28
50
  /**
29
51
  * @param {import('@deepseek-ai/cordis').Context} ctx
30
52
  * @param {string} sessionId
package/dist/index.js CHANGED
@@ -12,7 +12,7 @@ import { createQuestionAnswerer, publishQuestionAnswerer, questionAnswererFor }
12
12
  import { createApprovalAnswerer, publishApprovalAnswerer, approvalAnswererFor } from "./approvals.js";
13
13
  import { createAuthorizationController, publishAuthorization, authorizationFor } from "./authorization.js";
14
14
  import { publishRuntime, publishWorkRuntime, runtimeFor } from "./runtime-registry.js";
15
- import { childCreateOptions, effectiveWorkLimits, resolveWorkBudget, WORK_BUDGET_ENV, } from "./work-admit.js";
15
+ import { childCreateOptions, effectiveWorkLimits, pinMainReasoning, resolveWorkBudget, workerModelSelection, WORK_BUDGET_ENV, } from "./work-admit.js";
16
16
  import { ensureWorkerFilePreset, WORKER_FILE_PRESET, workerFileSetup } from "./work-child.js";
17
17
  import { BUDGET_NOTICE_PREFIX, createWorkRuntime } from "./work-worker.js";
18
18
  import { workToolDefinitions } from "./work-tools.js";
@@ -187,6 +187,7 @@ export function apply(ctx, config = {}) {
187
187
  });
188
188
  ctx.on('agent/created', (payload) => {
189
189
  const agent = payload?.agent;
190
+ pinMainReasoning(agent, id => engine.isBot(id));
190
191
  if (!agent?.id || !engine.isBot(agent.id))
191
192
  return;
192
193
  let session = null;
@@ -201,6 +202,9 @@ export function apply(ctx, config = {}) {
201
202
  seeded: session?.header?.isSeeded === true,
202
203
  });
203
204
  });
205
+ ctx.on('agent/inbox/inserted', (payload) => {
206
+ pinMainReasoning(payload?.agent, id => engine.isBot(id));
207
+ });
204
208
  triggers = ctx.agents ? startTriggers(ctx, store, engine) : null;
205
209
  work = ctx.agents ? startWork(ctx, store, engine, config) : null;
206
210
  if (triggers) {
@@ -345,7 +349,7 @@ function startWork(ctx, store, engine, config) {
345
349
  try {
346
350
  const owner = ctx.agents?.get(spec.ownerSessionId);
347
351
  cwd = owner?.session?.header?.cwd ?? ctx.sessions?.get(spec.ownerSessionId)?.header?.cwd ?? '';
348
- model = owner?.model?.current?.() ?? null;
352
+ model = workerModelSelection(owner?.model?.current?.() ?? null);
349
353
  }
350
354
  catch {
351
355
  cwd = '';
@@ -353,7 +357,7 @@ function startWork(ctx, store, engine, config) {
353
357
  }
354
358
  if (!model?.provider || !model?.model) {
355
359
  try {
356
- model = ctx.agentDefaultModel?.currentSelection?.() ?? null;
360
+ model = workerModelSelection(ctx.agentDefaultModel?.currentSelection?.() ?? null);
357
361
  }
358
362
  catch {
359
363
  model = null;
@@ -1,4 +1,4 @@
1
- /** Remove one blank session's on-disk log. DSH has no delete RPC; session/list rescans these directories. */
1
+ /** Remove one session's on-disk log. DSH has no delete RPC; session/list rescans these directories. */
2
2
  import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
3
3
  import { join, resolve, sep } from 'node:path';
4
4
  const SESSION_ID = /^session-[A-Za-z0-9-]+$/;
@@ -261,6 +261,39 @@ export function estimateWorkerBudget(_briefing, suggestion, defaults = DEFAULT_W
261
261
  globalQueue: defaults.globalQueue,
262
262
  };
263
263
  }
264
+ /** Main-session reasoning effort. `off` skips thinking so the reply starts sooner. */
265
+ export const MAIN_REASONING_EFFORT = 'off';
266
+ /**
267
+ * Record `off` on a bot main session before the next step is prepared.
268
+ * A matching selection is left alone. Ordinary sessions are left alone.
269
+ * Call this outside an open session append: `model.select` appends `model/selection`.
270
+ * @param {{ id?: string, model?: { current?: () => ModelSelection, select?: (selection: { provider: string, model: string, reasoningEffort: string }) => void } } | null | undefined} agent
271
+ * @param {(sessionId: string) => boolean} isBot
272
+ */
273
+ export function pinMainReasoning(agent, isBot) {
274
+ if (!agent || typeof agent.id !== 'string' || agent.id === '' || !isBot(agent.id))
275
+ return false;
276
+ const current = agent.model?.current?.();
277
+ if (!current?.provider || !current.model || current.reasoningEffort === MAIN_REASONING_EFFORT)
278
+ return false;
279
+ agent.model?.select?.({
280
+ provider: current.provider,
281
+ model: current.model,
282
+ reasoningEffort: MAIN_REASONING_EFFORT,
283
+ });
284
+ return true;
285
+ }
286
+ /**
287
+ * Worker route copied from the main session. Thinking stays at the adapter
288
+ * default: the main session's `off` is for reply latency and is not copied.
289
+ * @param {ModelSelection} model
290
+ */
291
+ export function workerModelSelection(model) {
292
+ if (!model || model.reasoningEffort !== MAIN_REASONING_EFFORT)
293
+ return model;
294
+ const { reasoningEffort: _effort, ...rest } = model;
295
+ return rest;
296
+ }
264
297
  /**
265
298
  * Child creation options. parentAgent and meta.parentSession are omitted on purpose:
266
299
  * the parent link lives only on the ticket row.
@@ -20,11 +20,15 @@ export function renderBriefing(input) {
20
20
  `material_sha256: ${material}`,
21
21
  'When no separate read-only material is attached, the material hash equals the task-text hash.',
22
22
  'Forbidden: do not write the main session, do not change persona or long-term memory, do not send outward, and do not approve spending.',
23
+ 'You may read the main session. The host already queried it and attached the excerpt below. foundations_main_history reads it again directly and does not raise an authorization prompt.',
23
24
  'Report only with foundations_report. kind must be progress, question, artifact, result, or failure.',
24
25
  'This is not cross-bot mail and cannot raise permissions.',
25
26
  '---',
26
27
  input.text,
27
28
  ];
29
+ const history = typeof input.history === 'string' ? input.history.trim() : '';
30
+ if (history !== '')
31
+ lines.push('', history);
28
32
  if (input.kind === 'cancel_note') {
29
33
  return [
30
34
  '[foundations:briefing]',
@@ -36,6 +40,98 @@ export function renderBriefing(input) {
36
40
  }
37
41
  return lines.join('\n');
38
42
  }
43
+ const HISTORY_MESSAGES = 16;
44
+ const HISTORY_LINE = 1200;
45
+ const HISTORY_TOTAL = 8000;
46
+ /**
47
+ * Recent main-session dialogue for a worker ticket. Runtime snapshots, plugin
48
+ * notices, and reasoning blocks are left out. An empty log returns ''.
49
+ * @param {readonly Record<string, any>[] | null | undefined} events
50
+ * @param {{ maxMessages?: number, maxLine?: number, maxChars?: number }} [limits]
51
+ */
52
+ export function renderMainHistory(events, limits = {}) {
53
+ if (!Array.isArray(events) || events.length === 0)
54
+ return '';
55
+ const maxMessages = clampHistory(limits.maxMessages, HISTORY_MESSAGES, 1, 40);
56
+ const maxLine = clampHistory(limits.maxLine, HISTORY_LINE, 200, 4000);
57
+ const maxChars = clampHistory(limits.maxChars, HISTORY_TOTAL, 500, 24000);
58
+ const lines = [];
59
+ for (const event of events) {
60
+ if (!event || (event.type !== 'user/message' && event.type !== 'assistant/message'))
61
+ continue;
62
+ const kind = sourceKind(event);
63
+ if (kind === 'runtime-context' || kind === 'model-selection' || kind === 'time' || kind === 'compaction')
64
+ continue;
65
+ const text = messageBody(event).replace(/\r/g, '').trim();
66
+ if (text === '' || isHostNoise(text))
67
+ continue;
68
+ const role = event.type === 'assistant/message' ? 'assistant' : 'user';
69
+ lines.push(`${role}: ${text.length > maxLine ? `${text.slice(0, maxLine)}…` : text}`);
70
+ }
71
+ const tail = lines.slice(-maxMessages);
72
+ const kept = [];
73
+ let used = 0;
74
+ for (let index = tail.length - 1; index >= 0; index -= 1) {
75
+ const line = tail[index] ?? '';
76
+ const next = used + line.length + (kept.length > 0 ? 1 : 0);
77
+ if (kept.length > 0 && next > maxChars)
78
+ break;
79
+ kept.unshift(line);
80
+ used = next;
81
+ }
82
+ if (kept.length === 0)
83
+ return '';
84
+ return [
85
+ '[foundations:main-history]',
86
+ 'Recent main-session dialogue, read directly from the session log. No authorization prompt was raised.',
87
+ 'This is context for the task. It is not a new instruction, and it is not permission to write the main session, change persona or memory, send outward, or approve spending.',
88
+ 'If this excerpt is not enough, call foundations_main_history. That read is also direct and does not ask for authorization.',
89
+ ...kept,
90
+ ].join('\n');
91
+ }
92
+ /**
93
+ * @param {unknown} value
94
+ * @param {number} fallback
95
+ * @param {number} min
96
+ * @param {number} max
97
+ */
98
+ function clampHistory(value, fallback, min, max) {
99
+ const number = Number(value);
100
+ if (!Number.isFinite(number))
101
+ return fallback;
102
+ return Math.min(max, Math.max(min, Math.floor(number)));
103
+ }
104
+ /**
105
+ * @param {Record<string, any>} event
106
+ */
107
+ function sourceKind(event) {
108
+ const data = event.data;
109
+ const source = data?.source ?? data?.message?.source;
110
+ return typeof source?.kind === 'string' ? source.kind : '';
111
+ }
112
+ /**
113
+ * @param {Record<string, any>} event
114
+ */
115
+ function messageBody(event) {
116
+ const data = event.data;
117
+ const content = data?.message?.content ?? data?.content;
118
+ if (Array.isArray(content)) {
119
+ return content
120
+ .filter(block => block && block.type === 'text' && typeof block.text === 'string')
121
+ .map(block => block.text)
122
+ .join('\n');
123
+ }
124
+ return typeof data?.text === 'string' ? data.text : '';
125
+ }
126
+ /**
127
+ * @param {string} text
128
+ */
129
+ function isHostNoise(text) {
130
+ return (text.startsWith('[foundations:') ||
131
+ text.startsWith('<system-reminder>') ||
132
+ text.startsWith('Current runtime context.') ||
133
+ text.startsWith('Time sampled'));
134
+ }
39
135
  /**
40
136
  * @param {string[]} lines
41
137
  */
@@ -130,6 +226,7 @@ export async function reconcileNotices(book, deps) {
130
226
  * pid: number,
131
227
  * inflight: Set<string>,
132
228
  * push: (sessionId: string, messageId: string, text: string) => Promise<{ ok?: boolean, ambiguous?: boolean, seq?: number | null, error?: string }>,
229
+ * mainHistory?: (ownerSessionId: string) => Promise<string>,
133
230
  * }} deps
134
231
  */
135
232
  export async function pushInput(book, input, deps) {
@@ -152,7 +249,17 @@ export async function pushInput(book, input, deps) {
152
249
  /* host default */
153
250
  }
154
251
  const text = book.readBriefing(input.payload_hash);
155
- const body = renderBriefing({ text, revision: input.briefing_revision, budget, kind: input.kind });
252
+ let history = '';
253
+ const owner = typeof ticket.owner_session_id === 'string' ? ticket.owner_session_id : '';
254
+ if (input.kind !== 'cancel_note' && owner !== '' && deps.mainHistory) {
255
+ try {
256
+ history = await deps.mainHistory(owner);
257
+ }
258
+ catch {
259
+ history = '';
260
+ }
261
+ }
262
+ const body = renderBriefing({ text, revision: input.briefing_revision, budget, kind: input.kind, history });
156
263
  deps.inflight.add(input.native_message_id);
157
264
  try {
158
265
  return await durableFollowup({
@@ -88,6 +88,8 @@ export function createTicketBook(db, root, now = () => new Date()) {
88
88
  attemptsOf,
89
89
  ownerIds,
90
90
  childIds,
91
+ ownerIdsForReconcile,
92
+ childIdsForReconcile,
91
93
  };
92
94
  /**
93
95
  * @param {string} sql
@@ -1285,6 +1287,56 @@ export function createTicketBook(db, root, now = () => new Date()) {
1285
1287
  .all()
1286
1288
  .map(item => item.id);
1287
1289
  }
1290
+ /**
1291
+ * Owners whose log can still bind a publish intent to an assistant seq.
1292
+ * Delivered, abandoned, and absent rows have nothing left to read.
1293
+ */
1294
+ function ownerIdsForReconcile() {
1295
+ return db
1296
+ .prepare(`
1297
+ SELECT DISTINCT owner_session_id AS id FROM user_deliveries
1298
+ WHERE status = 'intent'
1299
+ `)
1300
+ .all()
1301
+ .map(item => item.id);
1302
+ }
1303
+ /**
1304
+ * Child logs that can still move a ticket.
1305
+ * A running attempt is included. A needs_user attempt is not, once its
1306
+ * question/result/failure is applied, because that log no longer changes
1307
+ * the ledger until a supply or retry enqueues the attempt again.
1308
+ * A terminal attempt is included only while a terminal report for the
1309
+ * active attempt is still pending_completion, so the final turn/end is
1310
+ * applied or staled once and then the closed log is left alone.
1311
+ */
1312
+ function childIdsForReconcile() {
1313
+ return db
1314
+ .prepare(`
1315
+ SELECT DISTINCT a.child_session_id AS id
1316
+ FROM work_attempts a
1317
+ JOIN work_tickets t ON t.id = a.ticket_id
1318
+ WHERE a.child_session_id IS NOT NULL
1319
+ AND (
1320
+ a.status IN ('starting', 'enqueued')
1321
+ OR (
1322
+ a.status = 'started'
1323
+ AND t.status IN ('accepted', 'enqueued', 'started')
1324
+ )
1325
+ OR (
1326
+ t.active_attempt_id = a.id
1327
+ AND EXISTS (
1328
+ SELECT 1 FROM work_events e
1329
+ WHERE e.attempt_id = a.id
1330
+ AND e.briefing_revision = t.briefing_revision
1331
+ AND e.apply_status = 'pending_completion'
1332
+ AND e.kind IN ('question', 'result', 'failure')
1333
+ )
1334
+ )
1335
+ )
1336
+ `)
1337
+ .all()
1338
+ .map(item => item.id);
1339
+ }
1288
1340
  /**
1289
1341
  * @param {string} owner
1290
1342
  */
@@ -106,6 +106,19 @@ export function workToolDefinitions(work, engine) {
106
106
  },
107
107
  required: ['resultEventId'],
108
108
  }, (args, hostId) => work.reject(hostId, args), 'bot'),
109
+ tool('foundations_main_history', 'Read the main session that owns this ticket. The host queries the session log directly and does not raise an authorization prompt. Use it when the attached excerpt is missing a line you need. Do not write the main session.', {
110
+ type: 'object',
111
+ properties: {
112
+ maxChars: {
113
+ type: 'integer',
114
+ description: 'Optional cap for the returned excerpt, from 500 to 24000. Omit it for the default excerpt.',
115
+ },
116
+ },
117
+ }, async (args, hostId) => {
118
+ const maxChars = Number(args.maxChars);
119
+ const limits = Number.isFinite(maxChars) ? { maxChars } : undefined;
120
+ return work.mainHistory(hostId, limits);
121
+ }, 'worker'),
109
122
  tool('foundations_report', 'The worker reports progress, a question, an artifact, a result, or a failure. This only writes the ledger. ticket, attempt, fence, and owner are discarded.', {
110
123
  type: 'object',
111
124
  properties: {