@locusai/cli 0.11.6 → 0.11.7

package/bin/locus.js

@@ -37982,12 +37982,536 @@ var init_models = __esm(() => {
   init_workspace();
 });
 
+// ../shared/src/protocol/envelope.ts
+var PROTOCOL_VERSION = 1, ProtocolVersionSchema, ProtocolEnvelopeSchema;
+var init_envelope = __esm(() => {
+  init_zod();
+  ProtocolVersionSchema = exports_external.literal(PROTOCOL_VERSION);
+  ProtocolEnvelopeSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.string()
+  });
+});
+
+// ../shared/src/protocol/errors.ts
+var ProtocolErrorCode, ProtocolErrorCodeSchema, ProtocolErrorSchema;
+var init_errors3 = __esm(() => {
+  init_zod();
+  ProtocolErrorCode = {
+    CLI_NOT_FOUND: "CLI_NOT_FOUND",
+    AUTH_EXPIRED: "AUTH_EXPIRED",
+    NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
+    CONTEXT_LIMIT: "CONTEXT_LIMIT",
+    MALFORMED_EVENT: "MALFORMED_EVENT",
+    PROCESS_CRASHED: "PROCESS_CRASHED",
+    SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+    UNKNOWN: "UNKNOWN"
+  };
+  ProtocolErrorCodeSchema = exports_external.enum(ProtocolErrorCode);
+  ProtocolErrorSchema = exports_external.object({
+    code: ProtocolErrorCodeSchema,
+    message: exports_external.string(),
+    details: exports_external.unknown().optional(),
+    recoverable: exports_external.boolean()
+  });
+});
+
+// ../shared/src/protocol/cli-stream.ts
+function createCliStreamEvent(type, sessionId, payload) {
+  return CliStreamEventSchema.parse({
+    protocol: PROTOCOL_VERSION,
+    type,
+    sessionId,
+    timestamp: Date.now(),
+    payload
+  });
+}
+var CliStreamEventType, CliStreamEventTypeSchema, CliStreamBaseSchema, CliStartEventSchema, CliTextDeltaEventSchema, CliThinkingEventSchema, CliToolStartedEventSchema, CliToolCompletedEventSchema, CliStatusEventSchema, CliErrorEventSchema, CliDoneEventSchema, CliStreamEventSchema;
+var init_cli_stream = __esm(() => {
+  init_zod();
+  init_envelope();
+  init_errors3();
+  CliStreamEventType = {
+    START: "start",
+    TEXT_DELTA: "text_delta",
+    THINKING: "thinking",
+    TOOL_STARTED: "tool_started",
+    TOOL_COMPLETED: "tool_completed",
+    STATUS: "status",
+    ERROR: "error",
+    DONE: "done"
+  };
+  CliStreamEventTypeSchema = exports_external.enum(CliStreamEventType);
+  CliStreamBaseSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    sessionId: exports_external.string(),
+    timestamp: exports_external.number()
+  });
+  CliStartEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.START),
+    payload: exports_external.object({
+      command: exports_external.string(),
+      model: exports_external.string().optional(),
+      provider: exports_external.string().optional(),
+      cwd: exports_external.string().optional()
+    })
+  });
+  CliTextDeltaEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.TEXT_DELTA),
+    payload: exports_external.object({
+      content: exports_external.string()
+    })
+  });
+  CliThinkingEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.THINKING),
+    payload: exports_external.object({
+      content: exports_external.string().optional()
+    })
+  });
+  CliToolStartedEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.TOOL_STARTED),
+    payload: exports_external.object({
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+    })
+  });
+  CliToolCompletedEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.TOOL_COMPLETED),
+    payload: exports_external.object({
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      success: exports_external.boolean(),
+      duration: exports_external.number().optional(),
+      error: exports_external.string().optional()
+    })
+  });
+  CliStatusEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.STATUS),
+    payload: exports_external.object({
+      status: exports_external.string(),
+      message: exports_external.string().optional()
+    })
+  });
+  CliErrorEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.ERROR),
+    payload: exports_external.object({
+      error: ProtocolErrorSchema
+    })
+  });
+  CliDoneEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.DONE),
+    payload: exports_external.object({
+      exitCode: exports_external.number().int(),
+      duration: exports_external.number(),
+      toolsUsed: exports_external.array(exports_external.string()).optional(),
+      tokensUsed: exports_external.number().optional(),
+      success: exports_external.boolean()
+    })
+  });
+  CliStreamEventSchema = exports_external.discriminatedUnion("type", [
+    CliStartEventSchema,
+    CliTextDeltaEventSchema,
+    CliThinkingEventSchema,
+    CliToolStartedEventSchema,
+    CliToolCompletedEventSchema,
+    CliStatusEventSchema,
+    CliErrorEventSchema,
+    CliDoneEventSchema
+  ]);
+});
+
+// ../shared/src/protocol/context.ts
+var ActiveFileContextSchema, SelectionContextSchema, WorkspaceContextSchema, ContextPayloadSchema;
+var init_context = __esm(() => {
+  init_zod();
+  ActiveFileContextSchema = exports_external.object({
+    filePath: exports_external.string(),
+    languageId: exports_external.string().optional()
+  });
+  SelectionContextSchema = exports_external.object({
+    filePath: exports_external.string(),
+    languageId: exports_external.string().optional(),
+    startLine: exports_external.number().int().min(0),
+    startColumn: exports_external.number().int().min(0),
+    endLine: exports_external.number().int().min(0),
+    endColumn: exports_external.number().int().min(0),
+    text: exports_external.string()
+  });
+  WorkspaceContextSchema = exports_external.object({
+    rootPath: exports_external.string(),
+    name: exports_external.string().optional()
+  });
+  ContextPayloadSchema = exports_external.object({
+    workspace: WorkspaceContextSchema.optional(),
+    activeFile: ActiveFileContextSchema.optional(),
+    selection: SelectionContextSchema.optional()
+  });
+});
+
+// ../shared/src/protocol/session.ts
+var SessionStatus, SessionStatusSchema, SessionTransitionEvent, SessionTransitionEventSchema, SESSION_TRANSITIONS, TERMINAL_STATUSES, SessionMetadataSchema, SessionSummarySchema;
+var init_session = __esm(() => {
+  init_zod();
+  SessionStatus = {
+    IDLE: "idle",
+    STARTING: "starting",
+    RUNNING: "running",
+    STREAMING: "streaming",
+    COMPLETED: "completed",
+    CANCELED: "canceled",
+    INTERRUPTED: "interrupted",
+    FAILED: "failed",
+    RESUMING: "resuming"
+  };
+  SessionStatusSchema = exports_external.enum(SessionStatus);
+  SessionTransitionEvent = {
+    CREATE_SESSION: "create_session",
+    CLI_SPAWNED: "cli_spawned",
+    FIRST_TEXT_DELTA: "first_text_delta",
+    RESULT_RECEIVED: "result_received",
+    USER_STOP: "user_stop",
+    PROCESS_LOST: "process_lost",
+    RESUME: "resume",
+    ERROR: "error"
+  };
+  SessionTransitionEventSchema = exports_external.enum(SessionTransitionEvent);
+  SESSION_TRANSITIONS = [
+    {
+      from: SessionStatus.IDLE,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    },
+    {
+      from: SessionStatus.STARTING,
+      event: SessionTransitionEvent.CLI_SPAWNED,
+      to: SessionStatus.RUNNING
+    },
+    {
+      from: SessionStatus.STARTING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.FIRST_TEXT_DELTA,
+      to: SessionStatus.STREAMING
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.USER_STOP,
+      to: SessionStatus.CANCELED
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.PROCESS_LOST,
+      to: SessionStatus.INTERRUPTED
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.RESULT_RECEIVED,
+      to: SessionStatus.COMPLETED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.USER_STOP,
+      to: SessionStatus.CANCELED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.PROCESS_LOST,
+      to: SessionStatus.INTERRUPTED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.INTERRUPTED,
+      event: SessionTransitionEvent.RESUME,
+      to: SessionStatus.RESUMING
+    },
+    {
+      from: SessionStatus.RESUMING,
+      event: SessionTransitionEvent.CLI_SPAWNED,
+      to: SessionStatus.RUNNING
+    },
+    {
+      from: SessionStatus.RESUMING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.COMPLETED,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    },
+    {
+      from: SessionStatus.CANCELED,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    },
+    {
+      from: SessionStatus.FAILED,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    }
+  ];
+  TERMINAL_STATUSES = new Set([
+    SessionStatus.COMPLETED,
+    SessionStatus.CANCELED,
+    SessionStatus.FAILED
+  ]);
+  SessionMetadataSchema = exports_external.object({
+    sessionId: exports_external.string(),
+    status: SessionStatusSchema,
+    model: exports_external.string().optional(),
+    createdAt: exports_external.number(),
+    updatedAt: exports_external.number(),
+    title: exports_external.string().optional()
+  });
+  SessionSummarySchema = exports_external.object({
+    sessionId: exports_external.string(),
+    status: SessionStatusSchema,
+    model: exports_external.string().optional(),
+    title: exports_external.string().optional(),
+    createdAt: exports_external.number(),
+    updatedAt: exports_external.number(),
+    messageCount: exports_external.number(),
+    toolCount: exports_external.number()
+  });
+});
+
+// ../shared/src/protocol/host-events.ts
+var HostEventType, HostEventTypeSchema, TimelineEntryKind, TimelineEntryKindSchema, TimelineEntrySchema, SessionStateEventSchema, TextDeltaEventSchema, ToolStartedEventSchema, ToolCompletedEventSchema, ThinkingEventSchema, ErrorEventSchema, SessionListEventSchema, SessionCompletedEventSchema, HostEventSchema;
+var init_host_events = __esm(() => {
+  init_zod();
+  init_envelope();
+  init_errors3();
+  init_session();
+  HostEventType = {
+    SESSION_STATE: "session_state",
+    TEXT_DELTA: "text_delta",
+    TOOL_STARTED: "tool_started",
+    TOOL_COMPLETED: "tool_completed",
+    THINKING: "thinking",
+    ERROR: "error",
+    SESSION_LIST: "session_list",
+    SESSION_COMPLETED: "session_completed"
+  };
+  HostEventTypeSchema = exports_external.enum(HostEventType);
+  TimelineEntryKind = {
+    MESSAGE: "message",
+    TOOL_CALL: "tool_call",
+    STATUS: "status",
+    ERROR: "error",
+    DONE: "done"
+  };
+  TimelineEntryKindSchema = exports_external.enum(TimelineEntryKind);
+  TimelineEntrySchema = exports_external.object({
+    id: exports_external.string(),
+    kind: TimelineEntryKindSchema,
+    timestamp: exports_external.number(),
+    data: exports_external.record(exports_external.string(), exports_external.unknown())
+  });
+  SessionStateEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.SESSION_STATE),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      status: SessionStatusSchema,
+      metadata: SessionMetadataSchema.optional(),
+      timeline: exports_external.array(TimelineEntrySchema).optional()
+    })
+  });
+  TextDeltaEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.TEXT_DELTA),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      content: exports_external.string()
+    })
+  });
+  ToolStartedEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.TOOL_STARTED),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+    })
+  });
+  ToolCompletedEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.TOOL_COMPLETED),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      result: exports_external.unknown().optional(),
+      duration: exports_external.number().optional(),
+      success: exports_external.boolean(),
+      error: exports_external.string().optional()
+    })
+  });
+  ThinkingEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.THINKING),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      content: exports_external.string().optional()
+    })
+  });
+  ErrorEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.ERROR),
+    payload: exports_external.object({
+      sessionId: exports_external.string().optional(),
+      error: ProtocolErrorSchema
+    })
+  });
+  SessionListEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.SESSION_LIST),
+    payload: exports_external.object({
+      sessions: exports_external.array(SessionSummarySchema)
+    })
+  });
+  SessionCompletedEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.SESSION_COMPLETED),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      summary: exports_external.string().optional()
+    })
+  });
+  HostEventSchema = exports_external.discriminatedUnion("type", [
+    SessionStateEventSchema,
+    TextDeltaEventSchema,
+    ToolStartedEventSchema,
+    ToolCompletedEventSchema,
+    ThinkingEventSchema,
+    ErrorEventSchema,
+    SessionListEventSchema,
+    SessionCompletedEventSchema
+  ]);
+});
+
+// ../shared/src/protocol/ui-intents.ts
+var UIIntentType, UIIntentTypeSchema, SubmitPromptIntentSchema, StopSessionIntentSchema, ResumeSessionIntentSchema, RequestSessionsIntentSchema, RequestSessionDetailIntentSchema, ClearSessionIntentSchema, WebviewReadyIntentSchema, UIIntentSchema;
+var init_ui_intents = __esm(() => {
+  init_zod();
+  init_context();
+  init_envelope();
+  UIIntentType = {
+    SUBMIT_PROMPT: "submit_prompt",
+    STOP_SESSION: "stop_session",
+    RESUME_SESSION: "resume_session",
+    REQUEST_SESSIONS: "request_sessions",
+    REQUEST_SESSION_DETAIL: "request_session_detail",
+    CLEAR_SESSION: "clear_session",
+    WEBVIEW_READY: "webview_ready"
+  };
+  UIIntentTypeSchema = exports_external.enum(UIIntentType);
+  SubmitPromptIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.SUBMIT_PROMPT),
+    payload: exports_external.object({
+      text: exports_external.string().min(1),
+      context: ContextPayloadSchema.optional()
+    })
+  });
+  StopSessionIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.STOP_SESSION),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  ResumeSessionIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.RESUME_SESSION),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  RequestSessionsIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.REQUEST_SESSIONS),
+    payload: exports_external.object({}).optional()
+  });
+  RequestSessionDetailIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.REQUEST_SESSION_DETAIL),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  ClearSessionIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.CLEAR_SESSION),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  WebviewReadyIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.WEBVIEW_READY),
+    payload: exports_external.object({}).optional()
+  });
+  UIIntentSchema = exports_external.discriminatedUnion("type", [
+    SubmitPromptIntentSchema,
+    StopSessionIntentSchema,
+    ResumeSessionIntentSchema,
+    RequestSessionsIntentSchema,
+    RequestSessionDetailIntentSchema,
+    ClearSessionIntentSchema,
+    WebviewReadyIntentSchema
+  ]);
+});
+
+// ../shared/src/protocol/helpers.ts
+function createProtocolError(code, message, options) {
+  return {
+    code,
+    message,
+    details: options?.details,
+    recoverable: options?.recoverable ?? false
+  };
+}
+var init_helpers = __esm(() => {
+  init_envelope();
+  init_host_events();
+  init_session();
+  init_ui_intents();
+});
+
+// ../shared/src/protocol/index.ts
+var init_protocol = __esm(() => {
+  init_cli_stream();
+  init_context();
+  init_envelope();
+  init_errors3();
+  init_helpers();
+  init_host_events();
+  init_session();
+  init_ui_intents();
+});
+
 // ../shared/src/index.ts
 var init_src = __esm(() => {
   init_common();
   init_constants();
   init_enums();
   init_models();
+  init_protocol();
 });
 
 // ../sdk/src/modules/tasks.ts
