opencode-dux 1.0.0

package/src/hooks/phase-reminder/index.ts

@@ -0,0 +1,85 @@
+/**
+ * Phase reminder to append after each latest user message.
+ *
+ * Keeping this at the tail preserves immediate workflow guidance without
+ * mutating the cached system prompt or prepending request-local content ahead
+ * of the user's actual turn.
+ */
+import { PHASE_REMINDER_TEXT } from '../../config/constants';
+import { SLIM_INTERNAL_INITIATOR_MARKER } from '../../utils';
+
+export const PHASE_REMINDER = `<internal_reminder>${PHASE_REMINDER_TEXT}</internal_reminder>`;
+
+interface MessageInfo {
+  role: string;
+  agent?: string;
+  sessionID?: string;
+}
+
+interface MessagePart {
+  type: string;
+  text?: string;
+  [key: string]: unknown;
+}
+
+interface MessageWithParts {
+  info: MessageInfo;
+  parts: MessagePart[];
+}
+
+/**
+ * Creates the experimental.chat.messages.transform hook for phase reminder injection.
+ * This hook runs right before sending to API, so it doesn't affect UI display.
+ * Only injects for the orchestrator agent.
+ */
+export function createPhaseReminderHook() {
+  return {
+    'experimental.chat.messages.transform': async (
+      _input: Record<string, never>,
+      output: { messages: MessageWithParts[] },
+    ): Promise<void> => {
+      const { messages } = output;
+
+      if (messages.length === 0) {
+        return;
+      }
+
+      let lastUserMessageIndex = -1;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].info.role === 'user') {
+          lastUserMessageIndex = i;
+          break;
+        }
+      }
+
+      if (lastUserMessageIndex === -1) {
+        return;
+      }
+
+      const lastUserMessage = messages[lastUserMessageIndex];
+      const agent = lastUserMessage.info.agent;
+      if (agent && agent !== 'orchestrator') {
+        return;
+      }
+
+      const textPartIndex = lastUserMessage.parts.findIndex(
+        (p) => p.type === 'text' && p.text !== undefined,
+      );
+
+      if (textPartIndex === -1) {
+        return;
+      }
+
+      const originalText = lastUserMessage.parts[textPartIndex].text ?? '';
+      if (originalText.includes(SLIM_INTERNAL_INITIATOR_MARKER)) {
+        return;
+      }
+      if (originalText.includes(PHASE_REMINDER)) {
+        return;
+      }
+
+      lastUserMessage.parts[textPartIndex].text =
+        `${originalText}\n\n---\n\n${PHASE_REMINDER}`;
+    },
+  };
+}

