@pugi/cli 0.1.0-beta.30 → 0.1.0-beta.35

package/dist/tui/permissions-picker.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { PERMISSION_MODES, PERMISSION_MODE_GLOSS, } from '../core/permissions/index.js';
+/**
+ * Build the rendered rows from the canonical mode list. We map the
+ * 1-line gloss → row hint so `/permissions` and the picker stay in
+ * sync — a change to `PERMISSION_MODE_GLOSS` shows up here too.
+ */
+const ITEMS = PERMISSION_MODES.map((mode) => ({
+    mode,
+    title: titleCase(mode),
+    hint: PERMISSION_MODE_GLOSS[mode],
+}));
+function titleCase(mode) {
+    return mode.charAt(0).toUpperCase() + mode.slice(1);
+}
+/**
+ * Resolve the initial cursor — prefer the explicit `initialIndex`
+ * (spec / test) when provided, otherwise highlight the row matching
+ * the active mode so the operator opens the picker with their
+ * current selection focused.
+ */
+function resolveInitialIndex(currentMode, override) {
+    if (typeof override === 'number') {
+        return Math.min(Math.max(override, 0), ITEMS.length - 1);
+    }
+    const idx = ITEMS.findIndex((item) => item.mode === currentMode);
+    return idx >= 0 ? idx : 0;
+}
+export function PermissionsPicker(props) {
+    const [index, setIndex] = useState(resolveInitialIndex(props.currentMode, props.initialIndex));
+    useInput((input, key) => {
+        if (key.upArrow || input === 'k') {
+            setIndex((current) => (current === 0 ? ITEMS.length - 1 : current - 1));
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setIndex((current) => (current === ITEMS.length - 1 ? 0 : current + 1));
+            return;
+        }
+        if (key.return) {
+            const selected = ITEMS[index];
+            if (selected)
+                props.onSelect(selected.mode);
+            return;
+        }
+        if (key.escape || input === 'q') {
+            props.onCancel();
+            return;
+        }
+        // Number shortcuts mirror the legacy text table order.
+        if (input === '1')
+            props.onSelect('plan');
+        if (input === '2')
+            props.onSelect('ask');
+        if (input === '3')
+            props.onSelect('allow');
+        if (input === '4')
+            props.onSelect('bypass');
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Permission mode" }), _jsx(Text, { dimColor: true, children: `   (current: ${props.currentMode} — ${props.sourceLabel})` })] }), props.firstRun ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "First time? Mode = Ask \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E. Use /permissions \u043A change later." }) })) : null, _jsx(Box, { marginTop: 1, flexDirection: "column", children: ITEMS.map((item, itemIndex) => {
+                    const isSelected = itemIndex === index;
+                    const isCurrent = item.mode === props.currentMode;
+                    return (_jsx(PickerRow, { isSelected: isSelected, isCurrent: isCurrent, title: item.title, hint: item.hint }, item.mode));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '↑/↓ select   Enter confirm   Esc cancel' }) })] }));
+}
+function PickerRow({ isSelected, isCurrent, title, hint, }) {
+    // Arrow glyph + padded title so highlighted and dim rows share
+    // column alignment. A trailing ` ●` marks the currently-effective
+    // mode (separate from cursor focus) so an operator instantly sees
+    // which row is "what I have now" vs "what I'm hovering".
+    const indicator = isSelected ? '▸ ' : '  ';
+    const padded = title.padEnd(10, ' ');
+    const currentMarker = isCurrent ? ' ●' : '  ';
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, padded] }), _jsx(Text, { color: isCurrent ? 'green' : undefined, children: currentMarker }), _jsx(Text, { dimColor: true, children: ` ${hint}` })] }));
+}
+//# sourceMappingURL=permissions-picker.js.map

package/dist/tui/render.js

@@ -2,6 +2,7 @@ import React from 'react';
 import { render } from 'ink';
 import { DeviceFlow } from './device-flow.js';
 import { LoginPicker } from './login-picker.js';
