@agentdock/agent-runtime-core 0.0.97

package/dist/sessionStatsCollector.d.ts

@@ -0,0 +1,20 @@
+import type { AgentMessage } from './acpTypes.js';
+import type { StatsAccumulator } from './statsAccumulator.js';
+import type { Logger } from './logger.js';
+
+export interface SessionStatsCollectorOptions {
+    readonly accumulator: StatsAccumulator;
+    readonly logger?: Logger;
+}
+
+export interface SessionStatsCollector {
+    
+    trackSession(sessionId: string, agentType: string, cwd: string): void;
+    
+    onMessage(sessionId: string, msg: AgentMessage): void;
+    
+    endSession(sessionId: string): void;
+    
+    readonly dataPointCount: number;
+}
+export declare function createSessionStatsCollector(opts: SessionStatsCollectorOptions): SessionStatsCollector;

package/dist/sessionStatsCollector.js

@@ -0,0 +1 @@
+"use strict";export function createSessionStatsCollector(l){const{accumulator:s}=l,c=l.logger,a=new Map;let u=0;function p(o,e,t){a.set(o,{agentType:e,cwd:t,sessionId:o,toolCallCount:0}),c?.debug({sessionId:o,agentType:e,module:"daemon:usage"},"tracking session for stats")}function r(o,e){const t=a.get(o);if(t){if(e.type==="usage"){const n={model:e.model??`${t.agentType}-unknown`,inputTokens:e.inputTokens,outputTokens:e.outputTokens,cacheReadInputTokens:e.cacheReadTokens,cacheCreationInputTokens:e.cacheWriteTokens,timestamp:new Date().toISOString(),filePath:`session:${o}`,projectDir:t.cwd,toolCallCount:t.toolCallCount,agentType:t.agentType};n.inputTokens+n.outputTokens>0&&(s.addMessage(n),u++,t.toolCallCount=0)}if(e.type==="result"){const n=e.inputTokens??0,i=e.outputTokens??0;if(n+i>0){const C={model:`${t.agentType}-unknown`,inputTokens:n,outputTokens:i,cacheReadInputTokens:0,cacheCreationInputTokens:0,timestamp:new Date().toISOString(),filePath:`session:${o}`,projectDir:t.cwd,toolCallCount:t.toolCallCount,agentType:t.agentType};s.addMessage(C),u++,t.toolCallCount=0}}e.type==="tool-call"&&t.toolCallCount++}}function k(o){a.delete(o),c?.debug({sessionId:o,module:"daemon:usage"},"stopped tracking session for stats")}return{trackSession:p,onMessage:r,endSession:k,get dataPointCount(){return u}}}

package/dist/shellSanitizer.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeShell(shell: string | undefined): string;

package/dist/shellSanitizer.js

@@ -0,0 +1 @@
+"use strict";const i=new Set(["/bin/zsh","/bin/bash","/bin/sh","/usr/bin/zsh","/usr/bin/bash","/usr/bin/fish","/usr/bin/nu"]);export function sanitizeShell(n){return n?/^[A-Z]:\\Windows\\/i.test(n)||n.startsWith("/bin/")||n.startsWith("/usr/bin/")||i.has(n)?n:"custom":"unknown"}

package/dist/shutdownHelper.d.ts

@@ -0,0 +1,24 @@
+export interface SessionInfo {
+    readonly pid: number;
+    readonly sessionId: string;
+    readonly agent: string;
+}
+
+export declare const PROCESS_EXIT_TIMEOUT_MS = 5000;
+
+export declare function isAlive(pid: number): boolean;
+
+export declare function waitForExit(pid: number, timeoutMs: number): Promise<boolean>;
+
+export declare function stopLocalDaemon(pid: number, state: {
+    readonly httpPort: number;
+    readonly authToken?: string;
+} | null, onStatus?: (msg: string) => void): Promise<boolean>;
+
+export declare function fetchSessions(port: number, authToken: string): Promise<readonly SessionInfo[]>;
+
+export declare function stopSession(port: number, authToken: string, sessionId: string): Promise<boolean>;
+
+export declare function stopDaemonHttp(port: number, authToken: string): Promise<void>;
+
+export declare function forceStopAllSessions(port: number, authToken: string, onStatus?: (msg: string) => void): Promise<void>;

package/dist/shutdownHelper.js