@@ -38273,11 +38797,11 @@ ${line}`;
     writeFileSync3(this.progressPath, updated);
   }
   getFullContext() {
-    const context = this.readContext();
+    const context2 = this.readContext();
     const progress = this.readProgress();
     const parts = [];
-    if (context.trim()) {
-      parts.push(context.trim());
+    if (context2.trim()) {
+      parts.push(context2.trim());
     }
     if (progress.trim()) {
       parts.push(progress.trim());
@@ -38602,10 +39126,10 @@ ${task2.description || "No description provided."}
     let hasLocalContext = false;
     if (existsSync6(contextPath)) {
       try {
-        const context = readFileSync6(contextPath, "utf-8");
-        if (context.trim().length > 20) {
+        const context2 = readFileSync6(contextPath, "utf-8");
+        if (context2.trim().length > 20) {
           prompt += `## Project Context (Local)
-${context}
+${context2}
 
 `;
           hasLocalContext = true;
@@ -38735,10 +39259,10 @@ ${query}
     let hasLocalContext = false;
     if (existsSync6(contextPath)) {
       try {
-        const context = readFileSync6(contextPath, "utf-8");
-        if (context.trim().length > 20) {
+        const context2 = readFileSync6(contextPath, "utf-8");
+        if (context2.trim().length > 20) {
           prompt += `## Project Context (Local)
