@adhdev/daemon-core 0.9.82-rc.17 → 0.9.82-rc.170

package/src/providers/types/interactive-prompt.ts

@@ -0,0 +1,297 @@
+export interface InteractivePrompt {
+  promptId: string;
+  origin: 'cli' | 'mcp' | 'agent';
+  providerType: string;
+  createdAt: number;
+  questions: InteractiveQuestion[];
+}
+
+export interface InteractiveQuestion {
+  questionId: string;
+  question: string;
+  header?: string;
+  multiSelect: boolean;
+  options: InteractiveOption[];
+  allowFreeform?: boolean;
+}
+
+export interface InteractiveOption {
+  label: string;
+  description?: string;
+  preview?: string;
+}
+
+export interface InteractivePromptResponse {
+  promptId: string;
+  answers: Record<string, InteractiveAnswer>;
+}
+
+export interface InteractiveAnswer {
+  selectedLabels: string[];
+  freeformText?: string;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readStringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.map((item) => readString(item)).filter((item): item is string => !!item)
+    : [];
+}
+
+function normalizeOption(raw: unknown): InteractiveOption | null {
+  if (typeof raw === 'string') {
+    const label = raw.trim();
+    return label ? { label } : null;
+  }
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const label = readString(record.label);
+  if (!label) return null;
+  const description = readString(record.description);
+  const preview = readString(record.preview);
+  return {
+    label,
+    ...(description ? { description } : {}),
+    ...(preview ? { preview } : {}),
+  };
+}
+
+function normalizeQuestion(raw: unknown, index: number): InteractiveQuestion | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const question = readString(record.question);
+  if (!question) return null;
+  const questionId = readString(record.questionId) || readString(record.id) || `q${index + 1}`;
+  const options = Array.isArray(record.options)
+    ? record.options.map(normalizeOption).filter((item): item is InteractiveOption => !!item)
+    : [];
+  const header = readString(record.header);
+  return {
+    questionId,
+    question,
+    ...(header ? { header } : {}),
+    multiSelect: record.multiSelect === true,
+    options,
+    ...(record.allowFreeform === true ? { allowFreeform: true } : {}),
+  };
+}
+
+export function normalizeInteractivePrompt(raw: unknown): InteractivePrompt | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const promptId = readString(record.promptId);
+  const providerType = readString(record.providerType);
+  const origin = record.origin === 'mcp' || record.origin === 'agent' ? record.origin : 'cli';
+  const questions = Array.isArray(record.questions)
+    ? record.questions.map(normalizeQuestion).filter((item): item is InteractiveQuestion => !!item)
+    : [];
+  if (!promptId || !providerType || questions.length === 0) return null;
+  const createdAt = typeof record.createdAt === 'number' && Number.isFinite(record.createdAt)
+    ? record.createdAt
+    : Date.now();
+  return { promptId, origin, providerType, createdAt, questions };
+}
+
+export function normalizeInteractivePromptResponse(raw: unknown): InteractivePromptResponse {
+  if (!raw || typeof raw !== 'object') throw new Error('Interactive prompt response must be an object');
+  const record = raw as Record<string, unknown>;
+  const promptId = readString(record.promptId);
+  if (!promptId) throw new Error('promptId must be a non-empty string');
+  if (!record.answers || typeof record.answers !== 'object' || Array.isArray(record.answers)) {
+    throw new Error('answers must be an object');
+  }
+  const answers: Record<string, InteractiveAnswer> = {};
+  for (const [questionId, answerRaw] of Object.entries(record.answers as Record<string, unknown>)) {
+    if (!answerRaw || typeof answerRaw !== 'object' || Array.isArray(answerRaw)) continue;
+    const answer = answerRaw as Record<string, unknown>;
+    const selectedLabels = readStringArray(answer.selectedLabels);
+    const freeformText = readString(answer.freeformText);
+    answers[questionId] = {
+      selectedLabels,
+      ...(freeformText ? { freeformText } : {}),
+    };
+  }
+  return { promptId, answers };
+}
+
+export function buildClaudeInteractiveToolResult(response: InteractivePromptResponse): string {
+    return JSON.stringify({
+    type: 'user',
+    message: {
+      role: 'user',
+      content: [{
+        type: 'tool_result',
+        tool_use_id: response.promptId,
+        content: JSON.stringify({ answers: response.answers }),
+        is_error: false,
+      }],
+    },
+  });
+}
+
+export interface ClaudeInteractiveTuiPage {
+  screenText: string;
+  header?: string;
+}
+
+function claudeTuiQuestionHeaders(screenText: string): string[] {
+  const navLine = screenText.split(/\r?\n/).find(line => line.includes('✔ Submit') && /[☐☒]/.test(line));
+  if (!navLine) return [];
+  const headers: string[] = [];
+  const pattern = /[☐☒]\s+(.+?)(?=\s+[☐☒]|\s+✔\s+Submit)/g;
+  for (const match of navLine.matchAll(pattern)) {
+    const header = readString(match[1]);
+    if (header) headers.push(header);
+  }
+  return headers;
+}
+
+function parseClaudeInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index: number): InteractiveQuestion | null {
+  const lines = page.screenText.split(/\r?\n/);
+  let navIndex = -1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i].includes('✔ Submit') && /[☐☒]/.test(lines[i])) {
+      navIndex = i;
+      break;
+    }
+  }
+  if (navIndex < 0 || !page.screenText.includes('Enter to select')) return null;
+
+  let question = '';
+  let questionLineIndex = -1;
+  for (let i = navIndex + 1; i < lines.length; i += 1) {
+    const candidate = lines[i].trim();
+    if (!candidate || /^─+$/.test(candidate)) continue;
+    if (candidate === 'Review your answers' || candidate === 'Ready to submit your answers?') return null;
+    question = candidate;
+    questionLineIndex = i;
+    break;
+  }
+  if (!question) return null;
+
+  const options: InteractiveOption[] = [];
+  let allowFreeform = false;
+  const optionPattern = /^\s*(?:[❯›>]\s*)?(\d+)\.\s+(.+?)\s*$/;
+  for (let i = questionLineIndex + 1; i < lines.length; i += 1) {
+    const match = lines[i].match(optionPattern);
+    if (!match) continue;
+    const label = match[2].trim();
+    if (/^Type something\.?$/i.test(label)) {
+      allowFreeform = true;
+      continue;
+    }
+    if (/^Chat about this$/i.test(label)) continue;
+
+    let description: string | undefined;
+    const nextLine = lines[i + 1]?.trim();
+    if (nextLine
+      && !optionPattern.test(lines[i + 1])
+      && !/^─+$/.test(nextLine)
+      && !/^Enter to select\b/.test(nextLine)) {
+      description = nextLine;
+    }
+    options.push({ label, ...(description ? { description } : {}) });
+  }
+  if (options.length === 0) return null;
+
+  const header = readString(page.header);
+  return {
+    questionId: `q${index + 1}`,
+    question,
+    ...(header ? { header } : {}),
+    multiSelect: /Space to select|toggle selections/i.test(page.screenText),
+    options,
+    ...(allowFreeform ? { allowFreeform: true } : {}),
+  };
+}
+
+export function detectClaudeAskUserQuestionPromptFromTuiPages(
+  pages: ClaudeInteractiveTuiPage[],
+  options: { promptId: string; providerType?: string; createdAt?: number },
+): InteractivePrompt | null {
+  if (pages.length === 0) return null;
+  const headers = claudeTuiQuestionHeaders(pages[0].screenText);
+  const questions = pages.map((page, index) => parseClaudeInteractiveTuiQuestion({
+    ...page,
+    header: page.header || headers[index],
+  }, index)).filter((question): question is InteractiveQuestion => !!question);
+  if (questions.length !== pages.length) return null;
+  return {
+    promptId: options.promptId,
+    origin: 'cli',
+    providerType: options.providerType || 'claude-cli',
+    createdAt: options.createdAt || Date.now(),
+    questions,
+  };
+}
+
+export function buildClaudeInteractiveTuiAnswerSteps(
+  prompt: InteractivePrompt,
+  response: InteractivePromptResponse,
+): string[] {
+  if (response.promptId !== prompt.promptId) throw new Error('Interactive prompt response does not match active prompt');
+  const steps: string[] = [];
+  for (const question of prompt.questions) {
+    if (question.multiSelect) throw new Error('Claude TUI multi-select prompts are not supported yet');
+    const answer = response.answers[question.questionId];
+    if (!answer) throw new Error(`Missing answer for ${question.questionId}`);
+    if (answer.freeformText) throw new Error('Claude TUI freeform answers are not supported yet');
+    if (answer.selectedLabels.length !== 1) throw new Error(`Expected one selected label for ${question.questionId}`);
+    const selectedIndex = question.options.findIndex(option => option.label === answer.selectedLabels[0]);
+    if (selectedIndex < 0) throw new Error(`Unknown option for ${question.questionId}: ${answer.selectedLabels[0]}`);
+    steps.push(`${'\x1b[B'.repeat(selectedIndex)}\r`);
+  }
+  steps.push('\r');
+  return steps;
+}
+
+export function interactivePromptFromClaudeAskUserQuestion(input: unknown, options: {
+  promptId: string;
+  providerType: string;
+  createdAt?: number;
+  origin?: InteractivePrompt['origin'];
+}): InteractivePrompt | null {
+  if (!input || typeof input !== 'object') return null;
+  const record = input as Record<string, unknown>;
+  const questions = Array.isArray(record.questions)
+    ? record.questions.map(normalizeQuestion).filter((item): item is InteractiveQuestion => !!item)
+    : [];
+  if (questions.length === 0) return null;
+  return {
+    promptId: options.promptId,
+    origin: options.origin || 'cli',
+    providerType: options.providerType,
+    createdAt: options.createdAt || Date.now(),
+    questions,
+  };
+}
+
+export function detectClaudeAskUserQuestionPromptFromJson(value: unknown, providerType = 'claude-cli'): InteractivePrompt | null {
+  if (!value || typeof value !== 'object') return null;
+  const record = value as Record<string, unknown>;
+  const blocks: unknown[] = [];
+  if (Array.isArray(record.content)) blocks.push(...record.content);
+  const message = record.message;
+  if (message && typeof message === 'object' && Array.isArray((message as Record<string, unknown>).content)) {
+    blocks.push(...((message as Record<string, unknown>).content as unknown[]));
+  }
+  if (record.type === 'tool_use') blocks.push(record);
+
+  for (const block of blocks) {
+    if (!block || typeof block !== 'object') continue;
+    const b = block as Record<string, unknown>;
+    const name = readString(b.name);
+    if (b.type !== 'tool_use' || name !== 'AskUserQuestion') continue;
+    const id = readString(b.id) || readString(record.id) || `ask-user-${Date.now()}`;
+    const prompt = interactivePromptFromClaudeAskUserQuestion(b.input, {
+      promptId: id,
+      providerType,
+      origin: 'cli',
+    });
+    if (prompt) return prompt;
+  }
+  return null;
+}