package/src/hooks/post-file-tool-nudge/index.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'bun:test';
+
+import { PHASE_REMINDER_TEXT } from '../../config/constants';
+import { createPostFileToolNudgeHook } from './index';
+
+function createOutput(output = 'real content') {
+  return {
+    title: 'Read',
+    output,
+    metadata: {},
+  };
+}
+
+function countReminderInOutput(output: string | unknown): number {
+  if (typeof output !== 'string') return 0;
+  return output.split(PHASE_REMINDER_TEXT).length - 1;
+}
+
+describe('post-file-tool-nudge hook', () => {
+  test('appends delegation reminder to tool output', async () => {
+    const hook = createPostFileToolNudgeHook();
+    const output = createOutput();
+
+    await hook['tool.execute.after']({ tool: 'Read', sessionID: 's1' }, output);
+
+    expect(output.output).toContain(PHASE_REMINDER_TEXT);
+    expect(output.output).toContain('<internal_reminder>');
+    expect(output.output).toContain('</internal_reminder>');
+  });
+
+  test('does not duplicate reminder in same tool output', async () => {
+    const hook = createPostFileToolNudgeHook();
+    const output = createOutput();
+
+    await hook['tool.execute.after']({ tool: 'read', sessionID: 's1' }, output);
+    await hook['tool.execute.after']({ tool: 'read', sessionID: 's1' }, output);
+
+    expect(countReminderInOutput(output.output)).toBe(1);
+  });
+
+  test('deduplicates multiple Read/Write calls in same session', async () => {
+    const hook = createPostFileToolNudgeHook();
+    const output1 = createOutput('content 1');
+    const output2 = createOutput('content 2');
+    const output3 = createOutput('content 3');
+
+    await hook['tool.execute.after'](
+      { tool: 'read', sessionID: 's1' },
+      output1,
+    );
+    await hook['tool.execute.after'](
+      { tool: 'write', sessionID: 's1' },
+      output2,
+    );
+    await hook['tool.execute.after'](
+      { tool: 'Read', sessionID: 's1' },
+      output3,
+    );
+
+    expect(output1.output).toContain(PHASE_REMINDER_TEXT);
+    expect(output2.output).toContain(PHASE_REMINDER_TEXT);
+    expect(output3.output).toContain(PHASE_REMINDER_TEXT);
+  });
+
+  test('ignores non-file tools', async () => {
+    const hook = createPostFileToolNudgeHook();
+    const output = createOutput('ok');
+
+    await hook['tool.execute.after']({ tool: 'bash', sessionID: 's1' }, output);
+
+    expect(output.output).toBe('ok');
+    expect(output.output).not.toContain(PHASE_REMINDER_TEXT);
+  });
+
+  test('skips injection when shouldInject returns false', async () => {
+    const hook = createPostFileToolNudgeHook({ shouldInject: () => false });
+    const output = createOutput();
+
+    await hook['tool.execute.after']({ tool: 'read', sessionID: 's1' }, output);
+
+    expect(output.output).toBe('real content');
+    expect(output.output).not.toContain(PHASE_REMINDER_TEXT);
+  });
+
+  test('ignores Read/Write without sessionID', async () => {
+    const hook = createPostFileToolNudgeHook();
+    const output = createOutput();
+
+    await hook['tool.execute.after']({ tool: 'read' }, output);
+
+    expect(output.output).toBe('real content');
+    expect(output.output).not.toContain(PHASE_REMINDER_TEXT);
+  });
+});

package/src/hooks/post-file-tool-nudge/index.ts

@@ -0,0 +1,63 @@
+/**
+ * Post-tool nudge - queues a delegation reminder after file reads/writes.
+ * Catches the "inspect/edit files → implement myself" anti-pattern.
+ */
+
+import { PHASE_REMINDER_TEXT } from '../../config/constants';
+
+const POST_FILE_TOOL_NUDGE = PHASE_REMINDER_TEXT;
+
+interface ToolExecuteAfterInput {
+  tool: string;
+  sessionID?: string;
+  callID?: string;
+}
+
+interface ToolExecuteAfterOutput {
+  output?: unknown;
+}
+
+interface PostFileToolNudgeOptions {
+  shouldInject?: (sessionID: string) => boolean;
+}
+
+const FILE_TOOLS = new Set(['Read', 'read', 'Write', 'write']);
+
+export function createPostFileToolNudgeHook(
+  options: PostFileToolNudgeOptions = {},
+) {
+  function appendReminder(output: ToolExecuteAfterOutput): void {
+    if (typeof output.output !== 'string') {
+      return;
+    }
+
+    if (output.output.includes(POST_FILE_TOOL_NUDGE)) {
+      return;
+    }
+
+    output.output = [
+      output.output,
+      '',
+      '<internal_reminder>',
+      POST_FILE_TOOL_NUDGE,
+      '</internal_reminder>',
+    ].join('\n');
+  }
+
+  return {
+    'tool.execute.after': async (
+      input: ToolExecuteAfterInput,
+      output: ToolExecuteAfterOutput,
+    ): Promise<void> => {
+      if (!FILE_TOOLS.has(input.tool) || !input.sessionID) {
+        return;
+      }
+
+      if (options.shouldInject && !options.shouldInject(input.sessionID)) {
+        return;
+      }
+
+      appendReminder(output);
+    },
+  };
+}