-${context}
+${context2}
 
 `;
           hasLocalContext = true;
@@ -39696,10 +40220,10 @@ class HistoryManager {
   getSessionPath(sessionId) {
     return join7(this.historyDir, `${sessionId}.json`);
   }
-  saveSession(session) {
-    const filePath = this.getSessionPath(session.id);
-    session.updatedAt = Date.now();
-    writeFileSync4(filePath, JSON.stringify(session, null, 2), "utf-8");
+  saveSession(session2) {
+    const filePath = this.getSessionPath(session2.id);
+    session2.updatedAt = Date.now();
+    writeFileSync4(filePath, JSON.stringify(session2, null, 2), "utf-8");
   }
   loadSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
@@ -39730,9 +40254,9 @@ class HistoryManager {
     let sessions = [];
     for (const file2 of files) {
       if (file2.endsWith(".json")) {
-        const session = this.loadSession(file2.replace(".json", ""));
-        if (session) {
-          sessions.push(session);
+        const session2 = this.loadSession(file2.replace(".json", ""));
+        if (session2) {
+          sessions.push(session2);
         }
       }
     }
@@ -39754,7 +40278,7 @@ class HistoryManager {
     }
     if (options.query) {
       const query = options.query.toLowerCase();
-      filtered = filtered.filter((session) => session.messages.some((msg) => msg.content.toLowerCase().includes(query)));
+      filtered = filtered.filter((session2) => session2.messages.some((msg) => msg.content.toLowerCase().includes(query)));
     }
     const offset = options.offset ?? 0;
     const limit = options.limit ?? filtered.length;
@@ -39790,8 +40314,8 @@ class HistoryManager {
     let deleted = 0;
     if (sessions.length > this.maxSessions) {
       const sessionsToDelete = sessions.slice(this.maxSessions);
-      for (const session of sessionsToDelete) {
-        if (this.deleteSession(session.id)) {
+      for (const session2 of sessionsToDelete) {
+        if (this.deleteSession(session2.id)) {
           deleted++;
         }
       }
@@ -40676,78 +41200,6 @@ var init_plan_manager = __esm(() => {
   init_sprint_plan();
 });
 
-// ../sdk/src/planning/agents/architect.ts
-function buildArchitectPrompt(input) {
-  let prompt = `# Role: Software Architect
-
-You are a Software Architect participating in an async sprint planning meeting. The Tech Lead has produced an initial task breakdown. Your job is to refine it.
-
-## CEO Directive
-> ${input.directive}
-`;
-  if (input.feedback) {
-    prompt += `
-## CEO Feedback on Previous Plan
-> ${input.feedback}
-
-IMPORTANT: Ensure the refined plan addresses this feedback.
-`;
-  }
-  prompt += `
-## Project Context
-${input.projectContext || "No project context available."}
-
-## Tech Lead's Task Breakdown
-${input.techLeadOutput}
-
-## Your Task
-
-Review and refine the Tech Lead's breakdown:
-
-1. **Ordering** — Order tasks so that foundational work comes first. Tasks that produce outputs consumed by later tasks must appear earlier in the list. Foundation tasks (schemas, config, shared code) must be listed before tasks that build on them. The array index IS the execution order.
-2. **Risk Assessment** — Flag tasks that are risky, underestimated, or have unknowns.
-3. **Task Merging** — If two tasks are trivially small and related, merge them.
-4. **Complexity Scoring** — Rate each task 1-5 (1=trivial, 5=very complex).
-5. **Missing Tasks** — Add any tasks the Tech Lead missed (database migrations, configuration, testing, etc.).
-6. **Description Quality** — Review and improve each task description to be a clear, actionable implementation guide. Each description must tell the executing agent exactly what to do, where to do it (specific files/modules), how to do it (patterns, utilities, data flow), and what is NOT in scope. Vague descriptions like "Add authentication" must be rewritten with specific file paths, implementation approach, and boundaries.
-
-## CRITICAL: Task Ordering & Dependencies
-
-Tasks are executed SEQUENTIALLY by a single agent on ONE branch. The agent works through tasks in array order. Each completed task's changes are available to subsequent tasks. You MUST enforce these rules:
-
-1. **Order tasks by dependency.** Foundation tasks (schemas, config, shared code) must come first. Tasks that build on earlier work must appear later in the list.
-2. **Each task must be self-contained for its scope.** A task can depend on earlier tasks (they run sequentially), but must include all changes needed for its own goal.
-3. **Split tasks at logical boundaries.** Since tasks run sequentially on the same branch, splitting is safe — later tasks see earlier changes. Split when it improves clarity and reviewability.
-4. **Flag risks.** In your risk assessment, call out tasks that are complex or have unknowns.
-
-## Output Format
-
-Your entire response must be a single JSON object — no text before it, no text after it, no markdown code blocks, no explanation. Start your response with the "{" character:
-
-{
-  "tasks": [
-    {
-      "title": "string",
-      "description": "string (detailed implementation guide: what to do, where to do it, how to do it, and boundaries)",
-      "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
-      "priority": "HIGH | MEDIUM | LOW | CRITICAL",
-      "labels": ["string"],
-      "acceptanceCriteria": ["string"],
-      "complexity": 3
-    }
-  ],
-  "risks": [
-    {
-      "description": "string",
-      "mitigation": "string",
-      "severity": "low | medium | high"
-    }
-  ],
-  "architectureNotes": "string (notes for the Sprint Organizer about parallelism opportunities and constraints)"
-}`;
-  return prompt;
-}
-
 // ../sdk/src/planning/agents/cross-task-reviewer.ts
 function buildCrossTaskReviewerPrompt(input) {
   let prompt = `# Role: Cross-Task Reviewer (Architect + Engineer + Planner)