package/src/providers/version-archive.ts

@@ -12,7 +12,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { execSync } from 'child_process';
+// Removed execSync import
 import { platform } from 'os';
 import type { ProviderLoader } from './provider-loader.js';
 import type { ProviderModule } from './contracts.js';
@@ -117,22 +117,40 @@ export class VersionArchive {
 
 // ─── Version Detection ──────────────────────────────
 
-function runCommand(cmd: string, timeout = 10000): string | null {
-  try {
-    return execSync(cmd, {
+import { exec } from 'child_process';
+
+async function runCommand(cmd: string, timeout = 10000): Promise<string | null> {
+  return new Promise((resolve) => {
+    exec(cmd, {
       encoding: 'utf-8',
       timeout,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-  } catch {
-    return null;
-  }
+    }, (error, stdout) => {
+      if (error) return resolve(null);
+      resolve(stdout.trim());
+    });
+  });
 }
 
 function findBinary(name: string): string | null {
-  const cmd = platform() === 'win32' ? `where ${name}` : `which ${name}`;
-  const result = runCommand(cmd, 5000);
-  return result ? result.split('\n')[0] : null;
+  const isWin = platform() === 'win32';
+  const paths = (process.env.PATH || '').split(isWin ? ';' : ':');
+  const exes = isWin ? ['.exe', '.cmd', '.bat', ''] : [''];
+  
+  for (const p of paths) {
+    if (!p) continue;
+    for (const ext of exes) {
+      const fullPath = path.join(p, name + ext);
+      try {
+        if (fs.existsSync(fullPath)) {
+          const stat = fs.statSync(fullPath);
+          if (stat.isFile() && (isWin || (stat.mode & 0o111))) {
+            return fullPath;
+          }
+        }
+      } catch { }
+    }
+  }
+  return null;
 }
 
 /** Extract version string from CLI output */
@@ -162,16 +180,16 @@ function getPlatformVersionCommand(
   return undefined;
 }
 
-function getVersion(binary: string, versionCommand?: string): string | null {
+async function getVersion(binary: string, versionCommand?: string): Promise<string | null> {
   // Custom version command from provider.json
   if (versionCommand) {
-    const raw = runCommand(versionCommand);
+    const raw = await runCommand(versionCommand);
     return raw ? parseVersion(raw) : null;
   }
 
   // Default: try --version, then -V, then -v
   for (const flag of ['--version', '-V', '-v']) {
-    const raw = runCommand(`"${binary}" ${flag}`);
+    const raw = await runCommand(`"${binary}" ${flag}`);
     if (raw && raw.length < 500) return parseVersion(raw);
   }
   return null;
@@ -191,11 +209,11 @@ function checkPathExists(paths: string[]): string | null {
 }
 
 /** macOS: Get app version from Info.plist */
-function getMacAppVersion(appPath: string): string | null {
+async function getMacAppVersion(appPath: string): Promise<string | null> {
   if (platform() !== 'darwin' || !appPath.endsWith('.app')) return null;
   const plistPath = path.join(appPath, 'Contents', 'Info.plist');
   if (!fs.existsSync(plistPath)) return null;
-  const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
+  const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
 
@@ -242,10 +260,10 @@ export async function detectAllVersions(
 
       // Version: try CLI first, then plist
       if (resolvedBin) {
-        info.version = getVersion(resolvedBin, versionCommand);
+        info.version = await getVersion(resolvedBin, versionCommand);
       }
       if (!info.version && appPath) {
-        info.version = getMacAppVersion(appPath);
+        info.version = await getMacAppVersion(appPath);
       }
 
     } else if (provider.category === 'cli' || provider.category === 'acp') {
@@ -256,7 +274,7 @@ export async function detectAllVersions(
       info.binary = binPath || null;
 
       if (binPath) {
-        info.version = getVersion(binPath, versionCommand);
+        info.version = await getVersion(binPath, versionCommand);
       }
 
     } else if (provider.category === 'extension') {

package/src/repo-mesh-types.ts

@@ -23,11 +23,42 @@ export interface RepoMesh {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     projectContext: ProjectContextSnapshot;
     nodes: RepoMeshNode[];
     status: 'active' | 'archived' | 'deleted';
 }
 
+export type RepoMeshDaemonRole = 'host' | 'member';
+
+export interface RepoMeshHostPairingMetadata {
+    status: 'not_configured' | 'pairing' | 'paired' | 'rejected' | 'revoked';
+    tokenId?: string;
+    joinedAt?: string;
+    lastPairedAt?: string;
+    lastRejectedAt?: string;
+    expiresAt?: string;
+}
+
+export interface RepoMeshHostMetadata {
+    /** Local daemon role for this mesh. Missing metadata defaults to host for standalone compatibility. */
+    role: RepoMeshDaemonRole;
+    /** Daemon that owns mesh truth/status/git/queue/session/ledger/coordinator ownership. */
+    hostDaemonId?: string;
+    /** Mesh node that represents the host daemon, when known. */
+    hostNodeId?: string;
+    /** Future standalone manual pairing endpoint entered by member daemons. */
+    hostAddress?: string;
+    /** Redacted pairing state only; raw join tokens must not be persisted here. */
+    pairing?: RepoMeshHostPairingMetadata;
+}
+
+export interface RepoMeshHostStatus extends RepoMeshHostMetadata {
+    canOwnCoordinator: boolean;
+    canOwnQueue: boolean;
+    defaulted: boolean;
+}
+
 export interface RepoMeshNode {
     id: string;
     daemonId: string;
@@ -42,6 +73,7 @@ export interface RepoMeshNode {
     effectiveCapabilities: RepoMeshNodeCapabilities;
     policy: RepoMeshNodePolicy;
     health: RepoMeshNodeHealth;
+    role?: RepoMeshDaemonRole;
     status: 'enabled' | 'disabled' | 'removed';
 }
 
@@ -62,6 +94,13 @@ export interface RepoMeshPolicy {
     requirePreTaskCheckpoint: boolean;
     requirePostTaskCheckpoint: boolean;
     requireApprovalForPush: boolean;
+    /**
+     * Narrow Refinery opt-in: when validation and patch-equivalence have passed,
+     * allow Refinery to publish submodule gitlink commits to each submodule's
+     * configured remote main branch with a non-force push, then verify reachability.
+     * Defaults to false; root branch pushes/merges are not affected.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
     requireApprovalForDestructiveGit: boolean;
     dirtyWorkspaceBehavior: 'block' | 'warn' | 'checkpoint_then_continue';
     maxParallelTasks: number;
@@ -126,6 +165,7 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     requirePreTaskCheckpoint: false,
     requirePostTaskCheckpoint: true,
     requireApprovalForPush: true,
+    allowAutoPublishSubmoduleMainCommits: false,
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,
@@ -207,7 +247,28 @@ export interface RepoMeshCoordinatorConfig {
     providerType?: string;
     /** Preferred node to run coordinator on (null = auto) */
     preferredNodeId?: string;
-    /** Additional system prompt context for coordinator */
+    /**
+     * Full mesh-level override for the coordinator system prompt. When set,
+     * replaces the daemon's rendered default and any user-file override
+     * (~/.adhdev/coordinator-prompts/<cli>.md). The per-launch
+     * extraSystemPrompt still composes on top — it always lands last as
+     * Additional Context. Supports the same {{placeholders}} the daemon's
+     * default template uses ({{meshName}}, {{repo}}, {{nodes}}, …).
+     */
+    systemPromptOverride?: string;
+    /**
+     * Mesh-level append. Composes after whichever base prompt won
+     * (override → user-file override → daemon default). Use this when you
+     * want extra rules for THIS mesh but otherwise the standard prompt is
+     * fine. Stacks with the user-file append (`<cli>.append.md`) — both
+     * apply if both are set.
+     */
+    systemPromptAppend?: string;
+    /**
+     * @deprecated Use systemPromptAppend. Kept as a fallback alias so
+     * existing meshes.json files keep working without a migration step;
+     * the daemon prefers systemPromptAppend when both are present.
+     */
     systemPromptSuffix?: string;
 }
 
@@ -229,6 +290,7 @@ export interface LocalMeshEntry {
     defaultBranch?: string;
     policy: RepoMeshPolicy;
     coordinator: RepoMeshCoordinatorConfig;
+    meshHost?: RepoMeshHostMetadata;
     nodes: LocalMeshNodeEntry[];
     createdAt: string;
     updatedAt: string;
@@ -243,14 +305,38 @@ export interface LocalMeshNodeEntry {
     machineId?: string;
     userOverrides: Partial<RepoMeshNodeCapabilities>;
     policy: RepoMeshNodePolicy;
+    /**
+     * Per-node instruction surfaced in the coordinator prompt so the LLM
+     * knows what each node is for (e.g. "this is the staging mirror — run
+     * only smoke tests here", or "use opus on this node, sonnet elsewhere").
+     * Empty/missing: omitted silently from the rendered prompt, no rule
+     * line about it gets added. The coordinator forwards/honors it when
+     * delegating; we don't enforce it at the daemon level.
+     */
+    systemPrompt?: string;
     /** For single-machine mesh: same daemon, different worktree */
     isLocalWorktree?: boolean;
     /** Branch this worktree tracks (set when created via clone_mesh_node) */
     worktreeBranch?: string;
     /** Node ID this worktree was cloned from */
     clonedFromNodeId?: string;
+    /** Repo-local preparation result for ADHDev-created worktree nodes. */
+    worktreeBootstrap?: {
+        status: 'ready' | 'running' | 'failed' | 'not_configured' | 'disabled' | 'stale';
+        required?: boolean;
+        configSource?: string;
+        configSourceType?: string;
+        startedAt?: string;
+        completedAt?: string;
+        lastCommand?: string;
+        exitCode?: number | null;
+        error?: string;
+        commandsRun?: Array<Record<string, unknown>>;
+        staleInputs?: string[];
+    };
     /** Optional associated/external repos configured as node metadata. */
     relatedRepos?: RepoMeshRelatedRepo[];
+    role?: RepoMeshDaemonRole;
 }
 
 // ─── Mesh Status (runtime, not persisted) ───────
@@ -261,6 +347,7 @@ export interface RepoMeshStatus {
     repoIdentity: string;
     defaultBranch?: string;
     refreshedAt: string;
+    meshHost?: RepoMeshHostStatus;
     nodes: RepoMeshNodeStatus[];
     queue?: RepoMeshQueueStatus;
     ledger?: RepoMeshLedgerStatus;
@@ -301,16 +388,28 @@ export interface RepoMeshNodeStatus {
     repoRoot?: string;
     daemonId?: string;
     machineId?: string;
+    role?: RepoMeshDaemonRole;
     machineStatus?: string;
     isLocalWorktree?: boolean;
     worktreeBranch?: string;
+    /** Mirrored from LocalMeshNodeEntry.systemPrompt for coordinator-prompt rendering. */
+    systemPrompt?: string;
     health: RepoMeshNodeHealth;
     git?: GitRepoStatus;
+    /**
+     * True when the selected coordinator has evidence that a peer git probe is still
+     * in flight or just timed out during initial mesh handshake, so callers should
+     * treat missing git data as pending instead of authoritative absence.
+     */
+    gitProbePending?: boolean;
     providers: string[];
     activeSessions: string[];
     activeSessionDetails?: RepoMeshSessionStatus[];
     providerPriority?: string[];
     launchReady?: boolean;
+    worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
+    launchBlockedReason?: string;
+    launchBlockedMessage?: string;
     lastSeenAt?: string;
     updatedAt?: string;
     connection?: RepoMeshPeerConnectionStatus;
@@ -405,3 +504,13 @@ export interface RepoMeshLedgerStatus {
     entries: RepoMeshLedgerEntryStatus[];
     summary: RepoMeshLedgerSummaryStatus;
 }
+
+// ─── Async Job Lifecycle ─────────────────────────
+// Shared base for all mesh async job types (refine jobs, bootstrap runs, etc.)
+// Each concrete type adds its own status enum and domain-specific fields.
+
+export interface MeshAsyncJobLifecycle {
+    startedAt?: string;
+    completedAt?: string;
+    error?: string;
+}

package/src/sessions/registry.ts

@@ -8,6 +8,9 @@ export interface SessionRuntimeTarget {
     cdpManagerKey?: string;
     adapterKey?: string;
     instanceKey?: string;
+    /** Wall clock at register time. native-history readers use it as a
+     *  cutoff so a fresh session can't show records from a prior one. */
+    spawnedAtMs?: number;
 }
 
 export class SessionRegistry {