@giovannijecha/jecode 0.8.6 → 0.8.7

package/dist/providers/input-measurement.js

@@ -0,0 +1,85 @@
+// Measure the content each adapter actually sends, without exposing wire
+// formats to context policy or counting the normalized and raw copies twice.
+import { estimateSerializedTokensResponsive } from "../context/estimate.js";
+import { toWireItems, toWireTool as responsesTool } from "./openai-wire.js";
+import { toWireMessage, toWireTool as anthropicTool } from "./anthropic-wire.js";
+import { toWireMessages, toWireTool as ollamaTool } from "./ollama-wire.js";
+import { countO200k } from "../context/tokenizer/o200k.js";
+export function measureResponsesInput(request, providerId, signal) {
+    return measure({ instructions: request.system, tools: request.tools.map(responsesTool) }, request.messages.map((message) => {
+        const items = toWireItems(message, providerId);
+        const outputTokens = opaqueReserve(message, providerId);
+        if (outputTokens === undefined)
+            return { items,
+                unmeasuredOpaque: items.some((item) => hasOpaqueField(item, "reasoning", "encrypted_content")) };
+        return {
+            items: items.map((item) => withoutOpaqueField(item, "reasoning", "encrypted_content")),
+            outputTokens,
+        };
+    }), request.tools.length, signal, responsesTokenCounter(request.model, providerId));
+}
+export function measureAnthropicInput(request, signal) {
+    return measure({ system: request.system, tools: request.tools.map(anthropicTool) }, request.messages.map((message) => {
+        const wire = toWireMessage(message);
+        const outputTokens = opaqueReserve(message, "anthropic");
+        if (outputTokens === undefined || !Array.isArray(wire.content))
+            return { items: [wire] };
+        return {
+            items: [{
+                    ...wire,
+                    content: wire.content.map((item) => withoutOpaqueField(withoutOpaqueField(item, "thinking", "signature"), "redacted_thinking", "data")),
+                }],
+            outputTokens,
+        };
+    }), request.tools.length, signal);
+}
+export function measureOllamaInput(request, signal) {
+    return measure({ messages: toWireMessages(request.system, []), tools: request.tools.map(ollamaTool) }, request.messages.map((message) => ({ items: toWireMessages("", [message]) })), request.tools.length, signal);
+}
+async function measure(envelope, messages, toolCount, signal, count = estimateSerializedTokensResponsive) {
+    let tokens = 64 + toolCount * 16 + await count(envelope, signal);
+    for (const message of messages) {
+        if (message.items.length === 0)
+            continue;
+        const visible = await (message.unmeasuredOpaque ? estimateSerializedTokensResponsive : count)(message.items, signal);
+        // Reported output already includes hidden reasoning. Reserve it once for
+        // this assistant message, never once per opaque item or in addition to it.
+        tokens += Math.max(visible, message.outputTokens ?? 0) + message.items.length * 8;
+    }
+    return tokens;
+}
+/** Account aliases may precede tiktoken's model map: use a reference encoding,
+ * never label this a provider-exact count. Legacy/unknown API routes stay conservative. */
+function responsesTokenCounter(model, providerId) {
+    if (responsesTokenization(model, providerId) === "heuristic")
+        return estimateSerializedTokensResponsive;
+    return async (value, signal) => Math.max(1, Math.ceil(await countO200k(JSON.stringify(value), signal) * 1.1));
+}
+export function responsesTokenization(model, providerId) {
+    const modern = /^(?:gpt-5|gpt-4\.[15](?:-|$)|gpt-4o(?:-|$)|chatgpt-4o-|o[13](?:-|$)|o4-mini(?:-|$)|ft:gpt-4o)/u.test(model);
+    return providerId === "openai-codex" || modern ? "o200k-reference" : "heuristic";
+}
+function opaqueReserve(message, providerId) {
+    const tokens = message.usage?.outputTokens;
+    return message.role === "assistant" && message.rawFrom === providerId &&
+        Array.isArray(message.raw) && typeof tokens === "number" &&
+        Number.isSafeInteger(tokens) && tokens > 0 && message.raw.some((item) => (providerId === "anthropic"
+        ? hasOpaqueField(item, "thinking", "signature") ||
+            hasOpaqueField(item, "redacted_thinking", "data")
+        : hasOpaqueField(item, "reasoning", "encrypted_content")))
+        ? tokens
+        : undefined;
+}
+function withoutOpaqueField(value, type, field) {
+    if (!hasOpaqueField(value, type, field))
+        return value;
+    const visible = { ...value };
+    delete visible[field];
+    return visible;
+}
+function hasOpaqueField(value, type, field) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const item = value;
+    return item["type"] === type && typeof item[field] === "string";
+}