@@ -40783,7 +41235,7 @@ IMPORTANT: Ensure the reviewed plan still addresses this feedback.
 ${input.projectContext || "No project context available."}
 
 ## Sprint Plan to Review
-${input.sprintOrganizerOutput}
+${input.plannerOutput}
 
 ## Your Review Checklist
 
@@ -40862,11 +41314,11 @@ IMPORTANT:
   return prompt;
 }
 
-// ../sdk/src/planning/agents/sprint-organizer.ts
-function buildSprintOrganizerPrompt(input) {
-  let prompt = `# Role: Sprint Organizer
+// ../sdk/src/planning/agents/planner.ts
+function buildPlannerPrompt(input) {
+  let prompt = `# Role: Sprint Planner
 
-You are a Sprint Organizer finalizing the sprint plan from a planning meeting. The Architect has refined the task breakdown. Your job is to produce the final sprint plan document.
+You are a Sprint Planner — an expert engineer, architect, and project organizer rolled into one. Your job is to take a CEO directive and produce a complete, ready-to-execute sprint plan in a single pass.
 
 ## CEO Directive
 > ${input.directive}
@@ -40876,40 +41328,64 @@ You are a Sprint Organizer finalizing the sprint plan from a planning meeting. T
 ## CEO Feedback on Previous Plan
 > ${input.feedback}
 
-IMPORTANT: The final plan must address this feedback.
+IMPORTANT: Incorporate this feedback into your plan. The CEO has reviewed a previous plan and wants changes.
 `;
   }
   prompt += `
-## Architect's Refined Task Breakdown
-${input.architectOutput}
+## Project Context
+${input.projectContext || "No project context available."}
+
+## Codebase Structure
+${input.codebaseIndex || "No codebase index available."}
 
 ## Your Task
 
-Produce the final sprint plan:
+Analyze the directive and produce a **complete sprint plan** with the following:
 
-1. **Sprint Name** — A concise, memorable name for this sprint (e.g., "User Authentication", "Payment Integration")
+1. **Sprint Name** — A concise, memorable name (2-4 words)
 2. **Sprint Goal** — One paragraph describing what this sprint delivers
-3. **Task Ordering** — Final ordering so that foundational work comes first. The position in the array IS the execution order — task at index 0 runs first, index 1 runs second, etc. Tasks are executed SEQUENTIALLY by a single agent on one branch.
-4. **Duration Estimate** — How many days this sprint will take with a single agent working sequentially
-5. **Final Task List** — Each task with all fields filled in, ordered by execution priority
-6. **Description Quality Check** — Ensure every task description is a clear, actionable implementation guide. Each description must specify: what to do, where to do it (specific files/modules/directories), how to do it (implementation approach, patterns to follow, existing utilities to use), and what is NOT in scope. If any description is vague or generic, rewrite it with specifics. Remember: an independent agent will receive ONLY the task title, description, and acceptance criteria — the description is its primary instruction.
-
-Guidelines:
-- The order of tasks in the array determines execution order. Tasks are dispatched sequentially from first to last.
-- Foundation tasks (schemas, config, shared code) must appear before tasks that build on them
-- Since tasks execute sequentially on one branch, later tasks can depend on earlier tasks' outputs
-- Ensure acceptance criteria are specific and testable
-- Keep the sprint focused — if it's too large (>12 tasks), consider reducing scope
-- Ensure every task description reads as a standalone implementation brief — not a summary
+3. **Duration Estimate** — How many days this sprint will take with a single agent working sequentially
+4. **Task Breakdown** — An ordered list of tasks that fully implement the directive
+5. **Risk Assessment** — Potential risks with mitigations
+
+### Task Requirements
+
+For each task, provide:
+- **Title** — Clear, action-oriented (e.g., "Implement user registration API endpoint")
+- **Description** — A detailed, actionable implementation guide (see below)
+- **Assignee Role** — BACKEND, FRONTEND, QA, PM, or DESIGN
+- **Priority** — CRITICAL, HIGH, MEDIUM, or LOW
+- **Complexity** — 1 (trivial) to 5 (very complex)
+- **Labels** — Relevant tags (e.g., "api", "database", "ui", "auth")
+- **Acceptance Criteria** — Specific, testable conditions for completion
 
-## CRITICAL: Task Ordering Validation
+### CRITICAL: Task Description Requirements
 
-Before finalizing, validate that tasks are in the correct execution order:
+Each task description will be handed to an INDEPENDENT agent as its primary instruction. The agent will have access to the codebase but NO context about the planning meeting. Each description MUST include:
 
-1. **No forward dependencies.** A task must NOT depend on a task that appears later in the list.
-2. **Foundation first.** Config, schemas, and shared code must come before implementation tasks.
-3. **Each task is independently executable given prior tasks.** An agent working on task N must be able to complete it assuming tasks 1 through N-1 are already done.
-4. **Prefer focused, well-scoped tasks.** Each task should do one logical unit of work.
+1. **What to do** — Clearly state the goal and expected behavior/outcome
+2. **Where to do it** — List specific files, modules, or directories to modify or create. Reference existing code paths when extending functionality
+3. **How to do it** — Key implementation details: which patterns to follow, which existing utilities or services to use, what the data flow looks like
+4. **Boundaries** — What is NOT in scope for this task to prevent overlap with other tasks
+
+Bad example: "Add authentication to the API."
+Good example: "Implement JWT-based authentication middleware in src/middleware/auth.ts. Create a verifyToken middleware that extracts the Bearer token from the Authorization header, validates it using the existing JWT_SECRET from env config, and attaches the decoded user payload to req.user. Apply this middleware to all routes in src/routes/protected/. This task does NOT include user registration or password reset — those are handled separately."
+
+### CRITICAL: Task Ordering Rules
+
+Tasks are executed SEQUENTIALLY by a single agent on ONE branch. The agent works through tasks in array order. Therefore:
+
+1. **Foundation first.** Place foundational tasks (schemas, config, shared code) at the beginning. Later tasks can build on earlier ones since they run in sequence.
+2. **No forward dependencies.** A task must NOT depend on a task that appears later in the list.
+3. **Each task is self-contained for its scope.** A task can depend on earlier tasks but must include all changes needed for its own goal.
+4. **Keep tasks focused.** Each task should do one logical unit of work. Avoid trivially small or overly large tasks.
+5. **Merge related trivial work.** If two pieces of work are trivially small and tightly related, combine them into one task.
+
+### Sprint Scope Guidelines
+
+- If the sprint would exceed 12 tasks, reduce scope or merge related tasks
+- Ensure acceptance criteria are specific and testable
+- Keep the sprint focused on the directive — avoid scope creep
 
 ## Output Format
 
@@ -40922,7 +41398,7 @@ Your entire response must be a single JSON object — no text before it, no text
   "tasks": [
     {
       "title": "string",
-      "description": "string (detailed implementation guide: what to do, where to do it, how to do it, and boundaries)",
+      "description": "string (detailed implementation guide: what, where, how, boundaries)",
       "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
       "priority": "CRITICAL | HIGH | MEDIUM | LOW",
       "labels": ["string"],
@@ -40943,89 +41419,6 @@ IMPORTANT: Tasks are executed sequentially by a single agent. The array order IS
   return prompt;
 }
 
-// ../sdk/src/planning/agents/tech-lead.ts
-function buildTechLeadPrompt(input) {
-  let prompt = `# Role: Senior Tech Lead
-
-You are a Senior Tech Lead participating in an async sprint planning meeting. Your job is to take the CEO's directive and produce an initial task breakdown.
-
-## CEO Directive
-> ${input.directive}
-`;
-  if (input.feedback) {
-    prompt += `
-## CEO Feedback on Previous Plan
-> ${input.feedback}
-
-IMPORTANT: Incorporate this feedback into your task breakdown. The CEO has reviewed a previous plan and wants changes.
-`;
-  }
-  prompt += `
-## Project Context
-${input.projectContext || "No project context available."}
-
-## Codebase Structure
-${input.codebaseIndex || "No codebase index available."}
-
-## Your Task
-
-Analyze the CEO's directive and produce a detailed task breakdown. For each task:
-
-1. **Title** — Clear, action-oriented (e.g., "Implement user registration API endpoint")
-2. **Description** — A detailed, actionable implementation guide (see description requirements below)
-3. **Assignee Role** — Who should work on this: BACKEND, FRONTEND, QA, PM, or DESIGN
-4. **Priority** — HIGH, MEDIUM, or LOW based on business impact
-5. **Labels** — Relevant tags (e.g., "api", "database", "ui", "auth")
-6. **Acceptance Criteria** — Specific, testable conditions for completion
-
-Think about:
-- What existing code can be reused or extended
-- Which tasks are independent vs. dependent
-- What the right granularity is (not too big, not too small)
-- What risks or unknowns exist
-
-## CRITICAL: Task Description Requirements
-
-Each task description will be handed to an INDEPENDENT agent as its primary instruction. The agent will have access to the codebase but NO context about the planning meeting. Descriptions must be clear enough for the agent to execute the task without ambiguity.
-
-Each description MUST include:
-1. **What to do** — Clearly state the goal and what needs to be implemented, changed, or created. Be specific about the expected behavior or outcome.
-2. **Where to do it** — List the specific files, modules, or directories that need to be modified or created. Reference existing code paths when extending functionality.
-3. **How to do it** — Provide key implementation details: which patterns to follow, which existing utilities or services to use, what the data flow looks like.
-4. **Boundaries** — Clarify what is NOT in scope for this task to prevent overlap with other tasks.
-
-Bad example: "Add authentication to the API."
-Good example: "Implement JWT-based authentication middleware in src/middleware/auth.ts. Create a verifyToken middleware that extracts the Bearer token from the Authorization header, validates it using the existing JWT_SECRET from env config, and attaches the decoded user payload to req.user. Apply this middleware to all routes in src/routes/protected/. Add a POST /auth/login endpoint in src/routes/auth.ts that accepts {email, password}, validates credentials against the users table, and returns a signed JWT. This task does NOT include user registration or password reset — those are handled separately."
-
-## CRITICAL: Task Ordering Rules
-
-Tasks are executed SEQUENTIALLY by a single agent on ONE branch. The agent works through tasks in the order they appear in the array. Therefore:
-
-1. **Foundation first.** Place foundational tasks (schemas, config, shared code) at the beginning of the list. Later tasks can build on earlier ones since they run in sequence on the same branch.
-2. **Each task must be self-contained.** A task must include ALL the code changes it needs to work — from config to implementation to tests. A task CAN depend on earlier tasks in the list since they will have already been completed.
-3. **Logical ordering matters.** Tasks are dispatched in the order they appear. Ensure dependent tasks come after their prerequisites.
-4. **Keep tasks focused.** Each task should do one logical unit of work. Since there are no parallel execution conflicts, tasks can be more granular — but avoid tasks that are too small or trivial.
-
-## Output Format
-
-Your entire response must be a single JSON object — no text before it, no text after it, no markdown code blocks, no explanation. Start your response with the "{" character:
-
-{
-  "tasks": [
-    {
-      "title": "string",
-      "description": "string (detailed implementation guide: what to do, where to do it, how to do it, and boundaries — see description requirements above)",
-      "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
-      "priority": "HIGH | MEDIUM | LOW",
-      "labels": ["string"],
-      "acceptanceCriteria": ["string"]
-    }
-  ],
-  "technicalNotes": "string (brief notes on architecture decisions, risks, or considerations for the Architect phase)"
-}`;
-  return prompt;
-}
-
 // ../sdk/src/planning/planning-meeting.ts
 import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
 
@@ -41043,52 +41436,33 @@ class PlanningMeeting {
   async run(directive, feedback) {
     const projectContext = this.getProjectContext();
     const codebaseIndex = this.getCodebaseIndex();
-    this.log("Phase 1/4: Tech Lead analyzing directive...", "info");
-    const techLeadPrompt = buildTechLeadPrompt({
+    this.log("Phase 1/2: Planner building sprint plan...", "info");
+    const plannerPrompt = buildPlannerPrompt({
       directive,
       projectContext,
       codebaseIndex,
       feedback
     });
-    const techLeadOutput = await this.aiRunner.run(techLeadPrompt);
-    this.log("Tech Lead phase complete.", "success");
-    this.log("Phase 2/4: Architect refining task breakdown...", "info");
-    const architectPrompt = buildArchitectPrompt({
-      directive,
-      projectContext,
-      techLeadOutput,
-      feedback
-    });
-    const architectOutput = await this.aiRunner.run(architectPrompt);
-    this.log("Architect phase complete.", "success");
-    this.log("Phase 3/4: Sprint Organizer finalizing plan...", "info");
-    const sprintOrganizerPrompt = buildSprintOrganizerPrompt({
-      directive,
-      architectOutput,
-      feedback
-    });
-    const sprintOrganizerOutput = await this.aiRunner.run(sprintOrganizerPrompt);
-    this.log("Sprint Organizer phase complete.", "success");
-    this.log("Phase 4/4: Cross-Task Review checking for conflicts and overlaps...", "info");
+    const plannerOutput = await this.aiRunner.run(plannerPrompt);
+    this.log("Planner phase complete.", "success");
+    this.log("Phase 2/2: Reviewer checking for conflicts and quality...", "info");
     const crossTaskReviewerPrompt = buildCrossTaskReviewerPrompt({
       directive,
       projectContext,
-      sprintOrganizerOutput,
+      plannerOutput,
       feedback
     });
-    const crossTaskReviewOutput = await this.aiRunner.run(crossTaskReviewerPrompt);
-    this.log("Cross-Task Review phase complete.", "success");
-    const plan = parseSprintPlanFromAI(crossTaskReviewOutput, directive);
+    const reviewOutput = await this.aiRunner.run(crossTaskReviewerPrompt);
+    this.log("Review phase complete.", "success");
+    const plan = parseSprintPlanFromAI(reviewOutput, directive);
     if (feedback) {
       plan.feedback = feedback;
     }
     return {
       plan,
       phaseOutputs: {
-        techLead: techLeadOutput,
-        architect: architectOutput,
-        sprintOrganizer: sprintOrganizerOutput,
-        crossTaskReview: crossTaskReviewOutput
+        planner: plannerOutput,
+        review: reviewOutput
       }
     };
   }
@@ -41864,8 +42238,8 @@ function showHelp() {
   ${c.dim("Any other input will be sent as a prompt to the AI.")}
 `);
 }
-function showHistory(session, args) {
-  const historyManager = session.getHistoryManager();
+function showHistory(session2, args) {
+  const historyManager = session2.getHistoryManager();
   const limit = args ? parseInt(args, 10) : 10;
   const sessions = historyManager.listSessions({
     limit: Number.isNaN(limit) ? 10 : limit
@@ -41884,7 +42258,7 @@ function showHistory(session, args) {
     const dateStr = date5.toLocaleDateString();
     const timeStr = date5.toLocaleTimeString();
     const msgCount = sess.messages.length;
-    const isCurrent = sess.id === session.getSessionId();
+    const isCurrent = sess.id === session2.getSessionId();
     const marker = isCurrent ? c.success("*") : " ";
     console.log(`  ${marker} ${c.cyan(sess.id)} ${c.dim(`- ${dateStr} ${timeStr} (${msgCount} messages)`)}`);
     if (sess.messages.length > 0) {
@@ -41905,7 +42279,7 @@ var init_commands = __esm(() => {
       name: "exit",
       aliases: ["quit", "q"],
       description: "Exit interactive mode",
-      execute: (session) => session.shutdown()
+      execute: (session2) => session2.shutdown()
     },
     {
       name: "clear",
@@ -41923,21 +42297,21 @@ var init_commands = __esm(() => {
       name: "reset",
       aliases: ["r"],
       description: "Reset conversation context",
-      execute: (session) => session.resetContext()
+      execute: (session2) => session2.resetContext()
     },
     {
       name: "history",
       aliases: ["hist"],
       description: "List recent sessions",
-      execute: (session, args) => showHistory(session, args)
+      execute: (session2, args) => showHistory(session2, args)
     },
     {
       name: "session",
       aliases: ["sid"],
       description: "Show current session ID",
-      execute: (session) => {
+      execute: (session2) => {
         console.log(`
-  ${c.dim("Session ID:")} ${c.cyan(session.getSessionId())}
+  ${c.dim("Session ID:")} ${c.cyan(session2.getSessionId())}
 `);
       }
     }
@@ -43030,9 +43404,137 @@ function showDocsSyncHelp() {
 }
 // src/commands/exec.ts
 init_index_node();
-init_progress_renderer();
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { parseArgs as parseArgs2 } from "node:util";
 
+// src/display/json-stream-renderer.ts
+init_src();
+
+class JsonStreamRenderer {
+  sessionId;
+  command;
+  model;
+  provider;
+  cwd;
+  statsTracker;
+  started = false;
+  done = false;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.command = options.command;
+    this.model = options.model;
+    this.provider = options.provider;
+    this.cwd = options.cwd;
+    this.statsTracker = new ExecutionStatsTracker;
+  }
+  emitStart() {
+    if (this.started)
+      return;
+    this.started = true;
+    this.emit(createCliStreamEvent(CliStreamEventType.START, this.sessionId, {
+      command: this.command,
+      model: this.model,
+      provider: this.provider,
+      cwd: this.cwd
+    }));
+  }
+  handleChunk(chunk) {
+    this.ensureStarted();
+    switch (chunk.type) {
+      case "text_delta":
+        this.emit(createCliStreamEvent(CliStreamEventType.TEXT_DELTA, this.sessionId, {
+          content: chunk.content
+        }));
+        break;
+      case "thinking":
+        this.emit(createCliStreamEvent(CliStreamEventType.THINKING, this.sessionId, {
+          content: chunk.content
+        }));
+        break;
+      case "tool_use":
+        this.statsTracker.toolStarted(chunk.tool, chunk.id);
+        this.emit(createCliStreamEvent(CliStreamEventType.TOOL_STARTED, this.sessionId, {
+          tool: chunk.tool,
+          toolId: chunk.id,
+          parameters: chunk.parameters
+        }));
+        break;
+      case "tool_result":
+        if (chunk.success) {
+          this.statsTracker.toolCompleted(chunk.tool, chunk.id);
+        } else {
+          this.statsTracker.toolFailed(chunk.tool, chunk.error ?? "Unknown error", chunk.id);
+        }
+        this.emit(createCliStreamEvent(CliStreamEventType.TOOL_COMPLETED, this.sessionId, {
+          tool: chunk.tool,
+          toolId: chunk.id,
+          success: chunk.success,
+          duration: chunk.duration,
+          error: chunk.error
+        }));
+        break;
+      case "tool_parameters":
+        break;
+      case "result":
+        break;
+      case "error":
+        this.statsTracker.setError(chunk.error);
+        this.emitError("UNKNOWN", chunk.error);
+        break;
+    }
+  }
+  emitStatus(status, message) {
+    this.ensureStarted();
+    this.emit(createCliStreamEvent(CliStreamEventType.STATUS, this.sessionId, {
+      status,
+      message
+    }));
+  }
+  emitError(code, message, options) {
+    this.ensureStarted();
+    this.emit(createCliStreamEvent(CliStreamEventType.ERROR, this.sessionId, {
+      error: createProtocolError(code, message, options)
+    }));
+  }
+  emitDone(exitCode) {
+    if (this.done)
+      return;
+    this.done = true;
+    this.ensureStarted();
+    const stats = this.statsTracker.finalize();
+    this.emit(createCliStreamEvent(CliStreamEventType.DONE, this.sessionId, {
+      exitCode,
+      duration: stats.duration,
+      toolsUsed: stats.toolsUsed.length > 0 ? stats.toolsUsed : undefined,
+      tokensUsed: stats.tokensUsed,
+      success: exitCode === 0
+    }));
+  }
+  emitFatalError(code, message, options) {
+    this.statsTracker.setError(message);
+    this.emitError(code, message, {
+      ...options,
+      recoverable: false
+    });
+    this.emitDone(1);
+  }
+  isDone() {
+    return this.done;
+  }
+  ensureStarted() {
+    if (!this.started) {
+      this.emitStart();
+    }
+  }
+  emit(event) {
+    process.stdout.write(`${JSON.stringify(event)}
+`);
+  }
+}
+
+// src/commands/exec.ts
+init_progress_renderer();
+
 // src/commands/exec-sessions.ts
 init_index_node();
 function formatRelativeTime(timestamp) {
@@ -43070,11 +43572,11 @@ class SessionCommands {
     console.log(`
   ${c.primary("Recent Exec Sessions:")}
 `);
-    for (const session of sessions.slice(0, 10)) {
-      const shortId = this.getShortId(session.id);
-      const age = formatRelativeTime(session.updatedAt);
-      const msgCount = session.messages.length;
-      const firstUserMsg = session.messages.find((m) => m.role === "user");
+    for (const session2 of sessions.slice(0, 10)) {
+      const shortId = this.getShortId(session2.id);
+      const age = formatRelativeTime(session2.updatedAt);
+      const msgCount = session2.messages.length;
+      const firstUserMsg = session2.messages.find((m) => m.role === "user");
       const preview = firstUserMsg ? firstUserMsg.content.slice(0, 50).replace(/\n/g, " ") : "(empty session)";
       console.log(`  ${c.cyan(shortId)} ${c.gray("-")} ${preview}${firstUserMsg && firstUserMsg.content.length > 50 ? "..." : ""}`);
       console.log(`    ${c.dim(`${msgCount} messages • ${age}`)}`);
@@ -43094,8 +43596,8 @@ class SessionCommands {
 `);
       return;
     }
-    const session = this.historyManager.findSessionByPartialId(sessionId);
-    if (!session) {
+    const session2 = this.historyManager.findSessionByPartialId(sessionId);
+    if (!session2) {
       console.error(`
   ${c.error("Error:")} Session ${c.cyan(sessionId)} not found
 `);
@@ -43104,18 +43606,18 @@ class SessionCommands {
       return;
     }
     console.log(`
-  ${c.primary("Session:")} ${c.cyan(session.id)}`);
-    console.log(`  ${c.dim(`Created: ${new Date(session.createdAt).toLocaleString()}`)}`);
-    console.log(`  ${c.dim(`Model: ${session.metadata.model} (${session.metadata.provider})`)}
+  ${c.primary("Session:")} ${c.cyan(session2.id)}`);
+    console.log(`  ${c.dim(`Created: ${new Date(session2.createdAt).toLocaleString()}`)}`);
+    console.log(`  ${c.dim(`Model: ${session2.metadata.model} (${session2.metadata.provider})`)}
 `);
-    if (session.messages.length === 0) {
+    if (session2.messages.length === 0) {
       console.log(`  ${c.dim("(No messages in this session)")}
 `);
       return;
     }
     console.log(c.dim("  ─".repeat(30)));
     console.log();
-    for (const message of session.messages) {
+    for (const message of session2.messages) {
       const role = message.role === "user" ? c.cyan("You") : c.green("AI");
       const content = message.content;
       console.log(`  ${role}:`);
@@ -43136,17 +43638,17 @@ class SessionCommands {
 `);
       return;
     }
-    const session = this.historyManager.findSessionByPartialId(sessionId);
-    if (!session) {
+    const session2 = this.historyManager.findSessionByPartialId(sessionId);
+    if (!session2) {
       console.error(`
   ${c.error("Error:")} Session ${c.cyan(sessionId)} not found
 `);
       return;
     }
-    const deleted = this.historyManager.deleteSession(session.id);
+    const deleted = this.historyManager.deleteSession(session2.id);
     if (deleted) {
       console.log(`
-  ${c.success("✔")} Deleted session ${c.cyan(this.getShortId(session.id))}
+  ${c.success("✔")} Deleted session ${c.cyan(this.getShortId(session2.id))}
 `);
     } else {
       console.error(`
@@ -43206,11 +43708,17 @@ async function execCommand(args) {
       "no-stream": { type: "boolean" },
       "no-status": { type: "boolean" },
       interactive: { type: "boolean", short: "i" },
-      session: { type: "string", short: "s" }
+      session: { type: "string", short: "s" },
+      "json-stream": { type: "boolean" }
     },
     strict: false
   });
+  const jsonStream = values["json-stream"];
   const projectPath = values.dir || process.cwd();
+  if (jsonStream) {
+    await execJsonStream(values, positionals, projectPath);
+    return;
+  }
   requireInitialization(projectPath, "exec");
   if (positionals[0] === "sessions") {
     const sessionAction = positionals[1];
@@ -43241,13 +43749,13 @@ async function execCommand(args) {
   const sessionId = values.session;
   if (isInteractive) {
     const { InteractiveSession: InteractiveSession2 } = await Promise.resolve().then(() => (init_interactive_session(), exports_interactive_session));
-    const session = new InteractiveSession2({
+    const session2 = new InteractiveSession2({
       projectPath,
       provider,
       model,
       sessionId
     });
-    await session.start();
+    await session2.start();
     return;
   }
   const promptInput = positionals.join(" ");
@@ -43338,6 +43846,67 @@ async function execCommand(args) {
     process.exit(1);
   }
 }
+async function execJsonStream(values, positionals, projectPath) {
+  const sessionId = values.session ?? randomUUID2();
+  const execSettings = new SettingsManager(projectPath).load();
+  const provider = resolveProvider3(values.provider || execSettings.provider);
+  const model = values.model || execSettings.model || DEFAULT_MODEL[provider];
+  const renderer = new JsonStreamRenderer({
+    sessionId,
+    command: "exec",
+    model,
+    provider,
+    cwd: projectPath
+  });
+  const handleSignal = () => {
+    if (!renderer.isDone()) {
+      renderer.emitFatalError("PROCESS_CRASHED", "Process terminated by signal");
+    }
+    process.exit(1);
+  };
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+  try {
+    try {
+      requireInitialization(projectPath, "exec");
+    } catch (initError) {
+      renderer.emitFatalError("CLI_NOT_FOUND", initError instanceof Error ? initError.message : String(initError));
+      process.exit(1);
+    }
+    const promptInput = positionals.join(" ");
+    if (!promptInput) {
+      renderer.emitFatalError("UNKNOWN", 'Prompt is required. Usage: locus exec --json-stream "your prompt"');
+      process.exit(1);
+    }
+    renderer.emitStart();
+    renderer.emitStatus("running", "Building prompt context");
+    const aiRunner = createAiRunner(provider, {
+      projectPath,
+      model
+    });
+    const builder = new PromptBuilder(projectPath);
+    const fullPrompt = await builder.buildGenericPrompt(promptInput);
+    renderer.emitStatus("streaming", "Streaming AI response");
+    const stream4 = aiRunner.runStream(fullPrompt);
+    for await (const chunk of stream4) {
+      renderer.handleChunk(chunk);
+    }
+    try {
+      const knowledgeBase = new KnowledgeBase(projectPath);
+      knowledgeBase.updateProgress({
+        role: "user",
+        content: promptInput
+      });
+    } catch {}
+    renderer.emitDone(0);
+  } catch (error48) {
+    const message = error48 instanceof Error ? error48.message : String(error48);
+    if (!renderer.isDone()) {
+      renderer.emitFatalError("UNKNOWN", message);
+    }
+    process.exit(1);
+  }
+}
 // src/commands/help.ts
 init_index_node();
 function showHelp2() {
@@ -43527,12 +44096,7 @@ async function initCommand() {
 init_index_node();
 import { parseArgs as parseArgs4 } from "node:util";
 function normalizePlanIdArgs(args) {
-  const planIdFlags = new Set([
-    "--approve",
-    "--reject",
-    "--cancel",
-    "--show"
-  ]);
+  const planIdFlags = new Set(["--approve", "--reject", "--cancel", "--show"]);
   const result = [];
   let i = 0;
   while (i < args.length) {
@@ -44459,10 +45023,11 @@ function versionCommand() {
   console.log("");
 }
 // src/cli.ts
+var isJsonStream = process.argv.includes("--json-stream");
 async function main() {
   const command = process.argv[2];
   const args = process.argv.slice(3);
-  if (command !== "exec") {
+  if (command !== "exec" && !isJsonStream) {
     printBanner();
   }
   switch (command) {
@@ -44506,6 +45071,11 @@ async function main() {
   }
 }
 main().catch((err) => {
+  if (isJsonStream) {
+    process.stderr.write(`${JSON.stringify({ fatal: true, error: err.message })}
+`);
+    process.exit(1);
+  }
   console.error(`
   ${c.error("✖ Fatal Error")} ${c.red(err.message)}`);
   process.exit(1);