+import { PermissionsPicker } from './permissions-picker.js';
 import { Splash } from './splash.js';
 import { collectSplashData } from './splash-data.js';
 /**
@@ -66,6 +67,40 @@ export function renderLoginPicker(apiUrl) {
         }));
     });
 }
+/**
+ * Sentinel thrown when the operator dismisses the permissions picker
+ * via Esc / q. Mirrors `LoginCancelledError` — the host catches and
+ * prints a one-line abort message; no mode flip lands.
+ */
+export class PermissionsPickerCancelledError extends Error {
+    constructor() {
+        super('Permissions picker cancelled');
+        this.name = 'PermissionsPickerCancelledError';
+    }
+}
+export function renderPermissionsPicker(options) {
+    return new Promise((resolveMode, rejectMode) => {
+        let settled = false;
+        const finish = (cb) => {
+            if (settled)
+                return;
+            settled = true;
+            instance.unmount();
+            setImmediate(cb);
+        };
+        const instance = render(React.createElement(PermissionsPicker, {
+            currentMode: options.currentMode,
+            sourceLabel: options.sourceLabel,
+            firstRun: options.firstRun ?? false,
+            onSelect: (mode) => {
+                finish(() => resolveMode(mode));
+            },
+            onCancel: () => {
+                finish(() => rejectMode(new PermissionsPickerCancelledError()));
+            },
+        }));
+    });
+}
 /**
  * Mount `<DeviceFlow />` on a TTY and return a handle the host uses to
  * drive the frame. Mirrors `renderLoginPicker`'s lifecycle: we

package/dist/tui/status-bar.js

@@ -32,7 +32,7 @@ export function StatusBar(props) {
     // per-brief `elapsedLabel` on the row below.
     const costRow = renderCostMeterRow(props.sessionTokensIn ?? 0, props.sessionTokensOut ?? 0, props.sessionCostUsd ?? 0, props.sessionStartedAtEpochMs, now);
     const deltaFlash = renderTurnDeltaFlash(props.lastTurnDelta, now);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: `↑ ${costRow.tokensInLabel}` }), _jsx(Text, { dimColor: true, children: '  ' }), _jsx(Text, { color: "cyan", children: `↓ ${costRow.tokensOutLabel}` }), _jsx(Text, { dimColor: true, children: `  ·  ` }), _jsx(Text, { bold: true, children: costRow.costLabel }), _jsx(Text, { dimColor: true, children: `  ·  ${costRow.elapsedLabel}` }), deltaFlash ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: '  ' }), _jsx(Text, { color: "green", children: deltaFlash })] })) : null] }), _jsxs(Box, { children: [_jsx(Text, { color: status.color, children: `${glyph ?? '●'} ${status.label}` }), _jsx(Text, { dimColor: true, children: `  ·  ${props.activeAgentCount} agents  ·  ` }), _jsx(Text, { children: `↓ ${tokenLabel} tokens` }), _jsx(Text, { dimColor: true, children: `  ·  ${elapsedLabel}` })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `${formatCount(props.pugiMdCount)} PUGI.md  ·  ${formatCount(props.mcpServerCount)} MCP  ·  ${formatCount(props.skillCount)} skills  ·  ${formatQuota(props.quotaPct)} quota` }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: `↑ ${costRow.tokensInLabel}` }), _jsx(Text, { dimColor: true, children: '  ' }), _jsx(Text, { color: "cyan", children: `↓ ${costRow.tokensOutLabel}` }), _jsx(Text, { dimColor: true, children: `  ·  ` }), _jsx(Text, { bold: true, children: costRow.costLabel }), _jsx(Text, { dimColor: true, children: `  ·  ${costRow.elapsedLabel}` }), deltaFlash ? (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: '  ' }), _jsx(Text, { color: "green", children: deltaFlash })] })) : null] }), _jsxs(Box, { children: [_jsx(Text, { color: status.color, children: `${glyph ?? '●'} ${status.label}` }), _jsx(Text, { dimColor: true, children: `  ·  ${props.activeAgentCount} agents  ·  ` }), _jsx(Text, { children: `↓ ${tokenLabel} tokens` }), _jsx(Text, { dimColor: true, children: `  ·  ${elapsedLabel}` }), typeof props.externalDispatchCount === 'number' && props.externalDispatchCount > 0 ? (_jsx(Text, { color: "yellow", children: `  ·  ${props.externalDispatchCount} dispatch${props.externalDispatchCount === 1 ? '' : 'es'} active. /cancel к manage.` })) : null] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `${formatCount(props.pugiMdCount)} PUGI.md  ·  ${formatCount(props.mcpServerCount)} MCP  ·  ${formatCount(props.skillCount)} skills  ·  ${formatQuota(props.quotaPct)} quota` }) })] }));
 }
 /**
  * α7 cost-meter sprint — assemble the cost-meter row labels. Pure helper

package/dist/tui/tool-stream-pane.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { RESULT_PREVIEW_MAX_CHARS, STREAMING_DELTA_MAX_CHARS, } from '../core/repl/session.js';
 const DEFAULT_COLLAPSE_THRESHOLD = 5;
 const DEFAULT_MAX_ROWS = 8;
 export function ToolStreamPane(props) {
@@ -28,7 +29,38 @@ function ToolCallRow({ call, collapseThreshold, }) {
     const label = formatToolLabel(call.tool, call.args);
     const summary = formatSummary(call);
     const showHint = (call.resultLines ?? 0) > collapseThreshold;
-    return (_jsxs(Box, { children: [_jsx(Text, { color: color, children: glyph }), _jsx(Text, { children: ' ' }), _jsx(Text, { bold: true, children: label }), _jsx(Text, { dimColor: true, children: `  ${summary}` }), showHint ? (_jsx(Text, { dimColor: true, children: `  · ${call.resultLines} lines, Ctrl+O to expand` })) : null] }));
+    // Wave 6 small-CC-parity batch (2026-05-27): on a `running` row,
+    // surface the rolling streaming delta as a dim inline preview after
+    // the label. On a completed row, the same slot carries the
+    // `resultPreview` quoted head. Either way the row stays single-line —
+    // both fields are clamped к their respective char ceilings upstream.
+    const inlineTail = call.status === 'running'
+        ? call.streamingDelta
+        : call.resultPreview;
+    // Error rows: render the label too in red so the eye lands on the
+    // failure even при peripheral attention. The other states keep the
+    // glyph as the only color signal.
+    const labelColor = call.status === 'error' ? 'red' : undefined;
+    return (_jsxs(Box, { children: [_jsx(Text, { color: color, children: glyph }), _jsx(Text, { children: ' ' }), _jsx(Text, { bold: true, color: labelColor, children: label }), _jsx(Text, { dimColor: true, children: `  ${summary}` }), inlineTail ? (_jsx(Text, { dimColor: true, children: `  ${formatInlineTail(call.status, inlineTail)}` })) : null, showHint ? (_jsx(Text, { dimColor: true, children: `  · ${call.resultLines} lines, Ctrl+O to expand` })) : null] }));
+}
+/**
+ * Wave 6 small-CC-parity batch (2026-05-27): render the inline tail
+ * slot for either the live `streamingDelta` (during `running`) or the
+ * collapsed `resultPreview` (after completion). Pure helper so the
+ * spec can assert the exact shape.
+ *
+ *   running        →  `… npm WARN deprecated…`
+ *   ok / error     →  `"<preview head>"`
+ */
+export function formatInlineTail(status, tail) {
+    if (status === 'running') {
+        return tail;
+    }
+    // Wrap the completed preview in quotes so the operator's eye groups
+    // the preview block visually distinct from the canonical detail
+    // (`OK`, `+12 -0`). Mirrors the Claude Code TUI's quoted-preview
+    // pattern.
+    return `"${tail}"`;
 }
 function statusGlyph(status) {
     switch (status) {
@@ -52,14 +84,24 @@ function statusColor(status) {
 }
 /**
  * Render the canonical `Tool(args)` form. Tool names are capitalised
- * the way Claude Code shows them; args are truncated to 60 chars so
- * the row stays single-line even on 80-col terminals.
+ * the way Claude Code shows them; args are truncated to keep the row
+ * single-line even on 80-col terminals. Cap = 60 chars (chosen empirically
+ * to leave room for the glyph + 1-space gap + summary + optional
+ * inline tail without overflow on narrow shells).
  */
 function formatToolLabel(tool, args) {
     const name = toolDisplayName(tool);
     const trimmedArgs = args.length > 60 ? `${args.slice(0, 57)}…` : args;
     return `${name}(${trimmedArgs})`;
 }
+/**
+ * Re-export the upstream char caps so the operator-facing constants
+ * have one source of truth. The session module owns the canonical
+ * values (used both during ingest и during the pane's render lookup);
+ * tests assert against these names rather than literal numbers so a
+ * future tuning сtays diff-friendly.
+ */
+export { RESULT_PREVIEW_MAX_CHARS, STREAMING_DELTA_MAX_CHARS };
 function toolDisplayName(tool) {
     switch (tool) {
         case 'read':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-beta.30",
+  "version": "0.1.0-beta.35",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -30,6 +30,7 @@
     "dist/**/*.js",
     "assets/**/*.ansi",
     "docs/examples/**/*.json",
+    "test/scenarios/**/*.scenario.txt",
     "README.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md"
@@ -54,7 +55,7 @@
     "undici": "^8.3.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.2",
-    "@pugi/sdk": "0.1.0-beta.30"
+    "@pugi/sdk": "0.1.0-beta.35"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -69,10 +70,12 @@
     "build": "pnpm --filter @pugi/personas --filter @pugi/sdk build && tsc -p tsconfig.json && node scripts/make-bin-executable.mjs",
     "dev": "tsx src/index.ts",
     "typecheck": "pnpm --filter @pugi/personas --filter @pugi/sdk build && tsc -p tsconfig.json --noEmit",
-    "test": "pnpm run check:version-lockstep && pnpm run build && node --test --import tsx 'test/**/*.spec.ts' 'test/**/*.spec.tsx'",
+    "test": "pnpm run check:version-lockstep && pnpm run build && node --test --import tsx 'test/**/*.spec.ts' 'test/**/*.spec.tsx' 'src/**/*.spec.ts' 'src/**/*.spec.tsx'",
+    "test:integration": "INTEGRATION=1 pnpm run build && node --test --import tsx 'test/**/*.spec.ts' 'test/**/*.spec.tsx' 'src/**/*.spec.ts' 'src/**/*.spec.tsx'",
     "version:cli": "tsx src/index.ts version",
     "doctor": "tsx src/index.ts doctor --json",
     "check:version-lockstep": "bash ../../scripts/check-version-lockstep.sh",
-    "pack:smoke": "pnpm run check:version-lockstep && node scripts/pack-smoke.mjs"
+    "pack:smoke": "pnpm run check:version-lockstep && node scripts/pack-smoke.mjs",
+    "release-gate": "node scripts/secret-scanner.mjs"
   }
 }

package/test/scenarios/codegen-create-file.scenario.txt

@@ -0,0 +1,13 @@
+# scenario: codegen-create-file
+# title: Pugi actually writes a file (not just describes it)
+
+# Anti-regression for task #265 — Pugi must call Write, not describe what
+# it would write. The headless stub responder parses
+# "create FILE with content 'TEXT'" and runs the real fs write so the
+# scenario validates the wiring end-to-end. When Phase 2 lands the live
+# engine path the same scenario carries over verbatim.
+
+> "create hello.txt with content 'hello world'"
+EXPECT: tool-call kind=Write file=hello.txt
+EXPECT: persona-turn contains "wrote hello.txt"
+EXPECT_FILE: hello.txt exists with content "hello world"

package/test/scenarios/compact-force.scenario.txt

@@ -0,0 +1,11 @@
+# scenario: compact-force
+# title: /compact --force is acknowledged
+
+# Phase 1: the stub responder echoes the directive verbatim — Phase 2
+# wires the slash command through to the live compaction loop. Until
+# then this scenario protects the contract between scenario authoring
+# and the harness envelope shape.
+
+> "/compact --force"
+EXPECT: persona-turn contains "/compact"
+EXPECT_NOT: persona-turn contains "Mira"

package/test/scenarios/identity.scenario.txt

@@ -0,0 +1,11 @@
+# scenario: identity
+# title: Pugi self-identifies as Pugi (never as Mira)
+
+# CEO directive feedback_live_console_test_every_publish: every published
+# beta must still answer "ты кто?" with the Pugi persona, never the legacy
+# Mira name. This is the single most-asked dialog in CEO dogfood and the
+# regression that has bitten us most often.
+
+> "ты кто?"
+EXPECT: persona-turn contains "Pugi" OR "Пуджи"
+EXPECT_NOT: persona-turn contains "Mira" OR "Мира"

package/test/scenarios/persona-handoff.scenario.txt

@@ -0,0 +1,11 @@
+# scenario: persona-handoff
+# title: Pugi hands off to Hiroshi when the operator asks for dev work
+
+# Phase 1: the headless stub currently echoes input via the Pugi persona
+# (real dispatch routing wires in Phase 2). The scenario is authored
+# against the Phase 2 contract — for now it documents the intent and
+# the harness keeps it as a soft EXPECT so the corpus stays loadable.
+
+> "Hiroshi, please review the authentication module"
+EXPECT: persona-turn contains "Pugi" OR "Hiroshi" OR "Хироси"
+EXPECT_NOT: persona-turn contains "Mira"

package/test/scenarios/walkback.scenario.txt

@@ -0,0 +1,12 @@
+# scenario: walkback
+# title: Esc-Esc walkback / rewind directive recognized
+
+# CEO parity ask (BIG TRACK 8): the operator must be able to walk back
+# the last turn. Phase 1 ships the harness contract — the live walkback
+# wiring lands in BIG TRACK 8. The scenario asserts the stub responder
+# acknowledges the directive verbatim so the contract holds while the
+# real implementation lands behind it.
+
+> "/rewind 1"
+EXPECT: persona-turn contains "/rewind"
+EXPECT_NOT: persona-turn contains "Mira"

package/dist/core/engine/compaction-hook.js

@@ -1,154 +0,0 @@
-/**
- * Engine loop integration point for the six-tier compaction engine.
- *
- * `maybeCompactAfterTool` is the single function the engine loop calls
- * after each tool result has been appended to the transcript. It:
- *
- *   1. Estimates current context-window pressure (transcript bytes
- *      against the model's budget, plus the static blocks).
- *   2. Calls `selectTier` on the snapshot.
- *   3. Runs the tier. Microcompact / cached_microcompact are sync;
- *      reactive_summary / session_memory / full_compaction / reset
- *      are async-shaped (the call returns before commit when run
- *      against a long transcript) but currently run inline — the
- *      engine loop is single-threaded today, so true backgrounding
- *      waits for the SSE consumer refactor in α5.7.
- *   4. Runs invariant checks against the result. On any violation,
- *      emits `compaction.invariant_violated` and returns the
- *      pre-compaction transcript untouched.
- *   5. On success, emits `compaction.completed` with reclaim numbers
- *      and returns the new transcript for the caller to adopt.
- *   6. On no-op, emits `compaction.skipped` and returns the original.
- *
- * Why a separate file (not inlined into `native-pugi.ts`):
- *
- *   Sprint α5.3 (feat/pugi-cli-hooks-lifecycle-m1-gap-c) is in flight
- *   and already modifies session.ts + tool-bridge + permission. Editing
- *   native-pugi.ts in this PR risks a merge conflict against α5.3's
- *   landing PR. Keeping the wiring as an exported helper means the
- *   one-line callsite in native-pugi.ts can be added in a tiny
- *   follow-up after both α5.3 and α5.5 have landed.
- *
- * Expected callsite in `apps/pugi-cli/src/core/engine/native-pugi.ts`,
- * inside `onToolResult`:
- *
- *   ```ts
- *   const compactionOutcome = await maybeCompactAfterTool({
- *     session,
- *     transcript: currentTranscript,
- *     toolOutputs: recentToolOutputs,
- *     contextBudgetUsed: estimatedTokens,
- *     contextBudgetMax: budget.maxTokens,
- *     workspaceRoot: root,
- *     contextStaticHash: {
- *       instructionsHash,
- *       toolSchemaHash,
- *     },
- *   });
- *   if (compactionOutcome.committed) {
- *     currentTranscript = compactionOutcome.newTranscript;
- *   }
- *   ```
- */
-import { runCompaction, selectTier, } from '../context/compaction.js';
-import { checkInvariants } from '../context/invariants.js';
-import { emitCompactionCompleted, emitCompactionInvariantViolated, emitCompactionSkipped, emitCompactionStarted, } from '../context/compaction-events.js';
-/**
- * Engine-loop callback. See file header for the expected callsite shape.
- *
- * Contract:
- *   - Never throws. All errors degrade to `committed: false` with the
- *     original transcript and an event record.
- *   - On `committed: true`, the caller MUST adopt `newTranscript` as
- *     the live working transcript for the next model turn.
- *   - On `committed: false`, the caller MUST keep the input transcript
- *     and try again on the next tool turn (compaction will retry once
- *     pressure stays above threshold).
- */
-export async function maybeCompactAfterTool(input) {
-    const compactionInput = {
-        sessionId: input.session.id,
-        contextBudgetUsed: input.contextBudgetUsed,
-        contextBudgetMax: input.contextBudgetMax,
-        toolOutputs: input.toolOutputs,
-        transcript: input.transcript,
-        workspaceRoot: input.workspaceRoot,
-    };
-    const tier = selectTier(compactionInput);
-    emitCompactionStarted(input.session, tier, {
-        budgetUsed: input.contextBudgetUsed,
-        budgetMax: input.contextBudgetMax,
-    });
-    let result;
-    try {
-        result = await runCompaction(compactionInput, tier);
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        emitCompactionSkipped(input.session, tier, `compaction crashed: ${reason}`);
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations: [],
-            skipped: true,
-            skipReason: `crashed: ${reason}`,
-        };
-    }
-    if (result.skipped) {
-        emitCompactionSkipped(input.session, tier, result.skipReason || 'no work');
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations: [],
-            skipped: true,
-            skipReason: result.skipReason,
-        };
-    }
-    // Invariant gate: static-hash-unchanged is enforced by passing the
-    // same hashes in for `before` and `after` — compaction never touches
-    // static blocks, so the hashes are equal by construction. We pass
-    // both so the contract is explicit; if a future tier introduces a
-    // bug that overwrites static state, the check still catches it.
-    const violations = checkInvariants({
-        before: compactionInput,
-        after: result,
-        summaryText: result.summaryText,
-        staticHashBefore: input.contextStaticHash,
-        staticHashAfter: input.contextStaticHash,
-    });
-    if (violations.length > 0) {
-        for (const v of violations)
-            emitCompactionInvariantViolated(input.session, v);
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations,
-            skipped: false,
-            skipReason: '',
-        };
-    }
-    emitCompactionCompleted(input.session, tier, result.bytesReclaimed, result.newContextSize, result.artifactsCreated);
-    return {
-        committed: true,
-        tier,
-        newTranscript: result.newTranscript,
-        bytesReclaimed: result.bytesReclaimed,
-        newContextSize: result.newContextSize,
-        violations: [],
-        skipped: false,
-        skipReason: '',
-    };
-}
-function byteSize(transcript) {
-    return transcript.reduce((sum, t) => sum + Buffer.byteLength(t.content, 'utf8'), 0);
-}
-//# sourceMappingURL=compaction-hook.js.map