package/dist/providers/ollama-wire.js

@@ -107,6 +107,6 @@ function normalizeUsage(reply) {
 }
 export function stopNotice(reply) {
     return reply.finishReason === "length"
-        ? "[truncated: hit the output limit — raise --max-tokens]"
+        ? "[truncated: hit the output limit — raise max output tokens in /settings]"
         : undefined;
 }

package/dist/providers/ollama.js

@@ -8,6 +8,7 @@ import { ollamaContextWindow } from "./ollama-context.js";
 import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
 import { OLLAMA_CLOUD_HOST } from "./ollama-endpoint.js";
 import { fromWireReply, stopNotice, toWireMessages, toWireTool } from "./ollama-wire.js";
+import { measureOllamaInput } from "./input-measurement.js";
 const KEY = "OLLAMA_API_KEY";
 const ID = "ollama";
 // Ollama also accepts `none`; Jecode's product-wide reasoning floor is `low`.
@@ -33,6 +34,7 @@ export const ollama = {
     async contextWindow(model, signal, onStatus) {
         return ollamaContextWindow(model, headers(), signal, onStatus);
     },
+    measureInput: measureOllamaInput,
     async send(req) {
         const effort = requireSupportedEffort(req.model, req.effort, OLLAMA_EFFORTS);
         try {

package/dist/providers/openai-codex.js

@@ -9,6 +9,7 @@ import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderErro
 import { getJson, postSse } from "./http.js";
 import { assembleOpenAI, openAIStreamProgress } from "./openai-stream.js";
 import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+import { measureResponsesInput, responsesTokenization } from "./input-measurement.js";
 const ID = "openai-codex";
 const BASE = "https://chatgpt.com/backend-api/codex";
 // Jecode's product version is unrelated to the Codex protocol gate. OpenAI's
@@ -66,6 +67,8 @@ export const openaiCodex = {
             throwProviderError(ID, signal, error);
         }
     },
+    measureInput: (request, signal) => measureResponsesInput(request, ID, signal),
+    inputTokenization: (model) => responsesTokenization(model, ID),
     async send(req) {
         const efforts = effortByModel.get(req.model) ?? fallbackEfforts(req.model);
         const effort = requireSupportedEffort(req.model, req.effort, efforts);

package/dist/providers/openai-stream.js

@@ -5,9 +5,16 @@
 // an empty final `output` after complete `response.output_item.done` events, so
 // those streamed items remain the fallback when the final envelope is empty.
 import { providerWireError } from "./failure.js";
+import { OpenAISummary } from "./openai-summary.js";
 export async function assembleOpenAI(events, onStream, onStatus) {
     const items = [];
     const announcedTools = { identities: new Set(), anonymous: false };
+    const summary = new OpenAISummary();
+    const display = (event) => {
+        if (event.kind !== "thinking")
+            summary.reset();
+        onStream?.(event);
+    };
     let refusal = false;
     let activity;
     const status = (next) => {
@@ -27,32 +34,36 @@ export async function assembleOpenAI(events, onStream, onStatus) {
             case "response.output_text.delta":
                 if (typeof event.delta === "string") {
                     status("Responding");
-                    onStream?.({ kind: "text", text: event.delta });
+                    display({ kind: "text", text: event.delta });
                 }
                 break;
             case "response.refusal.delta":
                 if (typeof event.delta === "string") {
                     status("Responding");
-                    onStream?.({ kind: "text", text: `${refusal ? "" : "[refused] "}${event.delta}` });
+                    display({ kind: "text", text: `${refusal ? "" : "[refused] "}${event.delta}` });
                     refusal = true;
                 }
                 break;
-            case "response.reasoning_summary_text.delta":
-                if (typeof event.delta === "string") {
+            case "response.reasoning_summary_text.delta": {
+                const text = summary.delta(event);
+                if (text !== undefined) {
                     status("Thinking");
-                    onStream?.({ kind: "thinking", text: event.delta });
+                    display({ kind: "thinking", text });
                 }
                 break;
+            }
             case "response.reasoning_summary_part.added":
+                summary.end();
                 status("Thinking");
                 break;
             case "response.reasoning_summary_text.done":
             case "response.reasoning_summary_part.done":
+                summary.end();
                 status("Working");
                 break;
             case "response.output_item.added":
                 if (isFunctionCall(event.item)) {
-                    announceTool(event, event.item, announcedTools, onStream, status);
+                    announceTool(event, event.item, announcedTools, display, status);
                 }
                 else if (itemType(event.item) === "reasoning") {
                     status("Thinking");
@@ -63,14 +74,15 @@ export async function assembleOpenAI(events, onStream, onStatus) {
                 break;
             case "response.function_call_arguments.delta":
             case "response.function_call_arguments.done":
-                announceTool(event, undefined, announcedTools, onStream, status);
+                announceTool(event, undefined, announcedTools, display, status);
                 break;
             case "response.output_item.done":
                 if (event.item !== undefined) {
                     if (isFunctionCall(event.item)) {
-                        announceTool(event, event.item, announcedTools, onStream, status);
+                        announceTool(event, event.item, announcedTools, display, status);
                     }
                     else if (itemType(event.item) === "reasoning") {
+                        summary.end();
                         status("Working");
                     }
                     items.push(event.item);

package/dist/providers/openai-summary.js

@@ -0,0 +1,37 @@
+// Display boundaries between Responses summary parts; provider replay stays untouched.
+export class OpenAISummary {
+    #part;
+    #ended = false;
+    #tail = "";
+    reset() {
+        this.#part = undefined;
+        this.#ended = false;
+        this.#tail = "";
+    }
+    end() { this.#ended = true; }
+    delta(event) {
+        if (typeof event.delta !== "string" || event.delta === "")
+            return undefined;
+        const part = {
+            item: typeof event.item_id === "string" ? event.item_id : undefined,
+            output: index(event.output_index),
+            summary: index(event.summary_index),
+        };
+        const previous = this.#part;
+        const changed = previous !== undefined && ["item", "output", "summary"].some(key => (part[key] !== undefined && previous[key] !== undefined && part[key] !== previous[key]));
+        // Completion events cover older/idless streams. Identity changes also cover
+        // streams that omit those events. Wait for text so empty parts add no rows.
+        const boundary = previous !== undefined && (this.#ended || changed);
+        const trailing = this.#tail.match(/\n{0,2}$/u)?.[0].length ?? 0;
+        const leading = event.delta.match(/^\n{0,2}/u)?.[0].length ?? 0;
+        const prefix = boundary ? "\n".repeat(Math.max(0, 2 - trailing - leading)) : "";
+        const text = prefix + event.delta;
+        this.#tail = (this.#tail + text).slice(-2);
+        this.#part = part;
+        this.#ended = false;
+        return text;
+    }
+}
+function index(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}

package/dist/providers/openai-wire.js

@@ -45,7 +45,7 @@ export function stopNotice(data) {
         return data.status === "incomplete" ? "[incomplete response]" : undefined;
     }
     return reason === "max_output_tokens"
-        ? "[truncated: hit max_output_tokens — raise --max-tokens]"
+        ? "[truncated: hit max_output_tokens — raise max output tokens in /settings]"
         : `[incomplete: ${reason}]`;
 }
 export function fromWireResponse(data, providerId = "openai") {

package/dist/providers/openai.js

@@ -11,6 +11,7 @@ import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
 import { assembleOpenAI, openAIStreamProgress } from "./openai-stream.js";
 import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+import { measureResponsesInput, responsesTokenization } from "./input-measurement.js";
 const ENDPOINT = "https://api.openai.com/v1/responses";
 const MODELS = "https://api.openai.com/v1/models";
 const KEY = "OPENAI_API_KEY";
@@ -87,6 +88,8 @@ export const openai = {
     async contextWindow(model) {
         return openAIContextWindow(model);
     },
+    measureInput: (request, signal) => measureResponsesInput(request, ID, signal),
+    inputTokenization: (model) => responsesTokenization(model, ID),
     async send(req) {
         const key = requireKey();
         const effort = requireSupportedEffort(req.model, req.effort, openAIEfforts(req.model));

package/dist/settings-command.js

@@ -69,31 +69,26 @@ function settingsItems(values) {
             option: {
                 label: "model",
                 value: `${providerLabel(values.provider)} · ${values.model || "choose a model"}`,
-                description: "Choose the provider and model used for subsequent requests.",
             },
         },
-        { action: "effort", option: { label: "effort", value: values.effort,
-                description: "Set the saved reasoning effort for model requests." } },
+        { action: "effort", option: { label: "effort", value: values.effort } },
         ...(values.maxTokens === undefined
             ? []
             : [{
                     action: "maxTokens",
-                    option: { label: "max output tokens", value: String(values.maxTokens),
-                        description: "Limit the output tokens requested from the model in each response." },
+                    option: { label: "max output tokens", value: String(values.maxTokens) },
                 }]),
         {
             action: "compactionPercent",
-            option: { label: "context compaction", value: `${values.compactionPercent}%`,
-                description: "Compact model context near this share of its usable window. The transcript stays complete." },
+            option: { label: "context compaction", value: `${values.compactionPercent}%` },
         },
         {
             action: "reducedMotion",
-            option: { label: "reduced motion", value: values.reducedMotion ? "on" : "off",
-                description: "Keep decorative movement still while output continues to update." },
+            option: { label: "reduced motion", value: values.reducedMotion ? "on" : "off" },
         },
         {
             action: "providers",
-            option: { label: "providers", hint: "manage connections", description: "Manage API keys and account connections." },
+            option: { label: "providers", hint: "manage connections" },
         },
     ];
 }

package/dist/settings.js

@@ -1,4 +1,4 @@
-// Persistent, non-secret defaults for interactive and batch sessions.
+// Persistent, non-secret defaults for interactive sessions.
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
 import { assertDirectoryAnchor, captureDirectDirectorySync, preparePrivateDirectory, } from "./directory-anchor.js";

package/dist/start.js

@@ -1,6 +1,5 @@
-// Application bootstrap: resolve one session, then choose its terminal surface.
+// Application bootstrap: validate the terminal and resolve one interactive session.
 import * as path from "node:path";
-import { runBatch } from "./batch.js";
 import { showCliInfo } from "./cli-info.js";
 import { loadConfig } from "./config.js";
 import { ConversationTree } from "./conversation.js";
@@ -22,22 +21,17 @@ export async function start(args = process.argv.slice(2), environment = {}) {
     if (await showCliInfo(args, applicationRoot, write))
         return;
     const launch = parseLaunch(args);
-    const config = loadConfig(launch.configArgs);
-    const provider = selectProvider(config.providerId);
     const hasScreen = environment.interactive?.() ?? interactive();
-    if (launch.kind === "resume" && !hasScreen) {
-        throw new Error("resume needs an interactive terminal");
+    if (!hasScreen) {
+        throw new Error("an interactive terminal is required on stdin and stdout; run jecode directly without pipes or redirection");
     }
+    const config = loadConfig(launch.configArgs, environment.readSettings?.());
+    const provider = selectProvider(config.providerId);
     if (launch.kind === "resume" && config.ephemeral) {
         throw new Error("--ephemeral cannot be combined with resume");
     }
-    // A provider whose catalogue is not fixed has no sensible default model.
-    // The TUI can ask; a pipe cannot, so batch mode still requires one up front.
     const model = config.model === "" ? provider.defaultModel : config.model;
-    if (model === "" && !hasScreen) {
-        throw new Error(`${provider.id} has no default model — pass --model <id> (or set JECODE_MODEL)`);
-    }
-    configureColor(hasScreen);
+    configureColor(true);
     const session = {
         config,
         provider,
@@ -48,52 +42,42 @@ export async function start(args = process.argv.slice(2), environment = {}) {
         conversation: ConversationTree.empty(),
         usage: emptyUsage(),
     };
-    if (hasScreen) {
-        if (!config.ephemeral) {
-            const store = await DurableSessionStore.open(config.root, environment.sessionsRoot);
-            if (launch.kind === "resume") {
-                const candidates = await SessionPersistence.candidates(store);
-                if (candidates.length === 0)
-                    throw new Error("no resumable sessions found for this workspace");
-                const open = async (id) => {
-                    const resumed = await SessionPersistence.resume(store, id);
-                    try {
-                        applyResumedSession(session, resumed.conversation, resumed.persistence);
-                    }
-                    catch (error) {
-                        await resumed.persistence.close();
-                        throw error;
-                    }
-                };
-                if (launch.latest)
-                    await open(candidates[0].id);
-                else
-                    session.resume = { candidates, open };
-            }
-            else {
-                session.persistence = SessionPersistence.fresh(store);
-            }
+    if (!config.ephemeral) {
+        const store = await DurableSessionStore.open(config.root, environment.sessionsRoot);
+        if (launch.kind === "resume") {
+            const candidates = await SessionPersistence.candidates(store);
+            if (candidates.length === 0)
+                throw new Error("no resumable sessions found for this workspace");
+            const open = async (id) => {
+                const resumed = await SessionPersistence.resume(store, id);
+                try {
+                    applyResumedSession(session, resumed.conversation, resumed.persistence);
+                }
+                catch (error) {
+                    await resumed.persistence.close();
+                    throw error;
+                }
+            };
+            if (launch.latest)
+                await open(candidates[0].id);
+            else
+                session.resume = { candidates, open };
         }
-        try {
-            if (environment.runInteractive === undefined) {
-                await runApp(session, transcriptRoot, { shutdownSignal: environment.signal });
-            }
-            else {
-                await environment.runInteractive(session, transcriptRoot, environment.signal);
-            }
-        }
-        finally {
-            await session.persistence?.close();
+        else {
+            session.persistence = SessionPersistence.fresh(store);
         }
     }
-    else {
-        if (environment.runNonInteractive === undefined) {
-            await runBatch(session, { signal: environment.signal });
+    try {
+        if (environment.runInteractive === undefined) {
+            await runApp(session, transcriptRoot, { shutdownSignal: environment.signal });
         }
         else {
-            await environment.runNonInteractive(session, environment.signal);
+            await environment.runInteractive(session, transcriptRoot, environment.signal);
         }
     }
+    finally {
+        await session.persistence?.close();
+    }
 }
 function applyResumedSession(session, conversation, persistence) {
     const identity = conversation.activeNode?.identity;

package/dist/timeline.js

@@ -16,6 +16,8 @@ export function timelinePicker(conversation, palette) {
             searchable: true,
             query: "",
             visible: 8,
+            // Turn labels are previews; keep each node on its own row without a second copy.
+            overflow: "truncate",
             options: entries.map((entry) => ({
                 label: `${entry.prefix}${preview(entry.node)}`,
                 hint: stamp(entry.node.createdAt),

package/dist/tui/activity.js

@@ -1,4 +1,4 @@
-// One foreground operation owns cancellation and elapsed time.
+// Each turn or command owns its cancellation and elapsed time.
 export function begin(kind, label, now = Date.now()) {
     return {
         kind,

package/dist/tui/app-input.js

@@ -1,4 +1,5 @@
 // Keyboard and pointer intent for the TUI shell.
+import { commandNeedsIdle } from "../commands.js";
 import { PROMPT_LIMIT_MESSAGE, PromptLimitError } from "../input-boundary.js";
 import { activate as activateCompletion, move as moveCompletion, selected as selectedCompletion, } from "./complete.js";
 import * as edit from "./editor.js";
@@ -11,7 +12,7 @@ const WHEEL_STEP = 3;
 export function appInput(options) {
     const { session, state, feedback, actions } = options;
     function handle(key) {
-        if (!options.live())
+        if (!options.live() || state.closeWhenIdle)
             return;
         // The wheel only changes what is visible. It never answers an open prompt.
         if (key.name === "pointer") {
@@ -23,7 +24,7 @@ export function appInput(options) {
         if (state.feedback !== undefined)
             feedback.dismiss();
         if (key.name === "input_limit") {
-            if (state.open === undefined)
+            if (state.open === undefined && state.approval === undefined)
                 rejectPrompt();
             else
                 showInputLimit();
@@ -38,20 +39,27 @@ export function appInput(options) {
                 options.transcriptChanged(changed);
             return;
         }
-        if (state.open !== undefined) {
-            const outcome = overlay.handle(state.open, key);
-            state.open = outcome.open;
+        const open = state.approval ?? state.open;
+        if (open !== undefined) {
+            const approving = state.approval !== undefined;
+            const outcome = overlay.handle(open, key);
+            if (approving)
+                state.approval = outcome.open;
+            else
+                state.open = outcome.open;
             if (outcome.inputLimit === true)
                 showInputLimit();
-            if (outcome.abort === true)
-                state.activity?.control.abort(new Error("interrupted"));
+            if (outcome.abort === true) {
+                (approving ? state.activity : state.command ?? state.activity)?.control.abort(new Error("interrupted"));
+            }
             if (outcome.quit === true)
                 options.requestQuit();
             return;
         }
         if (key.ctrl && key.name === "c") {
-            if (state.activity !== undefined)
-                state.activity.control.abort(new Error("interrupted"));
+            const activity = state.command ?? state.activity;
+            if (activity !== undefined)
+                activity.control.abort(new Error("interrupted"));
             else
                 options.quit();
             return;
@@ -66,7 +74,7 @@ export function appInput(options) {
                     state.completing = undefined;
                     return;
                 }
-                state.activity?.control.abort(new Error("interrupted"));
+                (state.command ?? state.activity)?.control.abort(new Error("interrupted"));
                 return;
             case "enter": {
                 if (state.completing !== undefined) {
@@ -81,7 +89,7 @@ export function appInput(options) {
                 return;
             }
             case "tab": {
-                if (state.activity !== undefined)
+                if (state.command !== undefined)
                     return;
                 const completion = state.completing ?? activateCompletion(state.editor.text);
                 const completed = completion === undefined ? undefined : selectedCompletion(completion);
@@ -125,7 +133,7 @@ export function appInput(options) {
                 if (edited.text !== state.editor.text)
                     state.promptRejected = false;
                 state.editor = edited;
-                state.completing = state.activity === undefined ? activateCompletion(edited.text) : undefined;
+                state.completing = state.command === undefined ? activateCompletion(edited.text) : undefined;
             }
         }
         catch (error) {
@@ -163,11 +171,20 @@ export function appInput(options) {
         if (text === "")
             return;
         const isCommand = text.startsWith("/");
-        if (state.activity !== undefined) {
-            if (isCommand) {
-                keep("Slash commands run after the active work finishes");
-                return;
-            }
+        if (isCommand && text.slice(1).trim().split(/\s+/)[0] === "exit") {
+            accept(text);
+            options.requestQuit();
+            return;
+        }
+        if (state.command !== undefined) {
+            keep("Wait for the active command to finish");
+            return;
+        }
+        if (isCommand && state.activity !== undefined && commandNeedsIdle(text)) {
+            keep(`Stop the active turn before ${text.split(/\s+/)[0]}`);
+            return;
+        }
+        if (state.activity !== undefined && !isCommand) {
             const result = actions.steer(text);
             if (result !== "queued") {
                 keep(result === "full"

package/dist/tui/app-workflows.js

@@ -1,11 +1,16 @@
 // Wire foreground workflows to the shell and their shared compaction lifetime.
 import { automaticCompactionGate } from "../context/automatic.js";
+import { inputLifetime } from "../context/lifetime.js";
 import { commandWorkflow } from "./command-workflow.js";
 import { turnWorkflow } from "./turn-workflow.js";
 export function appWorkflows(options) {
     const automaticCompaction = automaticCompactionGate();
+    const inputs = inputLifetime();
     return {
-        command: commandWorkflow(options, () => automaticCompaction.reset()),
-        ...turnWorkflow(options, automaticCompaction),
+        command: commandWorkflow(options, () => {
+            automaticCompaction.reset();
+            inputs.reset();
+        }, () => inputs.reset()),
+        ...turnWorkflow(options, automaticCompaction, inputs),
     };
 }