@w32191/just-loop 0.1.4 → 0.1.6

package/dist/src/plugin/create-plugin.d.ts

@@ -1,5 +1,6 @@
 import { createOpenCodeHostAdapter } from "../host-adapter/opencode-host-adapter.js";
 import { createLoopCore } from "../ralph-loop/loop-core.js";
+import { type TuiCommandExecuteInput } from "./tui-command-execute-handler.js";
 import type { Plugin } from "@opencode-ai/plugin";
 export type CreatePluginDeps = {
     createOpenCodeHostAdapter?: typeof createOpenCodeHostAdapter;
@@ -48,6 +49,7 @@ export type PluginHooks = {
     event: (input: EventInput) => Promise<void>;
     config: (input: Record<string, unknown>) => Promise<void>;
     "command.execute.before": (input: CommandExecuteBeforeInput, output: CommandExecuteBeforeOutput) => Promise<void>;
+    "tui.command.execute": (input: TuiCommandExecuteInput) => Promise<void>;
     "tool.execute.before": (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
 };
 export declare function createPlugin(ctx?: PluginInput, deps?: CreatePluginDeps): Promise<PluginHooks>;

package/dist/src/plugin/create-plugin.js

@@ -4,6 +4,7 @@ import { handleCommandExecuteBefore } from "./command-execute-before-handler.js"
 import { handleConfig } from "./config-handler.js";
 import { handleEvent } from "./event-handler.js";
 import { resolvePluginConfig } from "./plugin-config.js";
+import { handleTuiCommandExecute } from "./tui-command-execute-handler.js";
 import { handleToolExecuteBefore } from "./tool-execute-before-handler.js";
 function extractSessionID(input) {
     if (typeof input.sessionID === "string")
@@ -68,6 +69,11 @@ export async function createPlugin(ctx, deps = {}) {
                 defaultMaxIterations: resolvedConfig.defaultMaxIterations,
             });
         },
+        "tui.command.execute": async (input) => {
+            if (!resolvedConfig.enabled)
+                return;
+            await handleTuiCommandExecute(input, core);
+        },
         "tool.execute.before": async (input, output) => {
             if (!resolvedConfig.enabled)
                 return;

package/dist/src/plugin/tui-command-execute-handler.d.ts

@@ -0,0 +1,8 @@
+type LoopCore = {
+    handleEvent: (event: {
+        type: "session.interrupt";
+    }) => Promise<unknown>;
+};
+export type TuiCommandExecuteInput = unknown;
+export declare function handleTuiCommandExecute(input: TuiCommandExecuteInput, core: LoopCore): Promise<void>;
+export {};

package/dist/src/plugin/tui-command-execute-handler.js

@@ -0,0 +1,15 @@
+function hasInterruptCommand(input) {
+    if (!input || typeof input !== "object")
+        return false;
+    const properties = input.properties;
+    if (!properties || typeof properties !== "object")
+        return false;
+    return properties.command === "session.interrupt";
+}
+export async function handleTuiCommandExecute(input, core) {
+    if (!hasInterruptCommand(input))
+        return;
+    // active-loop-scoped only: even though the core event name is session.interrupt,
+    // tui.command.execute does not provide sessionID, so this forwards a loop-level interrupt.
+    await core.handleEvent({ type: "session.interrupt" });
+}

package/dist/src/ralph-loop/loop-core.d.ts

@@ -9,6 +9,8 @@ export type LoopEvent = {
 } | {
     type: "session.error";
     sessionID: string;
+} | {
+    type: "session.interrupt";
 };
 export type CreateLoopCoreDeps = {
     rootDir: string;

package/dist/src/ralph-loop/loop-core.js

@@ -5,55 +5,88 @@ import { clearState, readState, writeState } from "./state-store.js";
 import { randomUUID } from "node:crypto";
 export function createLoopCore(deps) {
     const inFlight = new Map();
+    let stateMutationQueue = Promise.resolve();
     const getConfig = () => deps.getConfig?.() ?? {
         enabled: true,
         defaultMaxIterations: DEFAULT_MAX_ITERATIONS_FALLBACK,
         defaultStrategy: DEFAULT_STRATEGY,
     };
     const getToken = (state) => state.incarnation_token ?? state.started_at;
+    const runStateMutation = async (mutation) => {
+        const run = stateMutationQueue.then(mutation, mutation);
+        stateMutationQueue = run.then(() => undefined, () => undefined);
+        return run;
+    };
     return {
         async startLoop(sessionID, prompt, options = {}) {
-            const config = getConfig();
-            const existing = await readState(deps.rootDir);
-            if (existing?.active) {
-                const stillExists = await deps.adapter.sessionExists(existing.session_id);
-                if (stillExists) {
-                    throw new Error("an active Ralph Loop already exists; use /cancel-ralph first");
+            return await runStateMutation(async () => {
+                const config = getConfig();
+                const existing = await readState(deps.rootDir);
+                if (existing?.active) {
+                    const stillExists = await deps.adapter.sessionExists(existing.session_id);
+                    if (stillExists) {
+                        throw new Error("an active Ralph Loop already exists; use /cancel-ralph first");
+                    }
+                    await clearState(deps.rootDir);
                 }
-                await clearState(deps.rootDir);
-            }
-            else if (existing) {
-                await clearState(deps.rootDir);
-            }
-            const messageCountAtStart = await deps.adapter.getMessageCount(sessionID);
-            const incarnationToken = randomUUID();
-            const state = {
-                active: true,
-                session_id: sessionID,
-                prompt,
-                iteration: 0,
-                max_iterations: options.maxIterations ?? config.defaultMaxIterations,
-                completion_promise: options.completionPromise ?? DEFAULT_COMPLETION_PROMISE,
-                message_count_at_start: messageCountAtStart,
-                incarnation_token: incarnationToken,
-                started_at: new Date().toISOString(),
-            };
-            await writeState(deps.rootDir, state);
+                else if (existing) {
+                    await clearState(deps.rootDir);
+                }
+                const messageCountAtStart = await deps.adapter.getMessageCount(sessionID);
+                const incarnationToken = randomUUID();
+                const state = {
+                    active: true,
+                    session_id: sessionID,
+                    prompt,
+                    iteration: 0,
+                    max_iterations: options.maxIterations ?? config.defaultMaxIterations,
+                    completion_promise: options.completionPromise ?? DEFAULT_COMPLETION_PROMISE,
+                    message_count_at_start: messageCountAtStart,
+                    incarnation_token: incarnationToken,
+                    started_at: new Date().toISOString(),
+                };
+                await writeState(deps.rootDir, state);
+            });
         },
         async cancelLoop(sessionID) {
-            const state = await readState(deps.rootDir);
-            if (!state || !state.active || state.session_id !== sessionID)
-                return;
-            await deps.adapter.abortSession(sessionID);
-            await clearState(deps.rootDir);
+            return await runStateMutation(async () => {
+                const state = await readState(deps.rootDir);
+                if (!state || !state.active || state.session_id !== sessionID)
+                    return;
+                await deps.adapter.abortSession(sessionID);
+                await clearState(deps.rootDir);
+            });
         },
         async handleEvent(event) {
+            if (event.type === "session.interrupt") {
+                return await runStateMutation(async () => {
+                    const state = await readState(deps.rootDir);
+                    if (!state || !state.active)
+                        return;
+                    const observedSessionID = state.session_id;
+                    const observedToken = getToken(state);
+                    // active-loop-scoped only: the host interrupt hook does not provide sessionID,
+                    // so we re-read before write and only stamp the currently active incarnation.
+                    const currentState = await readState(deps.rootDir);
+                    if (!currentState ||
+                        !currentState.active ||
+                        currentState.session_id !== observedSessionID ||
+                        getToken(currentState) !== observedToken) {
+                        return;
+                    }
+                    await writeState(deps.rootDir, {
+                        ...currentState,
+                        skip_next_continuation: true,
+                    });
+                });
+            }
             if (event.type === "session.deleted" || event.type === "session.error") {
-                const state = await readState(deps.rootDir);
-                if (state && state.active && state.session_id === event.sessionID) {
-                    await clearState(deps.rootDir);
-                }
-                return;
+                return await runStateMutation(async () => {
+                    const state = await readState(deps.rootDir);
+                    if (state && state.active && state.session_id === event.sessionID) {
+                        await clearState(deps.rootDir);
+                    }
+                });
             }
             try {
                 const state = await readState(deps.rootDir);
@@ -64,13 +97,15 @@ export function createLoopCore(deps) {
                     const observedToken = getToken(state);
                     const stillExists = await deps.adapter.sessionExists(observedSessionID);
                     if (!stillExists) {
-                        const currentState = await readState(deps.rootDir);
-                        if (currentState &&
-                            currentState.active &&
-                            currentState.session_id === observedSessionID &&
-                            getToken(currentState) === observedToken) {
-                            await clearState(deps.rootDir);
-                        }
+                        await runStateMutation(async () => {
+                            const currentState = await readState(deps.rootDir);
+                            if (currentState &&
+                                currentState.active &&
+                                currentState.session_id === observedSessionID &&
+                                getToken(currentState) === observedToken) {
+                                await clearState(deps.rootDir);
+                            }
+                        });
                     }
                     return;
                 }
@@ -96,37 +131,83 @@ export function createLoopCore(deps) {
                     getToken(liveState) !== incarnationToken) {
                     return;
                 }
-                const currentLiveState = liveState;
-                if (detectCompletion(messages, currentLiveState.completion_promise, currentLiveState.message_count_at_start)) {
-                    await clearState(deps.rootDir);
+                const continuationState = await readState(deps.rootDir);
+                if (!continuationState ||
+                    !continuationState.active ||
+                    continuationState.session_id !== event.sessionID ||
+                    getToken(continuationState) !== incarnationToken) {
                     return;
                 }
-                const nextIteration = currentLiveState.iteration + 1;
-                if (typeof currentLiveState.max_iterations === "number" &&
-                    nextIteration > currentLiveState.max_iterations) {
-                    await clearState(deps.rootDir);
+                if (detectCompletion(messages, continuationState.completion_promise, continuationState.message_count_at_start)) {
+                    await runStateMutation(async () => {
+                        const currentState = await readState(deps.rootDir);
+                        if (currentState &&
+                            currentState.active &&
+                            currentState.session_id === event.sessionID &&
+                            getToken(currentState) === incarnationToken &&
+                            detectCompletion(messages, currentState.completion_promise, currentState.message_count_at_start)) {
+                            await clearState(deps.rootDir);
+                        }
+                    });
                     return;
                 }
-                await deps.adapter.prompt(event.sessionID, buildContinuationPrompt({
-                    iteration: nextIteration,
-                    prompt: currentLiveState.prompt,
-                    completionPromise: currentLiveState.completion_promise,
-                    maxIterations: currentLiveState.max_iterations,
-                }));
-                const currentState = await readState(deps.rootDir);
-                if (!currentState ||
-                    !currentState.active ||
-                    currentState.session_id !== event.sessionID ||
-                    getToken(currentState) !== incarnationToken) {
+                const nextIteration = continuationState.iteration + 1;
+                if (typeof continuationState.max_iterations === "number" &&
+                    nextIteration > continuationState.max_iterations) {
+                    await runStateMutation(async () => {
+                        const currentState = await readState(deps.rootDir);
+                        if (currentState &&
+                            currentState.active &&
+                            currentState.session_id === event.sessionID &&
+                            getToken(currentState) === incarnationToken &&
+                            typeof currentState.max_iterations === "number" &&
+                            currentState.iteration + 1 > currentState.max_iterations) {
+                            await clearState(deps.rootDir);
+                        }
+                    });
+                    return;
+                }
+                if (continuationState.skip_next_continuation) {
+                    // Consume the one-shot suppress flag for the currently active loop only.
+                    await runStateMutation(async () => {
+                        const currentState = await readState(deps.rootDir);
+                        if (!currentState ||
+                            !currentState.active ||
+                            currentState.session_id !== event.sessionID ||
+                            getToken(currentState) !== incarnationToken ||
+                            !currentState.skip_next_continuation) {
+                            return;
+                        }
+                        const nextState = {
+                            ...currentState,
+                            last_message_count_processed: batchMessageCount,
+                        };
+                        delete nextState.skip_next_continuation;
+                        await writeState(deps.rootDir, nextState);
+                    });
                     return;
                 }
-                const persistedState = currentState;
-                const nextState = {
-                    ...persistedState,
+                await deps.adapter.prompt(event.sessionID, buildContinuationPrompt({
                     iteration: nextIteration,
-                    last_message_count_processed: batchMessageCount,
-                };
-                await writeState(deps.rootDir, nextState);
+                    prompt: continuationState.prompt,
+                    completionPromise: continuationState.completion_promise,
+                    maxIterations: continuationState.max_iterations,
+                }));
+                await runStateMutation(async () => {
+                    const currentState = await readState(deps.rootDir);
+                    if (!currentState ||
+                        !currentState.active ||
+                        currentState.session_id !== event.sessionID ||
+                        getToken(currentState) !== incarnationToken) {
+                        return;
+                    }
+                    const nextState = {
+                        ...currentState,
+                        iteration: nextIteration,
+                        last_message_count_processed: batchMessageCount,
+                    };
+                    await writeState(deps.rootDir, nextState);
+                });
             }
             finally {
                 const currentToken = inFlight.get(event.sessionID);

package/dist/src/ralph-loop/state-store.js

@@ -17,6 +17,7 @@ function isRalphLoopState(value) {
         typeof record.completion_promise === "string" &&
         typeof record.message_count_at_start === "number" &&
         (record.last_message_count_processed === undefined || typeof record.last_message_count_processed === "number") &&
+        (record.skip_next_continuation === undefined || typeof record.skip_next_continuation === "boolean") &&
         (record.incarnation_token === undefined || typeof record.incarnation_token === "string") &&
         typeof record.started_at === "string");
 }

package/dist/src/ralph-loop/types.d.ts

@@ -7,6 +7,7 @@ export type RalphLoopState = {
     completion_promise: string;
     message_count_at_start: number;
     last_message_count_processed?: number;
+    skip_next_continuation?: boolean;
     incarnation_token?: string;
     started_at: string;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@w32191/just-loop",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "OpenCode plugin package for just-loop.",
   "license": "MIT",
   "repository": {