imprint-mcp 0.6.4 → 0.6.6

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.
Files changed (38) hide show
  1. package/README.md +5 -0
  2. package/package.json +1 -1
  3. package/prompts/audit-agent.md +3 -3
  4. package/prompts/auth-compile-agent.md +46 -4
  5. package/prompts/compile-agent.md +36 -12
  6. package/prompts/live-verifier-agent.md +15 -5
  7. package/prompts/request-triage.md +51 -9
  8. package/prompts/tool-candidate-detection.md +7 -1
  9. package/prompts/tool-planning.md +1 -1
  10. package/src/cli.ts +71 -13
  11. package/src/imprint/audit.ts +23 -5
  12. package/src/imprint/auth-compile-agent.ts +11 -7
  13. package/src/imprint/auth-compile-tools.ts +127 -18
  14. package/src/imprint/auth-verifier.ts +2 -1
  15. package/src/imprint/backend-ladder.ts +20 -0
  16. package/src/imprint/build-plan.ts +21 -0
  17. package/src/imprint/claude-cli-compile.ts +7 -1
  18. package/src/imprint/codex-cli-compile.ts +6 -0
  19. package/src/imprint/compile-agent.ts +50 -9
  20. package/src/imprint/compile-tools.ts +308 -25
  21. package/src/imprint/compile-verification.ts +11 -2
  22. package/src/imprint/compile.ts +298 -69
  23. package/src/imprint/effects.ts +9 -0
  24. package/src/imprint/live-verifier.ts +455 -34
  25. package/src/imprint/login.ts +30 -12
  26. package/src/imprint/mcp-compile-server.ts +56 -5
  27. package/src/imprint/mcp-live-verifier-server.ts +43 -10
  28. package/src/imprint/probe-backends.ts +6 -0
  29. package/src/imprint/recording-request.ts +7 -2
  30. package/src/imprint/replay-capture.ts +48 -29
  31. package/src/imprint/request-capture.ts +14 -0
  32. package/src/imprint/runtime.ts +102 -22
  33. package/src/imprint/teach-state.ts +162 -21
  34. package/src/imprint/teach.ts +629 -226
  35. package/src/imprint/tool-candidates.ts +138 -0
  36. package/src/imprint/tool-plan.ts +2 -0
  37. package/src/imprint/triage-selection.ts +44 -0
  38. package/src/imprint/types.ts +39 -3
@@ -23,7 +23,7 @@ import type { SharedModuleManifestEntry } from './build-plan.ts';
23
23
  import { type CompileAgentProgress, compileAgent } from './compile-agent.ts';
24
24
  import { isSameRegistrableDomain, registrableDomain } from './etld.ts';
25
25
  import { compactUrlForLlm } from './llm-url.ts';
26
- import { type LLMOptions, extractJsonArray, resolveProvider } from './llm.ts';
26
+ import { type LLMOptions, extractJsonArray, extractJsonObject, resolveProvider } from './llm.ts';
27
27
  import { loadJsonFile } from './load-json.ts';
28
28
  import { createLog } from './log.ts';
29
29
  import { imprintHomeDir, localSiteDir, localToolDir } from './paths.ts';
@@ -35,6 +35,7 @@ import type { ClassifiedValue } from './session-diff.ts';
35
35
  import { isTelemetryRequest } from './telemetry.ts';
36
36
  import type { SharedCompileContext, ToolCandidate } from './tool-candidates.ts';
37
37
  import { setSpanAttributes, traced } from './tracing.ts';