@@ -0,0 +1 @@
+"use strict";export const PROCESS_EXIT_TIMEOUT_MS=5e3;export function isAlive(t){try{return process.kill(t,0),!0}catch{return!1}}export async function waitForExit(t,e){const o=Date.now();for(;Date.now()-o<e;){if(!isAlive(t))return!0;await new Promise(s=>setTimeout(s,200))}try{process.kill(t,"SIGKILL")}catch{}return await new Promise(s=>setTimeout(s,200)),!isAlive(t)}export async function stopLocalDaemon(t,e,o){if(e?.authToken)await forceStopAllSessions(e.httpPort,e.authToken,o),await stopDaemonHttp(e.httpPort,e.authToken);else try{process.kill(t,"SIGTERM")}catch{}return waitForExit(t,5e3)}export async function fetchSessions(t,e){try{const o=await fetch(`http://127.0.0.1:${t}/sessions`,{headers:{Authorization:`Bearer ${e}`}});return o.ok?(await o.json()).sessions??[]:[]}catch{return[]}}export async function stopSession(t,e,o){try{return(await(await fetch(`http://127.0.0.1:${t}/rpc`,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${e}`},body:JSON.stringify({method:"stop-session",params:{sessionId:o}})})).json()).ok}catch{return!1}}export async function stopDaemonHttp(t,e){try{await fetch(`http://127.0.0.1:${t}/stop`,{method:"POST",headers:{Authorization:`Bearer ${e}`}})}catch{}}export async function forceStopAllSessions(t,e,o){const s=await fetchSessions(t,e);if(s.length!==0){o?.(`Stopping ${s.length} active session(s)...`);for(const n of s)await stopSession(t,e,n.sessionId),await waitForExit(n.pid,5e3),o?.(`${n.agent} (PID: ${n.pid}) stopped`)}}

package/dist/skillCache.d.ts

@@ -0,0 +1,4 @@
+import type { SkillDefinition } from '@agentdock/wire';
+export declare function discoverSkillsWithCache(projectCwds: readonly string[]): Record<string, SkillDefinition[]> | undefined;
+
+export declare function clearSkillCache(): void;

package/dist/skillCache.js

@@ -0,0 +1 @@
+"use strict";import{discoverSkills as i}from"./skillParser.js";let e=null,l=0;const r=6e4;export function discoverSkillsWithCache(c){const n=Date.now();if(e&&n-l<r)return e;try{const t=i(c);if(Object.keys(t).length>0)return e=t,l=n,t}catch{}return e??void 0}export function clearSkillCache(){e=null,l=0}

package/dist/skillParser.d.ts

@@ -0,0 +1,20 @@
+export interface ParsedSkill {
+    name: string;
+    description: string;
+    userInvocable: boolean;
+}
+
+export declare const AGENT_SKILL_DIRS: Record<string, {
+    user: () => readonly string[];
+    project: (cwd: string) => readonly string[];
+}>;
+
+export declare function parseSkillMd(filePath: string): ParsedSkill | null;
+
+export declare function discoverSkills(projectCwds: readonly string[]): Record<string, {
+    name: string;
+    description: string;
+    userInvocable: boolean;
+    source: 'project' | 'user';
+    projectPath?: string;
+}[]>;

package/dist/skillParser.js

@@ -0,0 +1,6 @@
+"use strict";import f from"node:os";import t from"node:path";import{readFileSync as j,readdirSync as g,existsSync as S}from"node:fs";const b=new Set(["SKILL.md","skill.md"]);export const AGENT_SKILL_DIRS={claude:{user:()=>[t.join(f.homedir(),".claude","skills")],project:e=>[t.join(e,".claude","skills")]},hermes:{user:()=>[t.join(f.homedir(),".hermes","skills")],project:()=>[]},copilot:{user:()=>[t.join(f.homedir(),".copilot","skills")],project:e=>[t.join(e,".github","skills")]},gemini:{user:()=>[t.join(f.homedir(),".gemini","skills")],project:e=>[t.join(e,".gemini","skills")]},opencode:{user:()=>[t.join(f.homedir(),".config","opencode","skills")],project:e=>[t.join(e,".opencode","skills")]},openclaw:{user:()=>[t.join(f.homedir(),".openclaw","skills")],project:e=>[t.join(e,".agents","skills")]},codex:{user:()=>[t.join(f.homedir(),".agents","skills"),t.join(f.homedir(),".codex","skills")],project:e=>[t.join(e,".agents","skills"),t.join(e,".codex","skills")]}};function y(e,c,u){const r=[];let l=c+1;for(;l<e.length;){const n=e[l];if(n===void 0)break;const i=n.trimStart();if(i===""||n.length===i.length)break;if(i.startsWith("#")){l++;continue}r.push(i),l++}return u===">"?r.join(" "):r.join(`
+`)}export function parseSkillMd(e){let c;try{c=j(e,"utf-8")}catch{return null}const u=c.replace(/\r\n/g,`
+`).replace(/\r/g,`
+`);if(!u.startsWith("---"))return null;const r=u.indexOf(`
+---`,3);if(r===-1)return null;const n=u.slice(4,r).split(`
+`);let i="",s="",a=!0;for(let d=0;d<n.length;d++){const m=n[d];if(m===void 0||!m.trim()||m.trimStart().startsWith("#"))continue;const h=m.match(/^(\w+):\s*(.*)$/);if(!h)continue;const k=h[1];if(k===void 0)continue;let o=(h[2]??"").trim();switch((o===">"||o==="|")&&(o=y(n,d,o)),o.length>=2&&(o.startsWith('"')&&o.endsWith('"')||o.startsWith("'")&&o.endsWith("'"))&&(o=o.slice(1,-1)),k){case"name":i=o;break;case"description":s=o;break;case"user_invocable":a=o.toLowerCase()!=="false";break}}return!i||!s?null:{name:i,description:s,userInvocable:a}}function p(e,c,u){if(!S(e))return[];const r=[];let l;try{l=g(e,{withFileTypes:!0})}catch{return[]}for(const n of l)if(n.isDirectory()&&!(n.name.startsWith(".")&&n.name!==".system")){if(n.name===".system"){for(const i of p(t.join(e,n.name),c,u))r.push(i);continue}for(const i of b){const s=t.join(e,n.name,i),a=parseSkillMd(s);if(a){r.push({...a,source:c,projectPath:c==="project"?u:void 0});break}}}return r}export function discoverSkills(e){const c={};for(const[u,r]of Object.entries(AGENT_SKILL_DIRS)){const l=[];for(const s of r.user())for(const a of p(s,"user"))l.push(a);for(let s=e.length-1;s>=0;s--){const a=e[s];if(a)for(const d of r.project(a))for(const m of p(d,"project",a))l.push(m)}const n=new Set,i=[];for(const s of l.reverse())n.has(s.name)||(n.add(s.name),i.unshift(s));i.length>0&&(c[u]=i)}return c}

package/dist/spawnConsole.d.ts

@@ -0,0 +1,9 @@
+import { type ChildProcess } from 'node:child_process';
+
+export declare function buildShellCommand(scripts: readonly string[], mainCmd: string): string;
+
+export declare function spawnWithConsole(args: readonly string[], cwd: string, env: Record<string, string | undefined>, startupScripts?: readonly string[], useWindowsTerminal?: boolean): ChildProcess;
+
+export declare function spawnDetached(args: readonly string[], cwd: string, env: Record<string, string | undefined>, startupScripts?: readonly string[]): ChildProcess;
+
+export declare function cleanSpawnTmpFiles(): void;

package/dist/spawnConsole.js

@@ -0,0 +1,21 @@
+"use strict";import u from"node:fs";import m from"node:path";import E from"node:os";import{randomUUID as O}from"node:crypto";import{spawn as d}from"node:child_process";import{getDaemonDir as P}from"./paths.js";import{getBrand as N}from"./brand.js";let w=null;function b(){if(w!==null)return w;try{const e=m.join(process.env.LOCALAPPDATA??m.join(E.homedir(),"AppData","Local"),"Microsoft","WindowsApps","wt.exe");u.accessSync(e,u.constants.X_OK),w=!0}catch{w=!1}return w}function x(e){return"'"+e.replace(/'/g,"'\\''")+"'"}function S(e){return"'"+e.replace(/'/g,"''")+"'"}function j(e){return'"'+e.replace(/\\/g,"\\\\").replace(/"/g,'\\"')+'"'}export function buildShellCommand(e,t){return e.length===0?t:[...e,t].join(" && ")}function g(e,t,o,n,r){const i="& "+[e,...t].map(c=>S(c)).join(" "),s=r.includeConsoleFont?['try { Add-Type -TypeDefinition @"',"using System;","using System.Runtime.InteropServices;","public class ConsoleFont {","  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]","  public struct CONSOLE_FONT_INFOEX {","    public uint cbSize;","    public uint nFont;","    public short dwFontSizeX;","    public short dwFontSizeY;","    public int FontFamily;","    public int FontWeight;","    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]","    public string FaceName;","  }",'  [DllImport("kernel32.dll", SetLastError = true)]',"  static extern IntPtr GetStdHandle(int h);",'  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]',"  static extern bool SetCurrentConsoleFontEx(IntPtr h, bool max, ref CONSOLE_FONT_INFOEX info);","  public static void Set(string name, short size) {","    var info = new CONSOLE_FONT_INFOEX();","    info.cbSize = (uint)Marshal.SizeOf(info);","    info.FaceName = name;","    info.dwFontSizeY = size;","    info.FontWeight = 400;","    SetCurrentConsoleFontEx(GetStdHandle(-11), false, ref info);","  }","}",'"@ } catch {}','[ConsoleFont]::Set("Consolas", 16)']:[];return["[Console]::OutputEncoding = [System.Text.Encoding]::UTF8","[Console]::InputEncoding = [System.Text.Encoding]::UTF8","$OutputEncoding = [System.Text.Encoding]::UTF8",...r.windowTitle?[`try { $host.UI.RawUI.WindowTitle = ${S(r.windowTitle)} } catch {}`]:[],...s,"try {","  Set-Location -LiteralPath "+S(o),...r.loadProfile?["  if (Test-Path $PROFILE) { . $PROFILE }"]:[],...n.map(c=>`  ${c}`),"  "+i,"} catch {",'  Write-Host "Error: $_" -ForegroundColor Red',"  exit 1","} finally {","  Remove-Item -LiteralPath $MyInvocation.MyCommand.Path -Force -ErrorAction SilentlyContinue","}","if ($LASTEXITCODE) { exit $LASTEXITCODE }"].join(`\r
+`)+`\r
+`}function C(e){const t=m.join(P(),"tmp");u.mkdirSync(t,{recursive:!0});for(let o=0;o<3;o++){const n=m.join(t,`spawn-${O()}.ps1`);try{return u.writeFileSync(n,`\uFEFF${e}`,{encoding:"utf8",flag:"wx"}),n}catch(r){if(!(typeof r=="object"&&r!==null&&"code"in r&&r.code==="EEXIST")||o===2)throw r}}throw new Error("unreachable: spawn script creation exhausted")}function L(e,t,o){const n=["-ExecutionPolicy","Bypass","-NoLogo","-NoProfile","-File",e],r="Start-Process -FilePath "+S("powershell.exe")+" -ArgumentList @("+n.map(i=>S(`"${i}"`)).join(", ")+") -WindowStyle Normal";return d("powershell.exe",["-NoLogo","-NoProfile","-Command",r],{stdio:"ignore",cwd:t,env:o,windowsHide:!0})}export function spawnWithConsole(e,t,o,n,r){if(process.platform==="win32"){const i=N().description;if(n&&n.length>0){const l=C(g(process.execPath,e,t,n,{includeConsoleFont:!0,loadProfile:!0,windowTitle:i}));return r&&b()?d("wt.exe",["-w","0","new-tab","--title",i,"--startingDirectory",t,"--","powershell.exe","-ExecutionPolicy","Bypass","-NoLogo","-NoProfile","-File",l],{detached:!0,stdio:"ignore",cwd:t,env:o}):L(l,t,o)}if(r&&b())return d("wt.exe",["-w","0","new-tab","--title",i,"--startingDirectory",t,"--",process.execPath,...e],{detached:!0,stdio:"ignore",cwd:t,env:o});const s=C(g(process.execPath,e,t,[],{includeConsoleFont:!0,loadProfile:!1,windowTitle:i}));return L(s,t,o)}if(process.platform==="darwin"){const i=Object.entries(o).filter(a=>a[0].startsWith("AGENTDOCK_")&&a[1]!==void 0).map(([a,y])=>`export ${a}=${x(y)}`).join("; "),s=[process.execPath,...e].map(a=>x(a)).join(" "),l=[i,`cd ${x(t)}`,"clear"].filter(Boolean),c=buildShellCommand(n??[],s),f=[...l,c].join(" && "),F=`tell application "Terminal"
+  activate
+  set t to do script ${j(f)}
+  set wId to id of window 1
+end tell
+delay 2
+repeat
+  try
+    tell application "Terminal"
+      if busy of t is false then
+        close (first window whose id is wId)
+        exit repeat
+      end if
+    end tell
+  on error
+    exit repeat
+  end try
+  delay 1
+end repeat`;return d("osascript",["-e",F],{detached:!0,stdio:"ignore",cwd:t,env:o})}if(n&&n.length>0){const i=process.env.SHELL||"/bin/sh",s=[process.execPath,...e].map(c=>x(c)).join(" "),l=buildShellCommand(n,`exec ${s}`);return d(i,["-lc",l],{detached:!0,stdio:"ignore",cwd:t,env:o})}return d(process.execPath,[...e],{detached:!0,stdio:"ignore",cwd:t,env:o})}export function spawnDetached(e,t,o,n){const r=m.join(E.tmpdir(),"agentdock-spawn-stderr.log"),i=u.openSync(r,"a"),s=()=>{try{u.closeSync(i)}catch{}};if(process.platform==="darwin"){const c=process.env.SHELL||"/bin/sh",f=Object.entries(o).filter(p=>p[0]!=="PATH"&&p[1]!==void 0).map(([p,T])=>`export ${p}=${x(T)}`).join("; "),F=[process.execPath,...e].map(p=>x(p)).join(" "),a=buildShellCommand(n??[],`exec ${F}`),y=[f,a].filter(Boolean).join("; "),h=d(c,["-lic",y],{cwd:t,env:o,detached:!0,stdio:["ignore","ignore",i]});return h.on("close",s),h.unref(),h}if(n&&n.length>0){if(process.platform==="linux"){const F=process.env.SHELL||"/bin/sh",a=[process.execPath,...e].map(p=>x(p)).join(" "),y=buildShellCommand(n,`exec ${a}`),h=d(F,["-lc",y],{cwd:t,env:o,detached:!0,stdio:["ignore","ignore",i]});return h.on("close",s),h.unref(),h}const c=C(g(process.execPath,e,t,n,{includeConsoleFont:!1,loadProfile:!0})),f=d("powershell.exe",["-ExecutionPolicy","Bypass","-NoLogo","-NoProfile","-File",c],{cwd:t,env:o,stdio:["ignore","ignore",i],windowsHide:!0});return f.on("close",s),f.unref(),f}const l=d(process.execPath,[...e],{cwd:t,env:o,detached:!0,stdio:["ignore","ignore",i],windowsHide:!0});return l.on("close",s),l.unref(),l}export function cleanSpawnTmpFiles(){const e=m.join(P(),"tmp");if(u.existsSync(e))for(const t of u.readdirSync(e)){if(!t.startsWith("spawn-"))continue;const o=m.join(e,t);try{u.unlinkSync(o)}catch{}}}

package/dist/startAbortHandler.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from './logger.js';
+import type { SessionSink } from '@agentdock/agent-runtime-contract/sessionSink';
+import type { SendControlRequestFn } from './startCancelTaskHandler.js';
+export interface AbortHandlerDeps {
+    readonly sessionId: string;
+    readonly serverClient: SessionSink | null;
+    readonly sendControlRequestRef: SendControlRequestFn;
+    readonly forceKillRef: {
+        current: (() => Promise<void>) | null;
+    };
+    readonly log: Logger;
+}
+export declare function createAbortHandler(deps: AbortHandlerDeps, abortPendingRef: {
+    current: boolean;
+}): () => Promise<void>;

package/dist/startAbortHandler.js

@@ -0,0 +1 @@
+"use strict";export function createAbortHandler(e,t){return async()=>{const r=e.sendControlRequestRef.current;if(r){const n=r("interrupt",{}),o=new Promise((l,i)=>setTimeout(()=>i(new Error("interrupt timeout")),5e3));try{await Promise.race([n,o]),t.current=!0,e.log.info({sessionId:e.sessionId,module:"daemon:start"},"graceful interrupt acknowledged")}catch{e.log.warn({sessionId:e.sessionId,module:"daemon:start"},"graceful interrupt failed, falling back to force kill"),await e.forceKillRef.current?.()}}else e.forceKillRef.current?await e.forceKillRef.current():e.log.warn({sessionId:e.sessionId,module:"daemon:start"},"abort received but no interrupt channel and no backend to kill (forceKillRef null)");e.serverClient&&e.sessionId&&e.serverClient.sendSessionStatus(e.sessionId,"idle")}}

package/dist/startAcpInitialPrompt.d.ts

@@ -0,0 +1,51 @@
+import type { SessionSink } from '@agentdock/agent-runtime-contract/sessionSink';
+import type { MessageQueue } from './messageQueue.js';
+
+export declare function buildAcpDeveloperInstructions(params: {
+    readonly agent: string;
+    readonly isScheduled: boolean;
+    readonly mergedSystemPrompt?: string;
+}): string | undefined;
+export declare function buildAcpInitialPrompt(params: {
+    readonly agent: string;
+    readonly initialPrompt?: string;
+    readonly appendSystemPrompt?: string;
+    readonly isScheduled: boolean;
+}): string | undefined;
+
+export declare function prepareAcpInitialPrompt(params: {
+    readonly agent: string;
+    readonly initialPrompt: string | undefined;
+    readonly mergedSystemPrompt: string | undefined;
+    readonly isScheduled: boolean;
+    readonly log: {
+        error: (obj: object, msg: string) => void;
+    };
+}): Promise<string | undefined>;
+
+export declare function startAcpBackendWithInitialPrompt(params: {
+    readonly agent: string;
+    readonly initialPrompt: string | undefined;
+    readonly mergedSystemPrompt: string | undefined;
+    readonly isScheduled: boolean;
+    readonly log: {
+        error: (obj: object, msg: string) => void;
+    };
+    readonly dispatch: Omit<DispatchInitialPromptParams, 'effectivePrompt'>;
+    readonly startBackend: () => Promise<void>;
+}): Promise<boolean>;
+export interface DispatchInitialPromptParams {
+    effectivePrompt: string | undefined;
+    initialPrompt: string | undefined;
+    serverClient: SessionSink | undefined;
+    sessionId: string | undefined;
+    messageQueue: MessageQueue;
+    sendMetadataUpdate: (update: Record<string, unknown>) => void;
+    resumeServerSessionId: string | undefined;
+    log: {
+        info: (obj: object, msg: string) => void;
+        error: (obj: object, msg: string) => void;
+    };
+}
+
+export declare function dispatchInitialPrompt(params: DispatchInitialPromptParams): boolean;

package/dist/startAcpInitialPrompt.js

@@ -0,0 +1,7 @@
+"use strict";import{createEnvelope as m,createId as g}from"@agentdock/wire";import{REMOTE_ENVIRONMENT_PROMPT as o,SUGGESTED_OPTIONS_PROMPT as u,withOpenCodeInstructions as S,writeOpenCodeInstructionsFile as h}from"./suggestedOptionsPrompt.js";export function buildAcpDeveloperInstructions(e){if(e.agent!=="codex"&&e.agent!=="pi")return;const t=e.isScheduled?[o]:[o,u];return e.mergedSystemPrompt&&t.push(e.mergedSystemPrompt),t.join(`
+
+`)}export function buildAcpInitialPrompt(e){if(e.agent==="opencode"||e.agent==="codex"||e.agent==="pi")return e.initialPrompt;const t=e.isScheduled?[o]:[o,u];e.appendSystemPrompt&&t.push(e.appendSystemPrompt);const n=t.join(`
+
+`);return e.initialPrompt?`${n}
+
+${e.initialPrompt}`:e.appendSystemPrompt?n:void 0}export async function prepareAcpInitialPrompt(e){if(e.agent==="opencode")try{await h(e.mergedSystemPrompt,e.isScheduled)}catch(t){e.log.error({err:t,module:"daemon:acp"},"failed to write opencode instructions file")}return buildAcpInitialPrompt({agent:e.agent,initialPrompt:e.initialPrompt,appendSystemPrompt:e.agent==="codex"||e.agent==="pi"?void 0:e.mergedSystemPrompt,isScheduled:e.isScheduled})}export async function startAcpBackendWithInitialPrompt(e){const t=async n=>{const i=dispatchInitialPrompt({...e.dispatch,effectivePrompt:n});return await e.startBackend(),i};return e.agent==="opencode"?S(e.mergedSystemPrompt,e.isScheduled,()=>t(buildAcpInitialPrompt(e))):t(await prepareAcpInitialPrompt(e))}export function dispatchInitialPrompt(e){const{effectivePrompt:t,initialPrompt:n,serverClient:i,sessionId:r,messageQueue:s,sendMetadataUpdate:l,resumeServerSessionId:p,log:d}=e;if(!t)return!1;const c=g();if(s.push(t,void 0,{messageUuid:c}),!n||!i||!r)return!1;const f=m("user",{t:"text",text:n},{messageUuid:c});return i.sendEnvelope(r,f).catch(P=>{d.error({err:P,module:"daemon:acp"},"failed to echo initial user message")}),p||l({title:n.slice(0,80)}),d.info({prompt:n.slice(0,80),module:"daemon:acp"},"initial prompt queued"),!0}

package/dist/startAcpPermission.d.ts

@@ -0,0 +1,20 @@
+import type { AgentBackend } from './acpTypes.js';
+import type { SessionSink } from '@agentdock/agent-runtime-contract/sessionSink';
+import type { Logger } from './logger.js';
+import type { MessageQueue } from './messageQueue.js';
+import type { SessionBridge } from './session/sessionBridge.js';
+export declare function createAcpPermissionHandler(deps: {
+    readonly serverClient: SessionSink;
+    readonly sessionId: string;
+    readonly log: Logger;
+    readonly agent: string;
+    readonly backend: AgentBackend;
+    readonly messageQueue: MessageQueue;
+    readonly bridgeRef: {
+        current: SessionBridge | undefined;
+    };
+    
+    readonly onAllowedToolsChanged?: (rules: readonly string[]) => void;
+    
+    readonly onAutoApproveEditsChanged?: () => void;
+}): (requestId: string, approved: boolean, reason?: string, allowTools?: readonly string[], mode?: string, autoApproveEdits?: boolean, inputOverrides?: Record<string, unknown>) => void;

package/dist/startAcpPermission.js

@@ -0,0 +1 @@
+"use strict";import{createEnvelope as m}from"@agentdock/wire";const E=new Set(["copilot"]);export function createAcpPermissionHandler(s){return(r,o,n,e,c,p,g)=>{const{serverClient:d,sessionId:l,log:u,agent:a,backend:t,messageQueue:f,bridgeRef:h}=s;if(t.resolvePermission?.(r,o,n,g),o){if(e&&e.length>0){t.addAllowedTools?.(e);const i=t.getAllowedTools?.();i&&i.length>0&&s.onAllowedToolsChanged?.(i)}c&&t.setPermissionMode?.(c),p&&(t.setAutoApproveEdits?.(!0),s.onAutoApproveEditsChanged?.())}d.sendSessionStatus(l,"thinking");const v=o?c==="acceptEdits"?"approve-all-edits":e&&e.length?"approve-tool":"approve":"deny",A=m("agent",{t:"permission-resolved",requestId:r,action:v,...n?{reason:n}:{},...e?.length?{allowTools:[...e]}:{}});d.sendEnvelope(l,A).then(()=>{d.sendPermissionResolved(l,r),!o&&n&&E.has(a)&&(h.current?.skipNextIdle(),f.push(n,void 0,{echoToServer:!0}))}).catch(i=>{u.error({err:i,module:"daemon:acp"},"failed to send permission-resolved envelope")})}}

package/dist/startAcpSwitchHelpers.d.ts

@@ -0,0 +1,52 @@
+import type { AgentBackend } from './acpTypes.js';
+import type { Logger } from './logger.js';
+import type { SessionSink } from '@agentdock/agent-runtime-contract/sessionSink';
+
+export interface AcpModeState {
+    currentModel: string | null;
+    pendingModelSwitch: string | null;
+    currentMode: string;
+    pendingModeSwitch: string | null;
+    pendingModeRevertTo: string | null;
+}
+export interface AnswerMetaDeps {
+    readonly agent: string;
+    readonly supportsNativeModeForward: boolean;
+    readonly backend: AgentBackend;
+    readonly log: Logger;
+    readonly sendMetadataUpdate: (patch: Record<string, unknown>) => void;
+}
+
+export declare function applyAnswerMetaChanges(state: AcpModeState, meta: {
+    model?: string;
+    permissionMode?: string;
+} | undefined, deps: AnswerMetaDeps): string;
+
+export interface SpawnPermissionMode {
+    
+    readonly resolved: string;
+    
+    readonly policyMode: string | null;
+    
+    readonly supportsNativeModeForward: boolean;
+}
+
+export declare function resolveSpawnPermissionMode(agent: string, permissionMode: string): SpawnPermissionMode;
+
+export type ModeRouting = {
+    readonly type: 'policy';
+    readonly policyMode: string;
+} | {
+    readonly type: 'native';
+} | {
+    readonly type: 'unsupported';
+};
+
+export declare function classifyModeChange(agent: string, requestedMode: string, supportsNativeModeForward: boolean): ModeRouting;
+export declare function applyPendingModelSwitch(backend: AgentBackend, pendingModelSwitch: string | null, serverClient: SessionSink | undefined, sessionId: string | undefined, modelLabelMap: Map<string, string>, log: Logger, onSwitched?: (model: string) => void, onFailed?: (model: string) => void): Promise<string | null>;
+export declare function applyPendingModeSwitch(backend: AgentBackend, pendingModeSwitch: string | null, serverClient: SessionSink | undefined, sessionId: string | undefined, modeLabelMap: Map<string, string>, log: Logger, 
+
+onFailed?: (mode: string) => void): Promise<string | null>;
+
+export type CompactOutcome = 'compacted' | 'failed' | 'unsupported';
+export declare function handleCompact(backend: AgentBackend, sendServiceEnvelope: (text: string) => void, sendMetadataUpdate: (patch: Record<string, unknown>) => void, log: Logger): Promise<CompactOutcome>;

package/dist/startAcpSwitchHelpers.js

@@ -0,0 +1 @@
+"use strict";import{createEnvelope as s,createId as w,errorMessage as M,getAgentCapability as v,resolvePolicyMode as f}from"@agentdock/wire";export function applyAnswerMetaChanges(n,e,o){if(e?.model&&e.model!==(n.currentModel??"")?(n.pendingModelSwitch=e.model,o.log.info({model:e.model,currentModel:n.currentModel,module:"daemon:acp"},"model switch requested")):e?.model&&o.log.debug({model:e.model,currentModel:n.currentModel,module:"daemon:acp"},"model unchanged, skipping switch"),e?.permissionMode&&e.permissionMode!==n.currentMode){const d=classifyModeChange(o.agent,e.permissionMode,o.supportsNativeModeForward);if(d.type==="policy")n.currentMode=d.policyMode,o.backend.setPermissionMode?.(d.policyMode),o.sendMetadataUpdate({permissionMode:d.policyMode}),o.log.info({mode:d.policyMode,module:"daemon:acp"},"permission mode changed");else if(d.type==="native"){const r=n.currentMode;n.currentMode=e.permissionMode,o.sendMetadataUpdate({permissionMode:e.permissionMode}),o.log.info({mode:e.permissionMode,module:"daemon:acp"},"agent-native mode change requested"),n.pendingModeSwitch=e.permissionMode,n.pendingModeRevertTo=r}else o.log.warn({mode:e.permissionMode,agent:o.agent,module:"daemon:acp"},"agent does not support native mode forwarding; ignoring")}else e?.permissionMode&&o.log.debug({mode:e.permissionMode,currentMode:n.currentMode,module:"daemon:acp"},"permission mode unchanged, skipping");return w()}export function resolveSpawnPermissionMode(n,e){const o=f(n,e);return{resolved:o??e,policyMode:o,supportsNativeModeForward:v(n).supportsNativeModeForward}}export function classifyModeChange(n,e,o){const d=f(n,e);return d?{type:"policy",policyMode:d}:o?{type:"native"}:{type:"unsupported"}}export async function applyPendingModelSwitch(n,e,o,d,r,t,l,u){if(!e)return null;const i=!!n.switchModel;if(t.debug({pendingModelSwitch:e,hasSwitchModel:i,module:"daemon:acp"},"checking pending model switch"),i){const c=e;try{const a=await n.switchModel?.(c);if(t.info({model:c,ok:a,module:"daemon:acp"},"applied model switch"),a){if(l?.(c),o&&d){const m=s("agent",{t:"service",text:"model:switched:"+(r.get(c)??c)});o.sendEnvelope(d,m).catch(p=>{t.error({err:p,module:"daemon:acp"},"failed to send model switch envelope")})}}else if(u?.(c),t.warn({model:c,module:"daemon:acp"},"model switch returned false \u2014 configOption not found or RPC failed"),o&&d){const m=s("agent",{t:"service",text:"model:switch:failed:"+(r.get(c)??c)});o.sendEnvelope(d,m).catch(p=>{t.error({err:p,module:"daemon:acp"},"failed to send model switch failure envelope")})}}catch(a){if(u?.(c),t.error({err:a,module:"daemon:acp"},"failed to switch model via ACP"),o&&d){const m=r.get(c)??c,p=s("agent",{t:"service",text:"model:switch:failed:"+m});o.sendEnvelope(d,p).catch(h=>{t.error({err:h,module:"daemon:acp"},"failed to send model switch failure envelope")})}}return null}if(t.warn({pendingModelSwitch:e,module:"daemon:acp"},"backend.switchModel not available, discarding"),u?.(e),o&&d){const c=s("agent",{t:"service",text:"model:switch:failed:"+(r.get(e)??e)});o.sendEnvelope(d,c).catch(a=>{t.error({err:a,module:"daemon:acp"},"failed to send model switch failure envelope")})}return null}export async function applyPendingModeSwitch(n,e,o,d,r,t,l){if(!e)return null;const u=!!n.switchMode;if(t.debug({pendingModeSwitch:e,hasSwitchMode:u,module:"daemon:acp"},"checking pending mode switch"),u){const i=e,c=a=>{if(t.warn({mode:i,reason:a,module:"daemon:acp"},"mode switch failed"),l?.(i),o&&d){const m=s("agent",{t:"service",text:"mode:switch:failed:"+(r.get(i)??i)});o.sendEnvelope(d,m).catch(p=>{t.error({err:p,module:"daemon:acp"},"failed to send mode switch failure envelope")})}};try{const a=await n.switchMode?.(i);if(t.info({mode:i,ok:a,module:"daemon:acp"},"applied mode switch via ACP config option"),a&&o&&d){const m=s("agent",{t:"service",text:"mode:switched:"+(r.get(i)??i)});o.sendEnvelope(d,m).catch(p=>{t.error({err:p,module:"daemon:acp"},"failed to send mode switch envelope")})}else a||c("switchMode returned false \u2014 configOption not found or RPC failed")}catch(a){t.error({err:a,module:"daemon:acp"},"failed to switch mode via ACP"),c("switchMode threw")}return null}return t.warn({pendingModeSwitch:e,module:"daemon:acp"},"backend.switchMode not available, discarding"),l?.(e),null}export async function handleCompact(n,e,o,d){if(d.info({module:"daemon:acp"},"/compact received"),e("compact:started"),!n.compactThread)return"unsupported";const r=(l,u={})=>(d.warn({...u,reason:l,module:"daemon:acp"},"native compaction failed; /compact dropped"),e(`compact:failed:${l}`),"failed");let t;try{t=await n.compactThread()}catch(l){return r(M(l),{err:l})}return t.status==="compacted"?(d.info({newThreadId:t.threadId,module:"daemon:acp"},"native compaction succeeded"),o({claudeSessionId:t.threadId}),"compacted"):t.status==="aborted"?(d.info({module:"daemon:acp"},"native compaction aborted by the user"),"failed"):r(t.reason??"")}

package/dist/startCancelTaskHandler.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from './logger.js';
+export interface SendControlRequestFn {
+    readonly current: ((subtype: string, params: Record<string, unknown>) => Promise<Record<string, unknown>>) | null;
+}
+export interface CancelTaskResult {
+    readonly ok: boolean;
+    readonly error?: string;
+}
+
+export interface CancelTaskHandlerOptions {
+    readonly sendControlRequestRef: SendControlRequestFn;
+    readonly sessionId: string;
+    readonly log: Logger;
+    
+    readonly getWorkflowChildTaskIds?: () => ReadonlyMap<string, readonly string[]>;
+}
+export declare function createCancelTaskHandler(opts: CancelTaskHandlerOptions): (taskId: string) => Promise<CancelTaskResult>;

package/dist/startCancelTaskHandler.js

@@ -0,0 +1 @@
+"use strict";import{parseWorkflowTaskId as i}from"./session/workflowTracker.js";export function createCancelTaskHandler(e){const{sendControlRequestRef:c}=e;return async o=>{const l=c.current;if(!l)return e.log.warn({taskId:o,sessionId:e.sessionId,module:"daemon:start"},"cancel-task: no backend to send control request"),{ok:!1,error:"no-backend"};const r=i(o);if(r!==null&&e.getWorkflowChildTaskIds){const n=e.getWorkflowChildTaskIds().get(r);if(!n||n.length===0)return e.log.warn({taskId:o,wfCallId:r,sessionId:e.sessionId,module:"daemon:start"},"cancel-task: Workflow has no active children"),{ok:!1,error:"no-children"};e.log.info({taskId:o,wfCallId:r,childCount:n.length,sessionId:e.sessionId,module:"daemon:start"},"cancelling Workflow with all children");let s=!0;for(const t of n)try{await l("stop_task",{task_id:t})}catch(d){e.log.error({err:d,taskId:o,childId:t,module:"daemon:start"},"cancel-task: failed to cancel Workflow child"),s=!1}return{ok:s}}e.log.info({taskId:o,sessionId:e.sessionId,module:"daemon:start"},"cancelling background task");try{return await l("stop_task",{task_id:o}),{ok:!0}}catch(a){return e.log.error({err:a,taskId:o,module:"daemon:start"},"cancel-task: sendControlRequest failed"),{ok:!1,error:"control-request-failed"}}}}

package/dist/startCommandDaemonDebug.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from './logger.js';
+interface DaemonDebugState {
+    httpPort: number;
+    authToken?: string;
+}
+
+export declare function applyDaemonDebugLevel(state: DaemonDebugState | undefined, log: Logger): Promise<void>;
+export {};

package/dist/startCommandDaemonDebug.js

@@ -0,0 +1 @@
+"use strict";export async function applyDaemonDebugLevel(e,o){if(e)try{const t=await(await fetch(`http://127.0.0.1:${e.httpPort}/rpc`,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${e.authToken??""}`},body:JSON.stringify({method:"get-debug",params:{}})})).json();t.ok===!0&&t.result?.enabled===!0&&(o.level="debug")}catch{}}

package/dist/startCommandRuntime.d.ts

@@ -0,0 +1,162 @@
+import { type SessionEnvelope } from '@agentdock/wire';
+import type { SessionSink } from '@agentdock/agent-runtime-contract/sessionSink';
+import { type KeepAlive, type LivenessHeartbeat, type SessionOwnershipLossReason } from './keepAlive.js';
+type Mode = 'local' | 'remote';
+interface MetadataLogger {
+    error(details: {
+        err: unknown;
+        module?: string;
+    }, message: string): void;
+    warn(details: Record<string, unknown>, message: string): void;
+    info(details: Record<string, unknown>, message: string): void;
+}
+interface PromptLogger {
+    info(details: Record<string, unknown>, message: string): void;
+}
+interface ModeChangeLogger {
+    info(details: Record<string, unknown>, message: string): void;
+    debug(details: Record<string, unknown>, message: string): void;
+    
+    warn(details: Record<string, unknown>, message: string): void;
+}
+
+export type LocalNoticeEvent = 'remote-entered' | 'local-resumed';
+interface ModeChangeOptions {
+    readonly mode: Mode;
+    readonly isInitial: boolean;
+    readonly previousMode: Mode | null;
+    readonly abortPending: boolean;
+    readonly keepAlive?: {
+        setMode(mode: Mode): void;
+    };
+    readonly scanner?: {
+        pause(): void;
+        resume(): void;
+    };
+    readonly stdinResume: {
+        listen(): void;
+        stop(): void;
+    };
+    readonly clearRemoteEnvelopes: () => void;
+    readonly clearQueuedMessages: () => void;
+    readonly serverClient?: SessionSink;
+    readonly sessionId?: string;
+    readonly sendMetadataUpdate: (patch: Record<string, unknown>) => void;
+    
+    readonly noticeLocalUser: (event: LocalNoticeEvent) => void;
+    readonly log: ModeChangeLogger;
+}
+interface CleanupOptions {
+    readonly stdinResume: {
+        stop(): void;
+    };
+    readonly messageQueue: {
+        close(): void;
+    };
+    readonly scanner?: {
+        cleanup(): void;
+        releaseCurrentSession?(): void;
+    };
+    readonly keepAlive?: {
+        stop(): void;
+    };
+    readonly sessionId?: string;
+    readonly serverClient?: SessionSink;
+    readonly hookServer?: {
+        stop(): void;
+    };
+    readonly hookSettingsPath?: string;
+    readonly cleanupHookSettingsFile: (path: string) => Promise<void>;
+    readonly systemPromptFile?: string;
+    
+    readonly daemonPid?: number;
+    
+    readonly flushMetadata?: () => Promise<void>;
+    
+    readonly shouldSendSessionEnd?: () => boolean;
+}
+interface EmergencyCleanupOptions extends CleanupOptions {
+    readonly markCleanedUp: () => boolean;
+}
+interface ExitLifecycleOptions {
+    readonly run: () => Promise<number>;
+    readonly onEmergencyExit: (code: number) => void;
+    readonly onAfterRun: () => Promise<void>;
+}
+export declare function createSessionOwnershipLossHandler(params: {
+    readonly sessionId: string;
+    readonly log: MetadataLogger;
+    readonly controllerRef: {
+        current: {
+            requestExit(): void;
+        } | null;
+    };
+    readonly reasonRef: {
+        current: SessionOwnershipLossReason | undefined;
+    };
+}): (reason: SessionOwnershipLossReason) => void;
+export declare function startSessionKeepAlive(params: {
+    readonly serverClient?: SessionSink;
+    readonly sessionId?: string;
+    readonly log: MetadataLogger;
+    readonly controllerRef: {
+        current: {
+            requestExit(): void;
+        } | null;
+    };
+    readonly reasonRef: {
+        current: SessionOwnershipLossReason | undefined;
+    };
+}): {
+    keepAlive?: KeepAlive;
+    livenessHeartbeat?: LivenessHeartbeat;
+};
+export declare function createSessionMetadataUpdater(serverClient: SessionSink | undefined, sessionId: string | undefined, initialMeta: Record<string, unknown>, logger: MetadataLogger): {
+    update: (patch: Record<string, unknown>) => void;
+    flush: () => Promise<void>;
+};
+export declare function createRemoteEnvelopeSender(isRemote: () => boolean): {
+    clear(): void;
+    send(serverClient: SessionSink, sessionId: string, envelope: SessionEnvelope): Promise<void>;
+};
+export declare function queueInitialPrompt(serverClient: SessionSink | undefined, sessionId: string | undefined, initialPrompt: string | undefined, pushMessage: (text: string, messageUuid?: string) => void, sendMetadataUpdate: (patch: Record<string, unknown>) => void, logger: PromptLogger, skipTitle?: boolean): boolean;
+export declare function applyModeChangeEffects({ mode, isInitial, previousMode, abortPending, keepAlive, scanner, stdinResume, clearRemoteEnvelopes, clearQueuedMessages, serverClient, sessionId, sendMetadataUpdate, noticeLocalUser, log, }: ModeChangeOptions): boolean;
+export declare function runStartCommandCleanup(opts: CleanupOptions): Promise<void>;
+export declare function createEmergencyCleanup(options: EmergencyCleanupOptions): () => Promise<void>;
+export declare function runWithExitLifecycle({ run, onEmergencyExit, onAfterRun, }: ExitLifecycleOptions): Promise<number>;
+
+export declare function echoUserEnvelopes(sc: SessionSink, sid: string, text: string, images: readonly {
+    data: string;
+    mediaType: string;
+}[] | undefined, log: MetadataLogger, messageUuid?: string): void;
+
+export declare function sendModeChangeEnvelopes(sc: SessionSink, sid: string, meta: {
+    model?: string;
+    permissionMode?: string;
+} | undefined, currentMeta: {
+    model?: string;
+    permissionMode?: string;
+}, log: MetadataLogger): void;
+
+export declare function tryHotSwitch(sendControlRequestRef: {
+    current: ((subtype: string, params: Record<string, unknown>) => Promise<Record<string, unknown>>) | null;
+}, meta: {
+    model?: string;
+    permissionMode?: string;
+} | undefined, currentMeta: {
+    model?: string;
+    permissionMode?: string;
+}, log: MetadataLogger, onPermissionModeSwitched?: (mode: string) => void): Promise<boolean>;
+
+export declare function checkDaemonUpgrade(): {
+    exitCode: number;
+} | undefined;
+
+export declare function syncPermissionModeAfterApproval(approved: boolean, mode: string | undefined, currentRemoteMeta: {
+    permissionMode?: string;
+}, sendMetadataUpdate: (fields: Record<string, unknown>) => void): {
+    permissionMode?: string;
+};
+
+export declare function loadAllowedToolsFromMeta(raw: unknown): readonly string[];
+export {};

package/dist/startCommandRuntime.js

@@ -0,0 +1,5 @@
+"use strict";import{killOwnChildProcessTrees as y}from"./processTree.js";import{createEnvelope as p,createId as M,errorMessage as g}from"@agentdock/wire";import{resetTerminalMouse as x}from"./terminalReset.js";import E from"node:fs/promises";import{getBrand as w}from"./brand.js";import{readDaemonState as T}from"./state.js";import{getStatePath as I}from"./paths.js";import{compareVersions as _}from"@agentdock/wire";import{VERSION as v}from"./version.js";import{isRecord as P}from"./typeGuards.js";import{createSessionKeepAliveSet as b}from"./keepAlive.js";export function createSessionOwnershipLossHandler(e){return r=>{e.reasonRef.current??=r,e.log.warn({sessionId:e.sessionId,reason:r,module:"daemon:start"},"session ownership lost; exiting CLI"),e.controllerRef.current?.requestExit()}}export function startSessionKeepAlive(e){if(!e.serverClient||!e.sessionId)return{};const r=createSessionOwnershipLossHandler({sessionId:e.sessionId,log:e.log,controllerRef:e.controllerRef,reasonRef:e.reasonRef});return b(e.serverClient,e.sessionId,void 0,r)}export function createSessionMetadataUpdater(e,r,n,t){let i=n,s=0,o=Promise.resolve();return{update:d=>{!e||!r||(i={...i,...d},o=o.then(async()=>{const c=s;try{await e.updateMetadata(r,JSON.stringify(i),c),s=c+1}catch(h){const u=P(h)?h.serverVersion:void 0;if(typeof u=="number"){t.warn({expectedVersion:c,serverVersion:u},"metadata version conflict, resyncing"),s=u;try{await e.updateMetadata(r,JSON.stringify(i),u),s=u+1}catch(S){t.error({err:S},"metadata resync retry failed")}}else t.error({err:h},"failed to update session metadata")}}))},flush:async()=>{let d;do d=o,await d;while(o!==d)}}}export function createRemoteEnvelopeSender(e){const r=new Set,n=t=>{if(!(!e()||!t.subagent))switch(t.ev.t){case"start":case"stop":case"tool-call-start":case"tool-call-end":return t.id;default:return}};return{clear(){r.clear()},async send(t,i,s){const o=n(s);if(!o){await t.sendEnvelope(i,s);return}if(!r.has(o)){r.add(o);try{await t.sendEnvelope(i,s)}catch(a){throw r.delete(o),a}}}}}export function queueInitialPrompt(e,r,n,t,i,s,o){if(!n||!e||!r)return!1;const a=M();return e.sendEnvelope(r,p("user",{t:"text",text:n},{messageUuid:a})).catch(()=>{}),t(n,a),o||i({title:n.slice(0,80)}),s.info({prompt:n.slice(0,80)},"initial prompt queued"),!0}export function applyModeChangeEffects({mode:e,isInitial:r,previousMode:n,abortPending:t,keepAlive:i,scanner:s,stdinResume:o,clearRemoteEnvelopes:a,clearQueuedMessages:m,serverClient:d,sessionId:c,sendMetadataUpdate:h,noticeLocalUser:u,log:S}){const f=e!==n;if(i?.setMode(e),e==="remote"?(s?.pause(),f&&u("remote-entered"),o.listen()):(a(),o.stop(),s?.resume(),m(),!r&&f&&u("local-resumed")),t){if(f&&h({mode:e}),d&&c&&(d.sendEnvelopeDirect(c,p("agent",{t:"turn-end",status:"cancelled"})).then(l=>{l.ok||S.warn({sessionId:c,error:l.error,module:"daemon:runtime"},"turn-end (cancelled) not synced")}).catch(l=>{S.warn({sessionId:c,err:l,module:"daemon:runtime"},"turn-end (cancelled) sync failed")}),f)){const l=e==="remote"?"mode:remote":"mode:local";d.sendEnvelope(c,p("agent",{t:"service",text:l})).catch(()=>{})}return S.debug({mode:e,isInitial:r,modeChanged:f,abortPending:!1,module:"daemon:runtime"},"mode changed"),!1}if(h({mode:e}),!r&&f&&d&&c){const l=e==="remote"?"mode:remote":"mode:local";d.sendEnvelope(c,p("agent",{t:"service",text:l})).catch(()=>{})}return S.info({mode:e,isInitial:r,modeChanged:f,abortPending:!1,module:"daemon:runtime"},"mode changed"),!1}export async function runStartCommandCleanup(e){if(e.stdinResume.stop(),x(),e.messageQueue.close(),e.scanner?.releaseCurrentSession?.(),e.scanner?.cleanup(),e.keepAlive?.stop(),e.flushMetadata)try{await Promise.race([e.flushMetadata(),new Promise(t=>setTimeout(t,2e3))])}catch{}if(e.sessionId&&e.serverClient&&(e.shouldSendSessionEnd?.()??!0))try{await Promise.race([e.serverClient.sendSessionEnd(e.sessionId),new Promise(t=>setTimeout(t,2e3))])}catch{}e.hookServer?.stop(),e.hookSettingsPath&&await e.cleanupHookSettingsFile(e.hookSettingsPath),e.systemPromptFile&&await E.unlink(e.systemPromptFile).catch(()=>{});const r=e.daemonPid?new Set([e.daemonPid]):void 0;y(r),e.serverClient?.disconnect()}export function createEmergencyCleanup(e){return async()=>{e.markCleanedUp()&&await runStartCommandCleanup(e)}}export async function runWithExitLifecycle({run:e,onEmergencyExit:r,onAfterRun:n}){const t=()=>r(130),i=()=>r(143),s=()=>r(129),o=()=>r(131);process.on("SIGINT",t),process.on("SIGTERM",i),process.on("SIGHUP",s),process.on("SIGQUIT",o);try{const a=await e();return await n(),a}catch(a){process.stderr.write(`FATAL: run() crashed: ${g(a)}
+`);try{await n()}catch{}return 1}finally{process.removeListener("SIGINT",t),process.removeListener("SIGTERM",i),process.removeListener("SIGHUP",s),process.removeListener("SIGQUIT",o)}}export function echoUserEnvelopes(e,r,n,t,i,s){const o=t&&t.length>0;if(!n&&!o)return;const a=o?t.map(m=>({data:m.data,mediaType:m.mediaType})):void 0;e.sendEnvelope(r,p("user",{t:"text",text:n||"",...a?{images:a}:{}},{messageUuid:s})).catch(m=>{i.error({err:m,module:"daemon:runtime"},"failed to echo user message")})}export function sendModeChangeEnvelopes(e,r,n,t,i){if(n?.model&&n.model!==t.model){const s=p("agent",{t:"service",text:"model:switched:"+n.model});e.sendEnvelope(r,s).catch(o=>{i.error({err:o,module:"daemon:runtime"},"failed to send model switch envelope")})}if(n?.permissionMode&&n.permissionMode!==t.permissionMode){const s=p("agent",{t:"service",text:"permission:switched:"+n.permissionMode});e.sendEnvelope(r,s).catch(o=>{i.error({err:o,module:"daemon:runtime"},"failed to send permission switch envelope")})}}export async function tryHotSwitch(e,r,n,t,i){if(!e.current)return!1;if(!r)return!0;const s=e.current;try{return r.model&&r.model!==n.model&&(await s("set_model",{model:r.model}),t.info({module:"daemon:runtime",model:r.model},"hot-switched model via control_request")),r.permissionMode&&r.permissionMode!==n.permissionMode&&(await s("set_permission_mode",{mode:r.permissionMode}),i?.(r.permissionMode),t.info({module:"daemon:runtime",mode:r.permissionMode},"hot-switched permission mode via control_request")),!0}catch(o){return t.warn({err:o,module:"daemon:runtime"},"hot-switch via control_request failed, will fallback to restart"),!1}}export function checkDaemonUpgrade(){const e=T(I());if(e?.upgradeRequired)return process.stderr.write(`\x1B[31m\u2716 Server requires a newer daemon version.\x1B[0m
+  Run: ${w().binCommand} upgrade
+`),{exitCode:1};e?.latestVersion&&_(v,e.latestVersion)<0&&process.stderr.write(`\x1B[33m\u26A0 Update available: v${v} \u2192 v${e.latestVersion}. Run: ${w().binCommand} upgrade\x1B[0m
+`)}export function syncPermissionModeAfterApproval(e,r,n,t){return!e||!r||r===n.permissionMode?n:(t({permissionMode:r}),{...n,permissionMode:r})}export function loadAllowedToolsFromMeta(e){return Array.isArray(e)?e.every(r=>typeof r=="string")?e:[]:[]}

package/dist/startCommandTypes.d.ts

@@ -0,0 +1,33 @@
+import type { Logger } from './logger.js';
+export interface StartCommandOptions {
+    
+    readonly agent?: string;
+    readonly cwd?: string;
+    readonly model?: string;
+    readonly permissionMode?: string;
+    readonly appendSystemPrompt?: string;
+    
+    readonly mcpConfig?: string;
+    readonly resumeSessionId?: string;
+    readonly extraArgs?: readonly string[];
+    readonly logger?: Logger;
+    readonly serverEndpoint?: string;
+    readonly serverToken?: string;
+    readonly name?: string;
+    
+    readonly source?: string;
+    
+    readonly serverSessionId?: string;
+    
+    readonly spawnToken?: string;
+    
+    readonly takeoverToken?: string;
+    
+    readonly sessionBootstrapFile?: string;
+    
+    readonly registerBackendControl?: (id: string, fn: (subtype: string, params: Record<string, unknown>) => Promise<Record<string, unknown>>) => void;
+    readonly unregisterBackendControl?: (id: string) => void;
+}
+export interface StartCommandResult {
+    readonly exitCode: number;
+}

package/dist/startCommandTypes.js

@@ -0,0 +1 @@
+"use strict";export{};

package/dist/startRpcHandler.d.ts

@@ -0,0 +1,41 @@
+import type { CancelTaskResult } from './startCancelTaskHandler.js';
+import type { Logger } from './logger.js';
+type RpcResult = {
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+
+export declare const START_RPC_METHODS: readonly ["answer-question", "approve-permission", "deny-permission", "abort", "stop-session", "cancel-task", "get-context-usage"];
+
+export interface RpcImageAttachment {
+    readonly data: string;
+    readonly mediaType: string;
+}
+
+export interface AnswerMeta {
+    readonly model?: string;
+    readonly permissionMode?: string;
+}
+
+export interface StartRpcDeps {
+    readonly sessionId: string;
+    readonly log?: Logger;
+    
+    readonly onAnswerQuestion: (text: string, meta?: AnswerMeta, images?: readonly RpcImageAttachment[]) => Promise<void>;
+    
+    readonly onAbort: () => Promise<void>;
+    
+    readonly onStopSession: () => Promise<() => void>;
+    
+    readonly onPermission?: (requestId: string, approved: boolean, reason?: string, allowTools?: readonly string[], mode?: string, autoApproveEdits?: boolean, inputOverrides?: Record<string, unknown>) => void;
+    
+    readonly onCancelTask?: (taskId: string) => Promise<CancelTaskResult>;
+    
+    readonly onGetContextUsage?: () => Promise<Record<string, unknown>>;
+}
+export type RpcRequestHandler = (method: string, params: Record<string, unknown>) => Promise<RpcResult>;
+export declare function createStartRpcHandler(deps: StartRpcDeps): RpcRequestHandler;
+export {};