@joshski/dust 0.1.87 → 0.1.89

package/dist/agent-events.d.ts

@@ -4,6 +4,7 @@
  * These types define the transport-agnostic event format used by both
  * the HTTP (loop) and WebSocket (bucket) paths.
  */
+import type { CommandEvent } from './command-events';
 export type AgentSessionEvent = {
     type: 'agent-session-started';
     title: string;
@@ -25,6 +26,9 @@ export type AgentSessionEvent = {
     type: 'agent-event';
     provider: string;
     rawEvent: Record<string, unknown>;
+} | {
+    type: 'command-event';
+    commandEvent: CommandEvent;
 };
 export interface EventMessage {
     sequence: number;

package/dist/artifacts/workflow-tasks.d.ts

@@ -21,7 +21,7 @@ export interface ParsedCaptureIdeaTask {
  * 6. Add .md extension
  */
 export declare function titleToFilename(title: string): string;
-export type WorkflowTaskType = 'refine' | 'decompose-idea' | 'shelve';
+export type WorkflowTaskType = 'refine-idea' | 'decompose-idea' | 'shelve-idea';
 export interface WorkflowTaskMatch {
     type: WorkflowTaskType;
     ideaSlug: string;

package/dist/artifacts.js

@@ -277,9 +277,11 @@ function titleToFilename(title) {
   return `${title.toLowerCase().replace(/\./g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}.md`;
 }
 var WORKFLOW_HINT_PATHS = {
-  refine: "config/workflow-hints/refine.md",
-  "decompose-idea": "config/workflow-hints/decompose-idea.md",
-  shelve: "config/workflow-hints/shelve.md"
+  "refine-idea": "config/hints/refine-idea.md",
+  "decompose-idea": "config/hints/decompose-idea.md",
+  "shelve-idea": "config/hints/shelve-idea.md",
+  "add-idea": "config/hints/add-idea.md",
+  "expedite-idea": "config/hints/expedite-idea.md"
 };
 async function readWorkflowHint(fileSystem, dustPath, workflowType) {
   const hintPath = `${dustPath}/${WORKFLOW_HINT_PATHS[workflowType]}`;
@@ -289,9 +291,9 @@ async function readWorkflowHint(fileSystem, dustPath, workflowType) {
   return fileSystem.readFile(hintPath);
 }
 var WORKFLOW_SECTION_HEADINGS = [
-  { type: "refine", heading: "Refines Idea" },
+  { type: "refine-idea", heading: "Refines Idea" },
   { type: "decompose-idea", heading: "Decomposes Idea" },
-  { type: "shelve", heading: "Shelves Idea" }
+  { type: "shelve-idea", heading: "Shelves Idea" }
 ];
 function extractIdeaSlugFromSection(content, sectionHeading) {
   const lines = content.split(`
@@ -450,7 +452,7 @@ ${hint}` : baseOpeningSentence;
 }
 async function createRefineIdeaTask(fileSystem, dustPath, ideaSlug, description, dustCommand) {
   const cmd = dustCommand ?? "dust";
-  return createIdeaTransitionTask(fileSystem, dustPath, "refine", "Refine Idea: ", ideaSlug, (ideaTitle) => `Thoroughly research this idea and refine it into a well-defined proposal. Read the idea file, explore the codebase for relevant context, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. Run \`${cmd} principles\` for alignment and \`${cmd} facts\` for relevant design decisions. See [${ideaTitle}](../ideas/${ideaSlug}.md). If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking.`, [
+  return createIdeaTransitionTask(fileSystem, dustPath, "refine-idea", "Refine Idea: ", ideaSlug, (ideaTitle) => `Thoroughly research this idea and refine it into a well-defined proposal. Read the idea file, explore the codebase for relevant context, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. Run \`${cmd} principles\` for alignment and \`${cmd} facts\` for relevant design decisions. See [${ideaTitle}](../ideas/${ideaSlug}.md). If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking.`, [
     "Idea is thoroughly researched with relevant codebase context",
     "Open questions are added for any ambiguous or underspecified aspects",
     "Open questions follow the required heading format and focus on high-value decisions",
@@ -469,7 +471,7 @@ async function decomposeIdea(fileSystem, dustPath, options, dustCommand) {
   });
 }
 async function createShelveIdeaTask(fileSystem, dustPath, ideaSlug, description, _dustCommand) {
-  return createIdeaTransitionTask(fileSystem, dustPath, "shelve", "Shelve Idea: ", ideaSlug, (ideaTitle) => `Archive this idea and remove it from the active backlog. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, ["Idea file is deleted", "Rationale is recorded in the commit message"], "Shelves Idea", { description });
+  return createIdeaTransitionTask(fileSystem, dustPath, "shelve-idea", "Shelve Idea: ", ideaSlug, (ideaTitle) => `Archive this idea and remove it from the active backlog. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, ["Idea file is deleted", "Rationale is recorded in the commit message"], "Shelves Idea", { description });
 }
 async function createIdeaTask(fileSystem, dustPath, options) {
   const { title, description, expedite, dustCommand } = options;
@@ -484,9 +486,14 @@ async function createIdeaTask(fileSystem, dustPath, options) {
     const taskTitle2 = `${EXPEDITE_IDEA_PREFIX}${title}`;
     const filename2 = titleToFilename(taskTitle2);
     const filePath2 = `${dustPath}/tasks/${filename2}`;
+    const baseOpeningSentence2 = `Research this idea briefly. If confident the implementation is straightforward (clear scope, minimal risk, no open questions), implement directly and commit. Otherwise, create one or more narrowly-scoped task files in \`.dust/tasks/\`. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context.`;
+    const hint2 = await readWorkflowHint(fileSystem, dustPath, "expedite-idea");
+    const openingSentence2 = hint2 ? `${baseOpeningSentence2}
+
+${hint2}` : baseOpeningSentence2;
     const content2 = `# ${taskTitle2}
 
-Research this idea briefly. If confident the implementation is straightforward (clear scope, minimal risk, no open questions), implement directly and commit. Otherwise, create one or more narrowly-scoped task files in \`.dust/tasks/\`. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context.
+${openingSentence2}
 
 ## Idea Description
 
@@ -508,9 +515,14 @@ ${description}
   const taskTitle = `${CAPTURE_IDEA_PREFIX}${title}`;
   const filename = titleToFilename(taskTitle);
   const filePath = `${dustPath}/tasks/${filename}`;
+  const baseOpeningSentence = `Research this idea thoroughly, then create one or more idea files in \`.dust/ideas/\`. Read the codebase for relevant context, flesh out the description, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context.`;
+  const hint = await readWorkflowHint(fileSystem, dustPath, "add-idea");
+  const openingSentence = hint ? `${baseOpeningSentence}
+
+${hint}` : baseOpeningSentence;
   const content = `# ${taskTitle}
 
-Research this idea thoroughly, then create one or more idea files in \`.dust/ideas/\`. Read the codebase for relevant context, flesh out the description, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context.
+${openingSentence}
 
 ## Idea Description
 

package/dist/bucket/command-events-proxy.d.ts

@@ -0,0 +1,29 @@
+import type { CommandEventMessage } from '../command-events';
+import type { ToolDefinition } from './server-messages';
+export interface CommandEventsProxy {
+    port: number;
+    stop: () => Promise<void>;
+}
+export interface ToolExecutionRequest {
+    toolName: string;
+    arguments: string[];
+    repositoryId: string;
+}
+export type ToolExecutionStatus = 'success' | 'tool-not-found' | 'error';
+export interface ToolExecutionResult {
+    status: ToolExecutionStatus;
+    output?: string;
+    error?: string;
+}
+interface CommandEventsProxyHandlers {
+    forwardEvent: (event: CommandEventMessage) => void;
+    getTools: () => ToolDefinition[];
+    forwardToolExecution: (request: ToolExecutionRequest) => Promise<ToolExecutionResult>;
+}
+export declare function isCommandEventMessage(payload: unknown): payload is CommandEventMessage;
+/**
+ * Start a local HTTP proxy that accepts command events on POST /events.
+ * Accepted payloads are forwarded to the bucket WebSocket channel.
+ */
+export declare function startCommandEventsProxy(handlers: CommandEventsProxyHandlers): Promise<CommandEventsProxy>;
+export {};

package/dist/bucket/repository-loop.d.ts

@@ -4,7 +4,7 @@
  * Manages the async loop that picks tasks and runs Claude sessions
  * for a single repository.
  */
-import type { AgentSessionEvent, EventMessage } from '../agent-events';
+import type { EventMessage } from '../agent-events';
 import { type run as claudeRun, type RunnerDependencies } from '../claude/run';
 import type { OutputSink } from '../claude/types';
 import { type LoopEmitFn, type SendAgentEventFn } from '../cli/commands/loop';
@@ -35,7 +35,7 @@ export declare function buildEventMessage(parameters: {
     sessionId: string;
     repository: string;
     repoId?: number;
-    event: AgentSessionEvent;
+    event: EventMessage['event'];
     agentSessionId?: string;
 }): EventMessage;
 /**

package/dist/bucket/repository.d.ts

@@ -8,6 +8,7 @@ import { spawn as nodeSpawn } from 'node:child_process';
 import { run as claudeRun } from '../claude/run';
 import type { CommandDependencies, FileSystem } from '../cli/types';
 import type { DockerDependencies } from '../docker/docker-agent';
+import type { ToolExecutionRequest, ToolExecutionResult } from './command-events-proxy';
 import { type BucketEmitFn, type SendEventFn } from './events';
 import { type LogBuffer } from './log-buffer';
 import type { ToolDefinition } from './server-messages';
@@ -53,6 +54,8 @@ export interface RepositoryDependencies {
     dockerDeps?: Partial<DockerDependencies>;
     /** Function to get current tool definitions */
     getTools?: () => ToolDefinition[];
+    /** Forward tool execution requests to the bucket server */
+    forwardToolExecution?: (request: ToolExecutionRequest) => Promise<ToolExecutionResult>;
 }
 /**
  * Start (or restart) the per-repository loop and keep loopPromise state accurate.

package/dist/cli/commands/loop.d.ts

@@ -109,6 +109,8 @@ interface IterationOptions {
     docker?: DockerSpawnConfig;
     /** Pre-formatted tools section to inject into the prompt */
     toolsSection?: string;
+    /** Port of the command events proxy for this iteration */
+    proxyPort?: number;
 }
 export declare function runOneIteration(dependencies: CommandDependencies, loopDependencies: LoopDependencies, onLoopEvent: LoopEmitFn, onAgentEvent?: SendAgentEventFn, options?: IterationOptions): Promise<IterationResult>;
 export declare function parseMaxIterations(commandArguments: string[]): number;

package/dist/command-events.d.ts

@@ -1,9 +1,9 @@
 /**
  * Command event types for the dust back channel protocol.
  *
- * These types define structured events emitted by dust commands
- * to a file descriptor specified by DUST_EVENTS_FD. Events are
- * written as newline-delimited JSON using the CommandEventMessage envelope.
+ * These types define structured events emitted by dust commands.
+ * Events are transported via DUST_PROXY_PORT (HTTP POST /events),
+ * using the same envelope.
  */
 /**
  * Events emitted by dust commands.