38
+ import { applySharedTriageSelection } from './triage-selection.ts';
38
39
  import {
39
40
  type Playbook,
40
41
  type Session,
@@ -81,7 +82,7 @@ interface GenerateOptions extends CompileOptions {
81
82
  onProgress?: (p: CompileAgentProgress) => void;
82
83
  /** Called when wall-clock deadline is reached; return ms to extend or null to time out. */
83
84
  onDeadlineReached?: OnDeadlineReached;
84
- /** Retain parser.test.ts after successful verification. */
85
+ /** Retain agent-generated tests after successful verification. */
85
86
  keepTest?: boolean;
86
87
  /** Directory where workflow.json/parser.ts/parser.test.ts are written. */
87
88
  outDir?: string;
@@ -143,6 +144,7 @@ export async function generate(opts: GenerateOptions): Promise<GenerateResult> {
143
144
  sharedModules: opts.sharedModules,
144
145
  toolPlan: opts.toolPlan,
145
146
  revisionMode: opts.revisionMode,
147
+ preTriagedSession: opts.preTriagedSession,
146
148
  });
147
149
 
148
150
  setSpanAttributes(span, {
@@ -343,6 +345,9 @@ const HEADER_TRUNCATE_LIMIT = 200;
343
345
  // data-bearing POSTs (search/booking) from telemetry; full bodies on a busy
344
346
  // site can total >1MB and blow the 200K-token cap on `claude-opus-4-8`.
345
347
  const TRIAGE_BODY_LIMIT = 500;
348
+ const EFFECT_TRIAGE_BODY_LIMIT = 800;
349
+ // Leave headroom for narration and browser-action context in every effect pass.
350
+ const EFFECT_TRIAGE_BATCH_CHARS = 300_000;
346
351
  const TRIAGE_ACTION_ALIGNMENT_BEFORE_MS = 1000;
347
352
  const TRIAGE_ACTION_ALIGNMENT_AFTER_MS = 5000;
348
353
  const TRIAGE_CONTEXT_EVENT_TYPES = new Set<Session['events'][number]['type']>([
@@ -351,6 +356,7 @@ const TRIAGE_CONTEXT_EVENT_TYPES = new Set<Session['events'][number]['type']>([
351
356
  'input',
352
357
  'change',
353
358
  'submit',
359
+ 'ws-sent',
354
360
  ]);
355
361
  const TRIAGE_ACTION_EVENT_TYPES = new Set<Session['events'][number]['type']>([
356
362
  'input',
@@ -361,6 +367,18 @@ const TRIAGE_ACTION_EVENT_TYPES = new Set<Session['events'][number]['type']>([
361
367
  export interface TriageResult {
362
368
  session: Session;
363
369
  selectedSeqs: number[];
370
+ /** Every full-inventory request covered by v2 triage except those classified
371
+ * irreversible. Independent of compile relevance. */
372
+ replaySafeSeqs: number[];
373
+ /** Full-inventory requests that are irreversible if
374
+ * re-issued (place order, charge, send, delete). Used to block them during
375
+ * replay and to flag the compiled tool so compile-verify + audit don't
376
+ * trigger the real action. */
377
+ irreversibleSeqs: number[];
378
+ /** Outbound WebSocket events shown to the effect classifier. */
379
+ coveredOutboundEventSeqs: number[];
380
+ /** Outbound WebSocket events whose replay can cause an irreversible effect. */
381
+ irreversibleEventSeqs: number[];
364
382
  consideredCount: number;
365
383
  inputTokens: number | null;
366
384
  outputTokens: number | null;
@@ -377,10 +395,12 @@ interface TriageRequestContext {
377
395
  mimeType?: string;
378
396
  headers: string;
379
397
  body?: string;
398
+ urlDigest?: string;
380
399
  bodyDigest?: string;
381
400
  bodyLength?: number;
382
401
  responseBodyDigest?: string;
383
402
  responseBodyLength?: number;
403
+ responsePreview?: string;
384
404
  repeatCount?: number;
385
405
  repeatedSeqs?: number[];
386
406
  lastTimestamp?: number;
@@ -393,6 +413,67 @@ interface TriageEventContext {
393
413
  detail: string;
394
414
  }
395
415
 
416
+ export function parseTriageSelectionResponse(text: string): {
417
+ keepSeqs: number[];
418
+ irreversibleSeqs: number[];
419
+ irreversibleEventSeqs: number[];
420
+ } {
421
+ const isNumArray = (v: unknown): v is number[] =>
422
+ Array.isArray(v) && v.every((s) => typeof s === 'number');
423
+
424
+ const objText = extractJsonObject(text);
425
+ if (objText) {
426
+ let parsed: unknown;
427
+ try {
428
+ parsed = JSON.parse(objText);
429
+ } catch (err) {
430
+ throw new Error(
431
+ `Triage response object was not valid JSON: ${err instanceof Error ? err.message : String(err)}\nExtracted:\n${objText.slice(0, 500)}`,
432
+ );
433
+ }
434
+ if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
435
+ throw new Error(
436
+ `Triage response object is not an object.\nParsed: ${JSON.stringify(parsed)}`,
437
+ );
438
+ }
439
+
440
+ const record = parsed as {
441
+ keep?: unknown;
442
+ irreversible?: unknown;
443
+ irreversibleEvents?: unknown;
444
+ };
445
+ if (!isNumArray(record.keep)) {
446
+ throw new Error(
447
+ `Triage response field "keep" must be an array of numbers.\nParsed: ${(JSON.stringify(record.keep) ?? String(record.keep)).slice(0, 500)}`,
448
+ );
449
+ }
450
+ if (!isNumArray(record.irreversible)) {
451
+ throw new Error(
452
+ `Triage response field "irreversible" must be an array of numbers.\nParsed: ${(JSON.stringify(record.irreversible) ?? String(record.irreversible)).slice(0, 500)}`,
453
+ );
454
+ }
455
+ if (!isNumArray(record.irreversibleEvents)) {
456
+ throw new Error(
457
+ `Triage response field "irreversibleEvents" must be an array of numbers.\nParsed: ${(JSON.stringify(record.irreversibleEvents) ?? String(record.irreversibleEvents)).slice(0, 500)}`,
458
+ );
459
+ }
460
+ return {
461
+ keepSeqs: record.keep,
462
+ irreversibleSeqs: record.irreversible,
463
+ irreversibleEventSeqs: record.irreversibleEvents,
464
+ };
465
+ }
466
+
467
+ if (!extractJsonArray(text)) {
468
+ throw new Error(
469
+ `Triage LLM did not return the required effect-aware object {"keep": [...], "irreversible": [...]}.\nRaw response:\n${text.slice(0, 1000)}`,
470
+ );
471
+ }
472
+ throw new Error(
473
+ `Triage LLM must return the effect-aware object {"keep": [...], "irreversible": [...]}; legacy arrays are unsafe because they cannot prove irreversible classification.\nRaw response:\n${text.slice(0, 1000)}`,
474
+ );
475
+ }
476
+
396
477
  export async function triageRequests(
397
478
  session: Session,
398
479
  llmConfig?: LLMOptions,
@@ -404,6 +485,7 @@ export async function triageRequests(
404
485
  ...(context.sharedContext?.loginRequestSeqs ?? []),
405
486
  ]);
406
487
  const candidates = selectTriageCandidateRequests(session, preserveSeqs);
488
+ const keepEligibleSeqs = new Set(candidates.map((request) => request.seq));
407
489
 
408
490
  return await traced(
409
491
  'compile.triage_requests',
@@ -415,38 +497,56 @@ export async function triageRequests(
415
497
  'imprint.provider': llmConfig?.provider ?? 'auto',
416
498
  },
417
499
  async (span) => {
500
+ const requestContext = (
501
+ r: Session['requests'][number],
502
+ bodyLimit: number,
503
+ includeResponse = true,
504
+ ): TriageRequestContext => ({
505
+ seq: r.seq,
506
+ timestamp: r.timestamp,
507
+ method: r.method,
508
+ url: compactUrlForLlm(r.url),
509
+ resourceType: r.resourceType,
510
+ status: r.response?.status,
511
+ mimeType: r.response?.mimeType,
512
+ headers: truncateHeaders(r.headers),
513
+ body: triageBodySnippet(r.body, bodyLimit),
514
+ urlDigest: requestContextDigest(r.url),
515
+ bodyDigest: requestContextDigest(r.body),
516
+ bodyLength: r.body?.length,
517
+ ...(includeResponse
518
+ ? {
519
+ responseBodyDigest: requestContextDigest(r.response?.body),
520
+ responseBodyLength: r.response?.body?.length,
521
+ responsePreview: triageBodySnippet(r.response?.body, bodyLimit),
522
+ }
523
+ : {}),
524
+ });
418
525
  const compacted = compactRequestContexts(
419
- candidates.map((r) => ({
420
- seq: r.seq,
421
- timestamp: r.timestamp,
422
- method: r.method,
423
- url: compactUrlForLlm(r.url),
424
- resourceType: r.resourceType,
425
- status: r.response?.status,
426
- mimeType: r.response?.mimeType,
427
- headers: truncateHeaders(r.headers),
428
- body: triageBodySnippet(r.body),
429
- bodyDigest: requestContextDigest(r.body),
430
- bodyLength: r.body?.length,
431
- responseBodyDigest: requestContextDigest(r.response?.body),
432
- responseBodyLength: r.response?.body?.length,
433
- })),
526
+ session.requests.map((request) => requestContext(request, EFFECT_TRIAGE_BODY_LIMIT)),
434
527
  triageRequestGroupKey,
435
528
  { preserveSeqs },
436
529
  );
437
- // Strip digest/length fields the LLM doesn't use — they served compaction only
438
- const metadata = compacted.map(
439
- ({ bodyDigest, responseBodyDigest, bodyLength, responseBodyLength, ...rest }) => rest,
440
- );
441
-
442
- const triagePayload = {
443
- site: session.site,
444
- url: compactUrlForLlm(session.url),
445
- narration: session.narration,
446
- events: buildTriageEventContexts(session),
447
- requests: metadata,
530
+ const requestMetadata = (
531
+ request: TriageRequestContext,
532
+ ): Omit<TriageRequestContext, 'urlDigest' | 'bodyDigest' | 'responseBodyDigest'> & {
533
+ keepEligible: boolean;
534
+ } => {
535
+ const { urlDigest, bodyDigest, responseBodyDigest, ...rest } = request;
536
+ return {
537
+ ...rest,
538
+ keepEligible: compactedRequestSeqs(rest).some((seq) => keepEligibleSeqs.has(seq)),
539
+ };
448
540
  };
449
- const triagePayloadChars = JSON.stringify(triagePayload).length;
541
+ const metadata = compacted.map(requestMetadata);
542
+ const coveredSeqs = expandCompactedTriageSeqs(
543
+ compacted.map((request) => request.seq),
544
+ compacted,
545
+ );
546
+ const outboundEvents = buildTriageEventContexts(session).filter(
547
+ (event) => event.type === 'ws-sent',
548
+ );
549
+ const coveredOutboundEventSeqs = outboundEvents.map((event) => event.seq);
450
550
 
451
551
  const promptPath = pathJoin(PROMPTS_DIR, 'request-triage.md');
452
552
  if (!existsSync(promptPath)) {
@@ -455,60 +555,147 @@ export async function triageRequests(
455
555
  );
456
556
  }
457
557
  const systemPrompt = readFileSync(promptPath, 'utf8');
458
-
558
+ const llm = resolveProvider(llmConfig ?? {});
559
+ const contextEvents = buildTriageEventContexts(session).filter(
560
+ (event) => event.type !== 'ws-sent',
561
+ );
562
+ const relevanceCompacted = compactRequestContexts(
563
+ candidates.map((request) => requestContext(request, TRIAGE_BODY_LIMIT, false)),
564
+ triageRequestGroupKey,
565
+ { preserveSeqs },
566
+ );
567
+ const relevancePayload = {
568
+ mode: 'relevance',
569
+ site: session.site,
570
+ url: compactUrlForLlm(session.url),
571
+ narration: session.narration,
572
+ events: contextEvents,
573
+ requests: relevanceCompacted.map(requestMetadata),
574
+ outboundWebSockets: [],
575
+ };
459
576
  log(
460
- `triaging ${metadata.length} compacted requests (from ${candidates.length} candidates / ${session.requests.length} total); ${Math.round(triagePayloadChars / 1024)} KB payload…`,
577
+ `triaging ${relevanceCompacted.length} relevance candidates; ${Math.round(JSON.stringify(relevancePayload).length / 1024)} KB payload…`,
461
578
  );
462
- const llm = resolveProvider(llmConfig ?? {});
463
- const result = await llm.analyze(systemPrompt, triagePayload);
464
-
465
- const arrayText = extractJsonArray(result.text);
466
- if (!arrayText) {
579
+ const relevanceResult = await llm.analyze(systemPrompt, relevancePayload);
580
+ const { keepSeqs } = parseTriageSelectionResponse(relevanceResult.text);
581
+ const candidateSet = new Set(
582
+ expandCompactedTriageSeqs(
583
+ relevanceCompacted.map((request) => request.seq),
584
+ relevanceCompacted,
585
+ ),
586
+ );
587
+ const unknownKeepSeqs = keepSeqs.filter((seq) => !candidateSet.has(seq));
588
+ if (unknownKeepSeqs.length > 0) {
467
589
  throw new Error(
468
- `Triage LLM did not return a JSON array.\nRaw response:\n${result.text.slice(0, 1000)}`,
590
+ `Triage response referenced request seq(s) absent from its relevance inventory: ${[...new Set(unknownKeepSeqs)].join(', ')}.`,
469
591
  );
470
592
  }
471
593
 
472
- let seqs: unknown;
473
- try {
474
- seqs = JSON.parse(arrayText);
475
- } catch (err) {
476
- throw new Error(
477
- `Triage response was not valid JSON: ${err instanceof Error ? err.message : String(err)}\nExtracted:\n${arrayText.slice(0, 500)}`,
594
+ const safetyItems = [
595
+ ...metadata.map((request) => ({ kind: 'request' as const, value: request })),
596
+ ...outboundEvents.map((event) => ({ kind: 'websocket' as const, value: event })),
597
+ ];
598
+ const safetyBatches = chunkTriageItems(safetyItems, EFFECT_TRIAGE_BATCH_CHARS);
599
+ const irreversibleSeqs: number[] = [];
600
+ const irreversibleEventSeqs: number[] = [];
601
+ let inputTokens = relevanceResult.inputTokens;
602
+ let outputTokens = relevanceResult.outputTokens;
603
+ let durationMs = relevanceResult.durationMs;
604
+ let safetyPayloadChars = 0;
605
+ for (const [batchIndex, batch] of safetyBatches.entries()) {
606
+ const batchRequests = batch
607
+ .filter((item) => item.kind === 'request')
608
+ .map((item) => item.value);
609
+ const batchWebSockets = batch
610
+ .filter((item) => item.kind === 'websocket')
611
+ .map((item) => item.value);
612
+ const safetyPayload = {
613
+ mode: 'effect',
614
+ batch: { index: batchIndex + 1, total: safetyBatches.length },
615
+ site: session.site,
616
+ url: compactUrlForLlm(session.url),
617
+ narration: session.narration,
618
+ events: contextEvents,
619
+ requests: batchRequests,
620
+ outboundWebSockets: batchWebSockets,
621
+ };
622
+ safetyPayloadChars += JSON.stringify(safetyPayload).length;
623
+ const result = await llm.analyze(systemPrompt, safetyPayload);
624
+ const parsed = parseTriageSelectionResponse(result.text);
625
+ const batchRequestSeqs = new Set(
626
+ batchRequests.flatMap((request) => compactedRequestSeqs(request)),
627
+ );
628
+ const batchEventSeqs = new Set(batchWebSockets.map((event) => event.seq));
629
+ const unknownRequests = parsed.irreversibleSeqs.filter((seq) => !batchRequestSeqs.has(seq));
630
+ const unknownEvents = parsed.irreversibleEventSeqs.filter(
631
+ (seq) => !batchEventSeqs.has(seq),
478
632
  );
633
+ if (unknownRequests.length > 0 || unknownEvents.length > 0) {
634
+ throw new Error(
635
+ `Effect triage batch ${batchIndex + 1} referenced item(s) absent from its inventory: ${[...new Set([...unknownRequests, ...unknownEvents])].join(', ')}.`,
636
+ );
637
+ }
638
+ irreversibleSeqs.push(...parsed.irreversibleSeqs);
639
+ irreversibleEventSeqs.push(...parsed.irreversibleEventSeqs);
640
+ inputTokens = sumOptionalTokens(inputTokens, result.inputTokens);
641
+ outputTokens = sumOptionalTokens(outputTokens, result.outputTokens);
642
+ durationMs += result.durationMs;
479
643
  }
480
644
 
481
- if (!Array.isArray(seqs) || !seqs.every((s) => typeof s === 'number')) {
645
+ const coveredSet = new Set(coveredSeqs);
646
+ const unknownOutputSeqs = irreversibleSeqs.filter((seq) => !coveredSet.has(seq));
647
+ if (unknownOutputSeqs.length > 0) {
482
648
  throw new Error(
483
- `Triage response is not an array of numbers.\nParsed: ${JSON.stringify(seqs).slice(0, 500)}`,
649
+ `Triage response referenced request seq(s) absent from its complete inventory: ${[...new Set(unknownOutputSeqs)].join(', ')}.`,
484
650
  );
485
651
  }
486
652
 
487
- const rescuedSeqs = rescueActionAlignedRepeatedSeqs(session, seqs as number[], compacted);
488
- const selectedSet = new Set([...(seqs as number[]), ...rescuedSeqs, ...preserveSeqs]);
653
+ const rescuedSeqs = rescueActionAlignedRepeatedSeqs(session, keepSeqs as number[], compacted);
654
+ const selectedSet = new Set([...keepSeqs, ...rescuedSeqs, ...preserveSeqs]);
655
+ const irreversibleSet = new Set(expandCompactedTriageSeqs(irreversibleSeqs, compacted));
656
+ const irreversibleEventSet = new Set(irreversibleEventSeqs);
657
+ const replaySafeSeqs = coveredSeqs.filter((seq) => !irreversibleSet.has(seq));
489
658
  const triaged: Session = {
490
659
  ...session,
491
- requests: session.requests.filter((r) => selectedSet.has(r.seq)),
660
+ triage: {
661
+ effectSchemaVersion: 2,
662
+ coveredSeqs,
663
+ irreversibleSeqs: [...irreversibleSet].sort((a, b) => a - b),
664
+ coveredOutboundEventSeqs,
665
+ irreversibleEventSeqs: [...irreversibleEventSet].sort((a, b) => a - b),
666
+ },
667
+ requests: session.requests
668
+ .filter((r) => selectedSet.has(r.seq))
669
+ .map((r) => (irreversibleSet.has(r.seq) ? { ...r, effect: 'irreversible' as const } : r)),
492
670
  };
493
671
 
494
- log(`triage selected ${selectedSet.size} requests out of ${candidates.length} candidates`);
672
+ log(
673
+ `triage selected ${selectedSet.size} requests out of ${candidates.length} relevance candidates (${irreversibleSet.size} irreversible requests and ${irreversibleEventSet.size} irreversible outbound WebSocket events across ${safetyBatches.length} bounded safety batch(es))`,
674
+ );
495
675
 
496
676
  setSpanAttributes(span, {
497
677
  'imprint.requests_compacted': metadata.length,
498
678
  'imprint.requests_selected': selectedSet.size,
499
- 'imprint.triage.payload_chars': triagePayloadChars,
500
- 'imprint.triage.duration_ms': result.durationMs,
501
- 'imprint.triage.input_tokens': result.inputTokens,
502
- 'imprint.triage.output_tokens': result.outputTokens,
679
+ 'imprint.triage.payload_chars':
680
+ JSON.stringify(relevancePayload).length + safetyPayloadChars,
681
+ 'imprint.requests_irreversible': irreversibleSet.size,
682
+ 'imprint.events_irreversible': irreversibleEventSet.size,
683
+ 'imprint.triage.duration_ms': durationMs,
684
+ 'imprint.triage.input_tokens': inputTokens,
685
+ 'imprint.triage.output_tokens': outputTokens,
503
686
  });
504
687
 
505
688
  return {
506
689
  session: triaged,
507
690
  selectedSeqs: [...selectedSet],
691
+ replaySafeSeqs,
692
+ irreversibleSeqs: [...irreversibleSet],
693
+ coveredOutboundEventSeqs,
694
+ irreversibleEventSeqs: [...irreversibleEventSet],
508
695
  consideredCount: candidates.length,
509
- inputTokens: result.inputTokens,
510
- outputTokens: result.outputTokens,
511
- durationMs: result.durationMs,
696
+ inputTokens,
697
+ outputTokens,
698
+ durationMs,
512
699
  };
513
700
  },
514
701
  );
@@ -525,6 +712,28 @@ export function buildTriageEventContexts(session: Session): TriageEventContext[]
525
712
  }));
526
713
  }
527
714
 
715
+ export function chunkTriageItems<T>(items: T[], maxChars: number): T[][] {
716
+ const batches: T[][] = [];
717
+ let current: T[] = [];
718
+ let currentChars = 2;
719
+ for (const item of items) {
720
+ const itemChars = JSON.stringify(item).length + 1;
721
+ if (current.length > 0 && currentChars + itemChars > maxChars) {
722
+ batches.push(current);
723
+ current = [];
724
+ currentChars = 2;
725
+ }
726
+ current.push(item);
727
+ currentChars += itemChars;
728
+ }
729
+ if (current.length > 0 || batches.length === 0) batches.push(current);
730
+ return batches;
731
+ }
732
+
733
+ function sumOptionalTokens(left: number | null, right: number | null): number | null {
734
+ return left === null && right === null ? null : (left ?? 0) + (right ?? 0);
735
+ }
736
+
528
737
  export function selectTriageCandidateRequests(
529
738
  session: Session,
530
739
  preserveSeqs: Iterable<number> = [],
@@ -537,6 +746,29 @@ export function selectTriageCandidateRequests(
537
746
  });
538
747
  }
539
748
 
749
+ function compactedRequestSeqs(
750
+ request: Pick<TriageRequestContext, 'seq' | 'repeatedSeqs'>,
751
+ ): number[] {
752
+ return [...new Set([request.seq, ...(request.repeatedSeqs ?? [])])];
753
+ }
754
+
755
+ /** Expand a classification on any representative/member of a compacted row to
756
+ * every original request represented by that row. Effect decisions must apply
757
+ * uniformly because the LLM saw only one compacted request description. */
758
+ export function expandCompactedTriageSeqs(
759
+ seqs: Iterable<number>,
760
+ compactedRequests: Pick<TriageRequestContext, 'seq' | 'repeatedSeqs'>[],
761
+ ): number[] {
762
+ const requested = new Set(seqs);
763
+ const expanded = new Set(requested);
764
+ for (const request of compactedRequests) {
765
+ const group = compactedRequestSeqs(request);
766
+ if (!group.some((seq) => requested.has(seq))) continue;
767
+ for (const seq of group) expanded.add(seq);
768
+ }
769
+ return [...expanded].sort((a, b) => a - b);
770
+ }
771
+
540
772
  export function rescueActionAlignedRepeatedSeqs(
541
773
  session: Session,
542
774
  selectedSeqs: Iterable<number>,
@@ -609,6 +841,7 @@ function triageRequestGroupKey(request: TriageRequestContext): unknown[] {
609
841
  request.resourceType,
610
842
  request.status,
611
843
  request.mimeType,
844
+ request.urlDigest,
612
845
  request.bodyDigest,
613
846
  ];
614
847
  }
@@ -619,9 +852,12 @@ function truncateHeaders(headers: Record<string, string>): string {
619
852
  return `${serialized.slice(0, HEADER_TRUNCATE_LIMIT)}…`;
620
853
  }
621
854
 
622
- export function triageBodySnippet(body: string | undefined): string | undefined {
855
+ export function triageBodySnippet(
856
+ body: string | undefined,
857
+ maxChars = TRIAGE_BODY_LIMIT,
858
+ ): string | undefined {
623
859
  if (body === undefined) return undefined;
624
- if (isLikelyText(body)) return truncate(body, TRIAGE_BODY_LIMIT);
860
+ if (isLikelyText(body)) return truncate(body, maxChars);
625
861
  return `[non-text request body omitted; original length ${body.length}]`;
626
862
  }
627
863
 
@@ -752,17 +988,10 @@ async function compilePlaybookImpl(opts: CompileOptions): Promise<CompilePlayboo
752
988
  durationMs: 0,
753
989
  };
754
990
  if (opts.preTriagedSession && !opts.noShrink) {
755
- // Shared triage path: merge pre-computed seqs with candidate-specific preserveSeqs
756
- const preserveSeqs = new Set([
757
- ...(opts.candidate?.requestSeqs ?? []),
758
- ...(opts.candidate?.dependencySeqs ?? []),
759
- ...(opts.sharedContext?.loginRequestSeqs ?? []),
760
- ]);
761
- const finalSeqs = new Set([...opts.preTriagedSession.selectedSeqs, ...preserveSeqs]);
762
- session = {
763
- ...session,
764
- requests: session.requests.filter((r) => finalSeqs.has(r.seq)),
765
- };
991
+ session = applySharedTriageSelection(session, opts.preTriagedSession, {
992
+ candidate: opts.candidate,
993
+ sharedContext: opts.sharedContext,
994
+ });
766
995
  log('using shared triage result (skipping per-tool triage LLM call)');
767
996
  triageTokens = {
768
997
  input: opts.preTriagedSession.inputTokens,
@@ -0,0 +1,9 @@
1
+ import type { Workflow } from './types.ts';
2
+
3
+ export function isIrreversibleRequest(request: { effect?: string }): boolean {
4
+ return request.effect === 'irreversible';
5
+ }
6
+
7
+ export function workflowHasIrreversibleEffect(workflow: Workflow): boolean {
8
+ return workflow.requests.some(isIrreversibleRequest);
9
+ }