@agimon-ai/doompi-task 0.0.1-alpha.2 → 0.0.1-alpha.21

package/dist/adapters/store/taskStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskStore.mjs","names":[],"sources":["../../../src/adapters/store/taskStore.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport { isProcessAlive } from '../../services/store/processLiveness.ts';\nimport { emptyDocument, STORE_SCHEMA_VERSION, type Task, type TaskDocument } from '../../services/store/types.ts';\nimport { TASK_EVENT, type TaskFailureReporter } from '../telemetry/logSinkTelemetry.ts';\nimport { lockPathFor, resolveStorePath, STORE_PATH_ENV, tempPathFor } from './paths.ts';\n\nconst LOCK_TIMEOUT_MS = 2000;\nconst LOCK_STALE_MS = 10_000;\nconst LOCK_RETRY_BASE_MS = 10;\nconst LOCK_RETRY_MAX_MS = 60;\nconst WATCH_DEBOUNCE_MS = 150;\nconst POLL_INTERVAL_MS = 2000;\nconst UTF8_ENCODING = 'utf8';\nconst MISSING_FILE_CODE = 'ENOENT';\nconst LOCK_EXISTS_CODE = 'EEXIST';\nconst STORE_PATH_ATTRIBUTE = 'store.path';\n\nexport type TaskStoreCommitListener = (previous: TaskDocument, committed: TaskDocument) => void;\n\nexport interface TaskStoreOptions {\n  cwd?: string;\n  env?: NodeJS.ProcessEnv;\n  storePath?: string;\n  onCommitted?: TaskStoreCommitListener;\n  /** Backstop poll cadence for change detection. Lowered in tests so they do\n   * not depend on `fs.watch`, whose delivery timing is platform-dependent. */\n  pollIntervalMs?: number;\n  /** How long to wait for the advisory lock before proceeding lock-free. */\n  lockTimeoutMs?: number;\n  /** Where swallowed failures go, so silent degradation stays visible. */\n  report?: TaskFailureReporter;\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Coerce arbitrary parsed JSON into a valid document.\n *\n * A corrupt or truncated store must not take the session down: the worst\n * acceptable outcome is starting from an empty list, never a crash on startup.\n */\nfunction normalizeDocument(parsed: unknown): TaskDocument {\n  if (!parsed || typeof parsed !== 'object') return emptyDocument();\n  const candidate = parsed as Partial<TaskDocument>;\n  if (!Array.isArray(candidate.tasks)) return emptyDocument();\n\n  const tasks = candidate.tasks.filter(\n    (task): task is Task => Boolean(task) && typeof task === 'object' && typeof (task as Task).id === 'number',\n  );\n  const maxId = tasks.reduce((max, task) => Math.max(max, task.id), 0);\n  return {\n    version: typeof candidate.version === 'number' ? candidate.version : STORE_SCHEMA_VERSION,\n    rev: typeof candidate.rev === 'number' ? candidate.rev : 0,\n    nextId: typeof candidate.nextId === 'number' && candidate.nextId > maxId ? candidate.nextId : maxId + 1,\n    tasks,\n  };\n}\n\n/**\n * File-backed task store shared by one root session and its delegated children.\n *\n * Durability model: the JSON file is the source of truth. Mutations are\n * read-modify-write under an advisory lock so concurrent delegated processes\n * cannot clobber each other, and writes land via temp-file rename so a\n * crash mid-write can never leave a partial document behind.\n */\nexport class TaskStore {\n  storePath: string;\n\n  private readonly cwd: string;\n  private readonly env: NodeJS.ProcessEnv;\n  private cached: TaskDocument = emptyDocument();\n  private lastKnownRev = -1;\n  private watcher?: fs.FSWatcher;\n  private pollTimer?: NodeJS.Timeout;\n  private debounceTimer?: NodeJS.Timeout;\n  private checkInFlight?: Promise<void>;\n  private checkQueued = false;\n  private watchGeneration = 0;\n  private readonly listeners = new Set<(document: TaskDocument) => void>();\n  private readonly pollIntervalMs: number;\n  private readonly lockTimeoutMs: number;\n  private readonly report?: TaskFailureReporter;\n  private readonly onCommitted?: TaskStoreCommitListener;\n\n  constructor(options: TaskStoreOptions = {}) {\n    this.cwd = options.cwd ?? process.cwd();\n    this.env = options.env ?? process.env;\n    this.storePath = options.storePath ?? resolveStorePath(this.cwd, this.env);\n    this.pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;\n    this.lockTimeoutMs = options.lockTimeoutMs ?? LOCK_TIMEOUT_MS;\n    this.report = options.report;\n    this.onCommitted = options.onCommitted;\n  }\n\n  /** Bind a default store to the current session tree before reading or watching it. */\n  configureSession(sessionKey: string): void {\n    if (this.env[STORE_PATH_ENV]?.trim()) return;\n    this.stopWatching();\n    this.storePath = resolveStorePath(this.cwd, this.env, sessionKey);\n    this.cached = emptyDocument();\n    this.lastKnownRev = -1;\n  }\n\n  /** Last document read from disk, without hitting the filesystem. */\n  get snapshot(): TaskDocument {\n    return this.cached;\n  }\n\n  read(): TaskDocument {\n    try {\n      const raw = fs.readFileSync(this.storePath, UTF8_ENCODING);\n      this.cached = normalizeDocument(JSON.parse(raw));\n    } catch (error) {\n      // A missing file is the normal state before the first write. Anything\n      // else means the task list just silently became empty, which is worth a\n      // record: unreadable or corrupt JSON looks identical to \"no tasks yet\".\n      if ((error as NodeJS.ErrnoException).code !== MISSING_FILE_CODE) {\n        this.report?.error(TASK_EVENT.storeReadFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });\n      }\n      this.cached = emptyDocument();\n    }\n    this.lastKnownRev = this.cached.rev;\n    return this.cached;\n  }\n\n  async readAsync(): Promise<TaskDocument> {\n    this.cached = await this.readDocumentAsync();\n    this.lastKnownRev = this.cached.rev;\n    return this.cached;\n  }\n\n  private async readDocumentAsync(): Promise<TaskDocument> {\n    try {\n      const raw = await fs.promises.readFile(this.storePath, UTF8_ENCODING);\n      return normalizeDocument(JSON.parse(raw));\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== MISSING_FILE_CODE) {\n        this.report?.error(TASK_EVENT.storeReadFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });\n      }\n      return emptyDocument();\n    }\n  }\n\n  /**\n   * Apply a mutation under the store lock.\n   *\n   * `mutate` receives the freshest on-disk document and returns either the next\n   * document to commit or `undefined` for a read-only action (list/get), which\n   * skips the write entirely so queries never bump `rev`.\n   */\n  async mutate<T>(\n    mutate: (document: TaskDocument) => { document?: TaskDocument; value: T },\n  ): Promise<{ document: TaskDocument; value: T }> {\n    const release = await this.acquireLock();\n    const outcome = (() => {\n      try {\n        const current = this.read();\n        const mutation = mutate(current);\n        if (!mutation.document) {\n          return { result: { document: current, value: mutation.value } };\n        }\n        const committed = this.write(mutation.document);\n        return {\n          result: { document: committed, value: mutation.value },\n          notification: { previous: current, committed },\n        };\n      } finally {\n        release();\n      }\n    })();\n    if (outcome.notification) {\n      this.notifyCommitted(outcome.notification.previous, outcome.notification.committed);\n    }\n    return outcome.result;\n  }\n\n  private notifyCommitted(previous: TaskDocument, committed: TaskDocument): void {\n    try {\n      this.onCommitted?.(previous, committed);\n    } catch (error) {\n      this.report?.error(TASK_EVENT.storeCommitListenerFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });\n    }\n  }\n\n  private write(document: TaskDocument): TaskDocument {\n    const next: TaskDocument = { ...document, version: STORE_SCHEMA_VERSION, rev: document.rev + 1 };\n    fs.mkdirSync(path.dirname(this.storePath), { recursive: true });\n    const temp = tempPathFor(this.storePath);\n    fs.writeFileSync(temp, `${JSON.stringify(next, undefined, 2)}\\n`, UTF8_ENCODING);\n    fs.renameSync(temp, this.storePath);\n    this.cached = next;\n    this.lastKnownRev = next.rev;\n    return next;\n  }\n\n  private async acquireLock(): Promise<() => void> {\n    const lockPath = lockPathFor(this.storePath);\n    fs.mkdirSync(path.dirname(this.storePath), { recursive: true });\n    const deadline = Date.now() + this.lockTimeoutMs;\n\n    for (;;) {\n      try {\n        const handle = fs.openSync(lockPath, 'wx');\n        fs.writeSync(handle, JSON.stringify({ pid: process.pid, time: Date.now() }));\n        fs.closeSync(handle);\n        return () => fs.rmSync(lockPath, { force: true });\n      } catch (error) {\n        if ((error as NodeJS.ErrnoException).code !== LOCK_EXISTS_CODE) throw error;\n        // The deadline is checked before breaking a stale lock so a peer that\n        // keeps recreating one cannot spin this loop without bound.\n        if (Date.now() >= deadline) {\n          // Proceeding lock-free beats stalling the agent: the rename is atomic,\n          // so the worst case is a lost concurrent update, not a corrupt file.\n          // Reported because a lost update here can strand a delegation.\n          this.report?.warn(\n            TASK_EVENT.storeLockTimeout,\n            new Error(`Task store lock still held after ${this.lockTimeoutMs}ms; proceeding without it`),\n            { [STORE_PATH_ATTRIBUTE]: this.storePath },\n          );\n          return () => {};\n        }\n        // Clearing a dead holder's lock still goes through the backoff. Yielding\n        // on every iteration is what stops a peer that keeps recreating the\n        // lock from turning this into a spin.\n        this.breakStaleLock(lockPath);\n        await sleep(LOCK_RETRY_BASE_MS + Math.random() * LOCK_RETRY_MAX_MS);\n      }\n    }\n  }\n\n  /** Remove a lock left behind by a dead process or one held implausibly long. */\n  private breakStaleLock(lockPath: string): boolean {\n    try {\n      const holder = JSON.parse(fs.readFileSync(lockPath, UTF8_ENCODING)) as { pid?: number; time?: number };\n      const expired = typeof holder.time === 'number' && Date.now() - holder.time > LOCK_STALE_MS;\n      const dead = typeof holder.pid === 'number' && !isProcessAlive(holder.pid);\n      if (!expired && !dead) return false;\n      fs.unlinkSync(lockPath);\n      return true;\n    } catch (error) {\n      // Losing the race to another breaker is normal; a persistent failure here\n      // shows up as the lock timeout above, so this stays a warning.\n      if ((error as NodeJS.ErrnoException).code !== MISSING_FILE_CODE) {\n        this.report?.warn(TASK_EVENT.storeLockBreakFailed, error, { [STORE_PATH_ATTRIBUTE]: lockPath });\n      }\n      return false;\n    }\n  }\n\n  /**\n   * Notify when another process changes the store.\n   *\n   * `fs.watch` alone is unreliable across the rename-based write (and on some\n   * network filesystems), so a slow poll backs it up. Writes made by this\n   * process are filtered out by revision so the UI does not redraw twice.\n   */\n  onExternalChange(listener: (document: TaskDocument) => void): () => void {\n    this.listeners.add(listener);\n    this.startWatching();\n    return () => {\n      this.listeners.delete(listener);\n      if (this.listeners.size === 0) this.stopWatching();\n    };\n  }\n\n  private startWatching(): void {\n    if (this.watcher || this.pollTimer) return;\n    this.watchGeneration += 1;\n    const directory = path.dirname(this.storePath);\n    const fileName = path.basename(this.storePath);\n\n    try {\n      fs.mkdirSync(directory, { recursive: true });\n      this.watcher = fs.watch(directory, (_event, changed) => {\n        if (changed && changed !== fileName) return;\n        this.scheduleCheck();\n      });\n    } catch (error) {\n      // Polling still covers change detection, just more slowly.\n      this.report?.warn(TASK_EVENT.storeWatchFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });\n    }\n\n    this.pollTimer = setInterval(() => this.queueChangeCheck(), this.pollIntervalMs);\n    this.pollTimer.unref?.();\n  }\n\n  private scheduleCheck(): void {\n    clearTimeout(this.debounceTimer);\n    this.debounceTimer = setTimeout(() => this.queueChangeCheck(), WATCH_DEBOUNCE_MS);\n    this.debounceTimer.unref?.();\n  }\n\n  private queueChangeCheck(): void {\n    if (this.checkInFlight) {\n      this.checkQueued = true;\n      return;\n    }\n    const generation = this.watchGeneration;\n    const execution = (async () => {\n      do {\n        this.checkQueued = false;\n        await this.checkForChange(generation);\n      } while (this.checkQueued && generation === this.watchGeneration);\n    })().finally(() => {\n      if (this.checkInFlight === execution) this.checkInFlight = undefined;\n    });\n    this.checkInFlight = execution;\n  }\n\n  private async checkForChange(generation: number): Promise<void> {\n    const previousRev = this.lastKnownRev;\n    const document = await this.readDocumentAsync();\n    if (generation !== this.watchGeneration) return;\n    if (this.lastKnownRev !== previousRev) {\n      this.checkQueued = true;\n      return;\n    }\n    this.cached = document;\n    this.lastKnownRev = document.rev;\n    if (document.rev === previousRev) return;\n    for (const listener of this.listeners) {\n      try {\n        listener(document);\n      } catch (error) {\n        // This runs from a timer and from the fs.watch callback, so an\n        // unguarded listener throw is an uncaught exception that takes the\n        // harness down rather than a handled render failure.\n        this.report?.error(TASK_EVENT.storeListenerFailed, error, { [STORE_PATH_ATTRIBUTE]: this.storePath });\n      }\n    }\n  }\n\n  private stopWatching(): void {\n    this.watchGeneration += 1;\n    this.checkQueued = false;\n    this.watcher?.close();\n    this.watcher = undefined;\n    if (this.pollTimer) clearInterval(this.pollTimer);\n    this.pollTimer = undefined;\n    clearTimeout(this.debounceTimer);\n    this.debounceTimer = undefined;\n  }\n\n  dispose(): void {\n    this.listeners.clear();\n    this.stopWatching();\n  }\n}\n"],"mappings":"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"}

package/dist/adapters/telemetry/logSinkTelemetry.cjs

@@ -0,0 +1,2 @@
+let e=require("@agimon-ai/doompi-telemetry");const t={notificationFailed:`doom_task.notification_failed`,storeReadFailed:`doom_task.store_read_failed`,storeLockTimeout:`doom_task.store_lock_timeout`,storeLockBreakFailed:`doom_task.store_lock_break_failed`,storeWatchFailed:`doom_task.store_watch_failed`,storeListenerFailed:`doom_task.store_listener_failed`,storeCommitListenerFailed:`doom_task.store_commit_listener_failed`,storeSweepFailed:`doom_task.store_sweep_failed`,sessionStartFailed:`doom_task.session_start_failed`,toolFailed:`doom_task.tool_failed`,delegationRequestFailed:`doom_task.delegation_request_failed`,delegationStartFailed:`doom_task.delegation_start_failed`,delegationResponseFailed:`doom_task.delegation_response_failed`,delegationSettleFailed:`doom_task.delegation_settle_failed`,delegationTimedOut:`doom_task.delegation_timed_out`,delegationOrphaned:`doom_task.delegation_orphaned`,delegationAssigned:`doom_task.delegation_assigned`,delegationCompleted:`doom_task.delegation_completed`};function n(n={}){let r=(0,e.createDoomTelemetry)({serviceName:`doom-task`,packageName:`@agimon-ai/doompi-task`,cwd:n.cwd,workspaceRoot:n.workspaceRoot,env:n.env,telemetryFactory:n.telemetryFactory,warn:n.warn,enableLogs:!0,enableTraces:!0});return{recordError:(e,t,n)=>r.recordError(e,t,n),recordWarning:(e,t,n)=>r.recordWarning(e,t,n),recordEvent:(e,t)=>r.recordEvent(e,t),recordNotificationError:(e,n)=>r.recordError(t.notificationFailed,e,{"task.id":n,"task.operation":`completion_notification`}),flush:()=>r.flush(),shutdown:()=>r.shutdown()}}function r(e){return{error:(t,n,r)=>void e.recordError(t,n,r),warn:(t,n,r)=>void e.recordWarning(t,n,r),event:(t,n)=>void e.recordEvent(t,n)}}exports.TASK_EVENT=t,exports.createTaskErrorReporter=n,exports.toFailureReporter=r;
+//# sourceMappingURL=logSinkTelemetry.cjs.map

package/dist/adapters/telemetry/logSinkTelemetry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logSinkTelemetry.cjs","names":["createDoomTelemetry"],"sources":["../../../src/adapters/telemetry/logSinkTelemetry.ts"],"sourcesContent":["import { createDoomTelemetry, type DoomTelemetry, type DoomTelemetryOptions } from '@agimon-ai/doompi-telemetry';\n\nconst SERVICE_NAME = 'doom-task';\nconst PACKAGE_NAME = '@agimon-ai/doompi-task';\nconst NOTIFICATION_OPERATION = 'completion_notification';\n\nexport const TASK_EVENT = {\n  notificationFailed: 'doom_task.notification_failed',\n  storeReadFailed: 'doom_task.store_read_failed',\n  storeLockTimeout: 'doom_task.store_lock_timeout',\n  storeLockBreakFailed: 'doom_task.store_lock_break_failed',\n  storeWatchFailed: 'doom_task.store_watch_failed',\n  storeListenerFailed: 'doom_task.store_listener_failed',\n  storeCommitListenerFailed: 'doom_task.store_commit_listener_failed',\n  storeSweepFailed: 'doom_task.store_sweep_failed',\n  sessionStartFailed: 'doom_task.session_start_failed',\n  toolFailed: 'doom_task.tool_failed',\n  delegationRequestFailed: 'doom_task.delegation_request_failed',\n  delegationStartFailed: 'doom_task.delegation_start_failed',\n  delegationResponseFailed: 'doom_task.delegation_response_failed',\n  delegationSettleFailed: 'doom_task.delegation_settle_failed',\n  delegationTimedOut: 'doom_task.delegation_timed_out',\n  delegationOrphaned: 'doom_task.delegation_orphaned',\n  // Info-level lifecycle events. These are the measurement pair: the shape of\n  // the brief that went out, and the cost of the run it produced.\n  delegationAssigned: 'doom_task.delegation_assigned',\n  delegationCompleted: 'doom_task.delegation_completed',\n} as const;\n\nexport type TaskEventName = (typeof TASK_EVENT)[keyof typeof TASK_EVENT];\nexport type TaskErrorAttributes = Record<string, string | number | boolean>;\nexport type TaskErrorSink = (event: TaskEventName, error: unknown, attributes?: TaskErrorAttributes) => void;\nexport type TaskEventSink = (event: TaskEventName, attributes?: TaskErrorAttributes) => void;\n\nexport interface TaskFailureReporter {\n  error: TaskErrorSink;\n  warn: TaskErrorSink;\n  /** Info-level event sink. Required so an unwired reporter fails to compile. */\n  event: TaskEventSink;\n}\n\nexport interface TaskErrorReporterOptions {\n  cwd?: string;\n  workspaceRoot?: string;\n  env?: NodeJS.ProcessEnv;\n  telemetryFactory?: NonNullable<DoomTelemetryOptions['telemetryFactory']>;\n  warn?: (message: string) => void;\n}\n\nexport interface TaskErrorReporter {\n  recordError(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;\n  recordWarning(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;\n  recordEvent(event: string, attributes?: TaskErrorAttributes): Promise<void>;\n  recordNotificationError(error: unknown, taskId: number): Promise<void>;\n  flush(): Promise<void>;\n  shutdown(): Promise<void>;\n}\n\nexport function createTaskErrorReporter(options: TaskErrorReporterOptions = {}): TaskErrorReporter {\n  const telemetry: DoomTelemetry = createDoomTelemetry({\n    serviceName: SERVICE_NAME,\n    packageName: PACKAGE_NAME,\n    cwd: options.cwd,\n    workspaceRoot: options.workspaceRoot,\n    env: options.env,\n    telemetryFactory: options.telemetryFactory,\n    warn: options.warn,\n    enableLogs: true,\n    enableTraces: true,\n  });\n  return {\n    recordError: (event, error, attributes) => telemetry.recordError(event, error, attributes),\n    recordWarning: (event, error, attributes) => telemetry.recordWarning(event, error, attributes),\n    recordEvent: (event, attributes) => telemetry.recordEvent(event, attributes),\n    recordNotificationError: (error, taskId) =>\n      telemetry.recordError(TASK_EVENT.notificationFailed, error, {\n        'task.id': taskId,\n        'task.operation': NOTIFICATION_OPERATION,\n      }),\n    flush: () => telemetry.flush(),\n    shutdown: () => telemetry.shutdown(),\n  };\n}\n\nexport function toFailureReporter(reporter: TaskErrorReporter): TaskFailureReporter {\n  return {\n    error: (event, error, attributes) => void reporter.recordError(event, error, attributes),\n    warn: (event, error, attributes) => void reporter.recordWarning(event, error, attributes),\n    event: (event, attributes) => void reporter.recordEvent(event, attributes),\n  };\n}\n"],"mappings":"6CAEA,MAIa,EAAa,CACxB,mBAAoB,gCACpB,gBAAiB,8BACjB,iBAAkB,+BAClB,qBAAsB,oCACtB,iBAAkB,+BAClB,oBAAqB,kCACrB,0BAA2B,yCAC3B,iBAAkB,+BAClB,mBAAoB,iCACpB,WAAY,wBACZ,wBAAyB,sCACzB,sBAAuB,oCACvB,yBAA0B,uCAC1B,uBAAwB,qCACxB,mBAAoB,iCACpB,mBAAoB,gCAGpB,mBAAoB,gCACpB,oBAAqB,gCACvB,EA+BA,SAAgB,EAAwB,EAAoC,CAAC,EAAsB,CACjG,IAAM,GAAA,EAA2BA,EAAAA,oBAAAA,CAAoB,CACnD,YAAa,YACb,YAAa,yBACb,IAAK,EAAQ,IACb,cAAe,EAAQ,cACvB,IAAK,EAAQ,IACb,iBAAkB,EAAQ,iBAC1B,KAAM,EAAQ,KACd,WAAY,GACZ,aAAc,EAChB,CAAC,EACD,MAAO,CACL,aAAc,EAAO,EAAO,IAAe,EAAU,YAAY,EAAO,EAAO,CAAU,EACzF,eAAgB,EAAO,EAAO,IAAe,EAAU,cAAc,EAAO,EAAO,CAAU,EAC7F,aAAc,EAAO,IAAe,EAAU,YAAY,EAAO,CAAU,EAC3E,yBAA0B,EAAO,IAC/B,EAAU,YAAY,EAAW,mBAAoB,EAAO,CAC1D,UAAW,EACX,iBAAkB,yBACpB,CAAC,EACH,UAAa,EAAU,MAAM,EAC7B,aAAgB,EAAU,SAAS,CACrC,CACF,CAEA,SAAgB,EAAkB,EAAkD,CAClF,MAAO,CACL,OAAQ,EAAO,EAAO,IAAe,KAAK,EAAS,YAAY,EAAO,EAAO,CAAU,EACvF,MAAO,EAAO,EAAO,IAAe,KAAK,EAAS,cAAc,EAAO,EAAO,CAAU,EACxF,OAAQ,EAAO,IAAe,KAAK,EAAS,YAAY,EAAO,CAAU,CAC3E,CACF"}

package/dist/adapters/telemetry/logSinkTelemetry.d.cts

@@ -0,0 +1,52 @@
+import { DoomTelemetryOptions } from "@agimon-ai/doompi-telemetry";
+//#region src/adapters/telemetry/logSinkTelemetry.d.ts
+declare const TASK_EVENT: {
+  readonly notificationFailed: "doom_task.notification_failed";
+  readonly storeReadFailed: "doom_task.store_read_failed";
+  readonly storeLockTimeout: "doom_task.store_lock_timeout";
+  readonly storeLockBreakFailed: "doom_task.store_lock_break_failed";
+  readonly storeWatchFailed: "doom_task.store_watch_failed";
+  readonly storeListenerFailed: "doom_task.store_listener_failed";
+  readonly storeCommitListenerFailed: "doom_task.store_commit_listener_failed";
+  readonly storeSweepFailed: "doom_task.store_sweep_failed";
+  readonly sessionStartFailed: "doom_task.session_start_failed";
+  readonly toolFailed: "doom_task.tool_failed";
+  readonly delegationRequestFailed: "doom_task.delegation_request_failed";
+  readonly delegationStartFailed: "doom_task.delegation_start_failed";
+  readonly delegationResponseFailed: "doom_task.delegation_response_failed";
+  readonly delegationSettleFailed: "doom_task.delegation_settle_failed";
+  readonly delegationTimedOut: "doom_task.delegation_timed_out";
+  readonly delegationOrphaned: "doom_task.delegation_orphaned";
+  readonly delegationAssigned: "doom_task.delegation_assigned";
+  readonly delegationCompleted: "doom_task.delegation_completed";
+};
+type TaskEventName = (typeof TASK_EVENT)[keyof typeof TASK_EVENT];
+type TaskErrorAttributes = Record<string, string | number | boolean>;
+type TaskErrorSink = (event: TaskEventName, error: unknown, attributes?: TaskErrorAttributes) => void;
+type TaskEventSink = (event: TaskEventName, attributes?: TaskErrorAttributes) => void;
+interface TaskFailureReporter {
+  error: TaskErrorSink;
+  warn: TaskErrorSink;
+  /** Info-level event sink. Required so an unwired reporter fails to compile. */
+  event: TaskEventSink;
+}
+interface TaskErrorReporterOptions {
+  cwd?: string;
+  workspaceRoot?: string;
+  env?: NodeJS.ProcessEnv;
+  telemetryFactory?: NonNullable<DoomTelemetryOptions['telemetryFactory']>;
+  warn?: (message: string) => void;
+}
+interface TaskErrorReporter {
+  recordError(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;
+  recordWarning(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;
+  recordEvent(event: string, attributes?: TaskErrorAttributes): Promise<void>;
+  recordNotificationError(error: unknown, taskId: number): Promise<void>;
+  flush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+declare function createTaskErrorReporter(options?: TaskErrorReporterOptions): TaskErrorReporter;
+declare function toFailureReporter(reporter: TaskErrorReporter): TaskFailureReporter;
+//#endregion
+export { TASK_EVENT, TaskErrorAttributes, TaskErrorReporter, TaskErrorReporterOptions, TaskErrorSink, TaskEventName, TaskEventSink, TaskFailureReporter, createTaskErrorReporter, toFailureReporter };
+//# sourceMappingURL=logSinkTelemetry.d.cts.map

package/dist/adapters/telemetry/logSinkTelemetry.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logSinkTelemetry.d.cts","names":[],"sources":["../../../src/adapters/telemetry/logSinkTelemetry.ts"],"mappings":";;cAMa;;;;;;;;;;;;;;;;;;;;KAuBD,wBAAwB,yBAAyB;KACjD,sBAAsB;KACtB,iBAAiB,OAAO,eAAe,gBAAgB,aAAa;KACpE,iBAAiB,OAAO,eAAe,aAAa;UAE/C;EACf,OAAO;EACP,MAAM;;EAEN,OAAO;;UAGQ;EACf;EACA;EACA,MAAM,OAAO;EACb,mBAAmB,YAAY;EAC/B,QAAQ;;UAGO;EACf,YAAY,eAAe,gBAAgB,aAAa,sBAAsB;EAC9E,cAAc,eAAe,gBAAgB,aAAa,sBAAsB;EAChF,YAAY,eAAe,aAAa,sBAAsB;EAC9D,wBAAwB,gBAAgB,iBAAiB;EACzD,SAAS;EACT,YAAY;;iBAGE,wBAAwB,UAAS,2BAAgC;iBA0BjE,kBAAkB,UAAU,oBAAoB"}

package/dist/adapters/telemetry/logSinkTelemetry.d.mts

@@ -0,0 +1,52 @@
+import { DoomTelemetryOptions } from "@agimon-ai/doompi-telemetry";
+//#region src/adapters/telemetry/logSinkTelemetry.d.ts
+declare const TASK_EVENT: {
+  readonly notificationFailed: "doom_task.notification_failed";
+  readonly storeReadFailed: "doom_task.store_read_failed";
+  readonly storeLockTimeout: "doom_task.store_lock_timeout";
+  readonly storeLockBreakFailed: "doom_task.store_lock_break_failed";
+  readonly storeWatchFailed: "doom_task.store_watch_failed";
+  readonly storeListenerFailed: "doom_task.store_listener_failed";
+  readonly storeCommitListenerFailed: "doom_task.store_commit_listener_failed";
+  readonly storeSweepFailed: "doom_task.store_sweep_failed";
+  readonly sessionStartFailed: "doom_task.session_start_failed";
+  readonly toolFailed: "doom_task.tool_failed";
+  readonly delegationRequestFailed: "doom_task.delegation_request_failed";
+  readonly delegationStartFailed: "doom_task.delegation_start_failed";
+  readonly delegationResponseFailed: "doom_task.delegation_response_failed";
+  readonly delegationSettleFailed: "doom_task.delegation_settle_failed";
+  readonly delegationTimedOut: "doom_task.delegation_timed_out";
+  readonly delegationOrphaned: "doom_task.delegation_orphaned";
+  readonly delegationAssigned: "doom_task.delegation_assigned";
+  readonly delegationCompleted: "doom_task.delegation_completed";
+};
+type TaskEventName = (typeof TASK_EVENT)[keyof typeof TASK_EVENT];
+type TaskErrorAttributes = Record<string, string | number | boolean>;
+type TaskErrorSink = (event: TaskEventName, error: unknown, attributes?: TaskErrorAttributes) => void;
+type TaskEventSink = (event: TaskEventName, attributes?: TaskErrorAttributes) => void;
+interface TaskFailureReporter {
+  error: TaskErrorSink;
+  warn: TaskErrorSink;
+  /** Info-level event sink. Required so an unwired reporter fails to compile. */
+  event: TaskEventSink;
+}
+interface TaskErrorReporterOptions {
+  cwd?: string;
+  workspaceRoot?: string;
+  env?: NodeJS.ProcessEnv;
+  telemetryFactory?: NonNullable<DoomTelemetryOptions['telemetryFactory']>;
+  warn?: (message: string) => void;
+}
+interface TaskErrorReporter {
+  recordError(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;
+  recordWarning(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;
+  recordEvent(event: string, attributes?: TaskErrorAttributes): Promise<void>;
+  recordNotificationError(error: unknown, taskId: number): Promise<void>;
+  flush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+declare function createTaskErrorReporter(options?: TaskErrorReporterOptions): TaskErrorReporter;
+declare function toFailureReporter(reporter: TaskErrorReporter): TaskFailureReporter;
+//#endregion
+export { TASK_EVENT, TaskErrorAttributes, TaskErrorReporter, TaskErrorReporterOptions, TaskErrorSink, TaskEventName, TaskEventSink, TaskFailureReporter, createTaskErrorReporter, toFailureReporter };
+//# sourceMappingURL=logSinkTelemetry.d.mts.map

package/dist/adapters/telemetry/logSinkTelemetry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logSinkTelemetry.d.mts","names":[],"sources":["../../../src/adapters/telemetry/logSinkTelemetry.ts"],"mappings":";;cAMa;;;;;;;;;;;;;;;;;;;;KAuBD,wBAAwB,yBAAyB;KACjD,sBAAsB;KACtB,iBAAiB,OAAO,eAAe,gBAAgB,aAAa;KACpE,iBAAiB,OAAO,eAAe,aAAa;UAE/C;EACf,OAAO;EACP,MAAM;;EAEN,OAAO;;UAGQ;EACf;EACA;EACA,MAAM,OAAO;EACb,mBAAmB,YAAY;EAC/B,QAAQ;;UAGO;EACf,YAAY,eAAe,gBAAgB,aAAa,sBAAsB;EAC9E,cAAc,eAAe,gBAAgB,aAAa,sBAAsB;EAChF,YAAY,eAAe,aAAa,sBAAsB;EAC9D,wBAAwB,gBAAgB,iBAAiB;EACzD,SAAS;EACT,YAAY;;iBAGE,wBAAwB,UAAS,2BAAgC;iBA0BjE,kBAAkB,UAAU,oBAAoB"}

package/dist/adapters/telemetry/logSinkTelemetry.mjs

@@ -0,0 +1,2 @@
+import{createDoomTelemetry as e}from"@agimon-ai/doompi-telemetry";const t={notificationFailed:`doom_task.notification_failed`,storeReadFailed:`doom_task.store_read_failed`,storeLockTimeout:`doom_task.store_lock_timeout`,storeLockBreakFailed:`doom_task.store_lock_break_failed`,storeWatchFailed:`doom_task.store_watch_failed`,storeListenerFailed:`doom_task.store_listener_failed`,storeCommitListenerFailed:`doom_task.store_commit_listener_failed`,storeSweepFailed:`doom_task.store_sweep_failed`,sessionStartFailed:`doom_task.session_start_failed`,toolFailed:`doom_task.tool_failed`,delegationRequestFailed:`doom_task.delegation_request_failed`,delegationStartFailed:`doom_task.delegation_start_failed`,delegationResponseFailed:`doom_task.delegation_response_failed`,delegationSettleFailed:`doom_task.delegation_settle_failed`,delegationTimedOut:`doom_task.delegation_timed_out`,delegationOrphaned:`doom_task.delegation_orphaned`,delegationAssigned:`doom_task.delegation_assigned`,delegationCompleted:`doom_task.delegation_completed`};function n(n={}){let r=e({serviceName:`doom-task`,packageName:`@agimon-ai/doompi-task`,cwd:n.cwd,workspaceRoot:n.workspaceRoot,env:n.env,telemetryFactory:n.telemetryFactory,warn:n.warn,enableLogs:!0,enableTraces:!0});return{recordError:(e,t,n)=>r.recordError(e,t,n),recordWarning:(e,t,n)=>r.recordWarning(e,t,n),recordEvent:(e,t)=>r.recordEvent(e,t),recordNotificationError:(e,n)=>r.recordError(t.notificationFailed,e,{"task.id":n,"task.operation":`completion_notification`}),flush:()=>r.flush(),shutdown:()=>r.shutdown()}}function r(e){return{error:(t,n,r)=>void e.recordError(t,n,r),warn:(t,n,r)=>void e.recordWarning(t,n,r),event:(t,n)=>void e.recordEvent(t,n)}}export{t as TASK_EVENT,n as createTaskErrorReporter,r as toFailureReporter};
+//# sourceMappingURL=logSinkTelemetry.mjs.map

package/dist/adapters/telemetry/logSinkTelemetry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logSinkTelemetry.mjs","names":[],"sources":["../../../src/adapters/telemetry/logSinkTelemetry.ts"],"sourcesContent":["import { createDoomTelemetry, type DoomTelemetry, type DoomTelemetryOptions } from '@agimon-ai/doompi-telemetry';\n\nconst SERVICE_NAME = 'doom-task';\nconst PACKAGE_NAME = '@agimon-ai/doompi-task';\nconst NOTIFICATION_OPERATION = 'completion_notification';\n\nexport const TASK_EVENT = {\n  notificationFailed: 'doom_task.notification_failed',\n  storeReadFailed: 'doom_task.store_read_failed',\n  storeLockTimeout: 'doom_task.store_lock_timeout',\n  storeLockBreakFailed: 'doom_task.store_lock_break_failed',\n  storeWatchFailed: 'doom_task.store_watch_failed',\n  storeListenerFailed: 'doom_task.store_listener_failed',\n  storeCommitListenerFailed: 'doom_task.store_commit_listener_failed',\n  storeSweepFailed: 'doom_task.store_sweep_failed',\n  sessionStartFailed: 'doom_task.session_start_failed',\n  toolFailed: 'doom_task.tool_failed',\n  delegationRequestFailed: 'doom_task.delegation_request_failed',\n  delegationStartFailed: 'doom_task.delegation_start_failed',\n  delegationResponseFailed: 'doom_task.delegation_response_failed',\n  delegationSettleFailed: 'doom_task.delegation_settle_failed',\n  delegationTimedOut: 'doom_task.delegation_timed_out',\n  delegationOrphaned: 'doom_task.delegation_orphaned',\n  // Info-level lifecycle events. These are the measurement pair: the shape of\n  // the brief that went out, and the cost of the run it produced.\n  delegationAssigned: 'doom_task.delegation_assigned',\n  delegationCompleted: 'doom_task.delegation_completed',\n} as const;\n\nexport type TaskEventName = (typeof TASK_EVENT)[keyof typeof TASK_EVENT];\nexport type TaskErrorAttributes = Record<string, string | number | boolean>;\nexport type TaskErrorSink = (event: TaskEventName, error: unknown, attributes?: TaskErrorAttributes) => void;\nexport type TaskEventSink = (event: TaskEventName, attributes?: TaskErrorAttributes) => void;\n\nexport interface TaskFailureReporter {\n  error: TaskErrorSink;\n  warn: TaskErrorSink;\n  /** Info-level event sink. Required so an unwired reporter fails to compile. */\n  event: TaskEventSink;\n}\n\nexport interface TaskErrorReporterOptions {\n  cwd?: string;\n  workspaceRoot?: string;\n  env?: NodeJS.ProcessEnv;\n  telemetryFactory?: NonNullable<DoomTelemetryOptions['telemetryFactory']>;\n  warn?: (message: string) => void;\n}\n\nexport interface TaskErrorReporter {\n  recordError(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;\n  recordWarning(event: string, error: unknown, attributes?: TaskErrorAttributes): Promise<void>;\n  recordEvent(event: string, attributes?: TaskErrorAttributes): Promise<void>;\n  recordNotificationError(error: unknown, taskId: number): Promise<void>;\n  flush(): Promise<void>;\n  shutdown(): Promise<void>;\n}\n\nexport function createTaskErrorReporter(options: TaskErrorReporterOptions = {}): TaskErrorReporter {\n  const telemetry: DoomTelemetry = createDoomTelemetry({\n    serviceName: SERVICE_NAME,\n    packageName: PACKAGE_NAME,\n    cwd: options.cwd,\n    workspaceRoot: options.workspaceRoot,\n    env: options.env,\n    telemetryFactory: options.telemetryFactory,\n    warn: options.warn,\n    enableLogs: true,\n    enableTraces: true,\n  });\n  return {\n    recordError: (event, error, attributes) => telemetry.recordError(event, error, attributes),\n    recordWarning: (event, error, attributes) => telemetry.recordWarning(event, error, attributes),\n    recordEvent: (event, attributes) => telemetry.recordEvent(event, attributes),\n    recordNotificationError: (error, taskId) =>\n      telemetry.recordError(TASK_EVENT.notificationFailed, error, {\n        'task.id': taskId,\n        'task.operation': NOTIFICATION_OPERATION,\n      }),\n    flush: () => telemetry.flush(),\n    shutdown: () => telemetry.shutdown(),\n  };\n}\n\nexport function toFailureReporter(reporter: TaskErrorReporter): TaskFailureReporter {\n  return {\n    error: (event, error, attributes) => void reporter.recordError(event, error, attributes),\n    warn: (event, error, attributes) => void reporter.recordWarning(event, error, attributes),\n    event: (event, attributes) => void reporter.recordEvent(event, attributes),\n  };\n}\n"],"mappings":"kEAEA,MAIa,EAAa,CACxB,mBAAoB,gCACpB,gBAAiB,8BACjB,iBAAkB,+BAClB,qBAAsB,oCACtB,iBAAkB,+BAClB,oBAAqB,kCACrB,0BAA2B,yCAC3B,iBAAkB,+BAClB,mBAAoB,iCACpB,WAAY,wBACZ,wBAAyB,sCACzB,sBAAuB,oCACvB,yBAA0B,uCAC1B,uBAAwB,qCACxB,mBAAoB,iCACpB,mBAAoB,gCAGpB,mBAAoB,gCACpB,oBAAqB,gCACvB,EA+BA,SAAgB,EAAwB,EAAoC,CAAC,EAAsB,CACjG,IAAM,EAA2B,EAAoB,CACnD,YAAa,YACb,YAAa,yBACb,IAAK,EAAQ,IACb,cAAe,EAAQ,cACvB,IAAK,EAAQ,IACb,iBAAkB,EAAQ,iBAC1B,KAAM,EAAQ,KACd,WAAY,GACZ,aAAc,EAChB,CAAC,EACD,MAAO,CACL,aAAc,EAAO,EAAO,IAAe,EAAU,YAAY,EAAO,EAAO,CAAU,EACzF,eAAgB,EAAO,EAAO,IAAe,EAAU,cAAc,EAAO,EAAO,CAAU,EAC7F,aAAc,EAAO,IAAe,EAAU,YAAY,EAAO,CAAU,EAC3E,yBAA0B,EAAO,IAC/B,EAAU,YAAY,EAAW,mBAAoB,EAAO,CAC1D,UAAW,EACX,iBAAkB,yBACpB,CAAC,EACH,UAAa,EAAU,MAAM,EAC7B,aAAgB,EAAU,SAAS,CACrC,CACF,CAEA,SAAgB,EAAkB,EAAkD,CAClF,MAAO,CACL,OAAQ,EAAO,EAAO,IAAe,KAAK,EAAS,YAAY,EAAO,EAAO,CAAU,EACvF,MAAO,EAAO,EAAO,IAAe,KAAK,EAAS,cAAc,EAAO,EAAO,CAAU,EACxF,OAAQ,EAAO,IAAe,KAAK,EAAS,YAAY,EAAO,CAAU,CAC3E,CACF"}

package/dist/commands/index.cjs

@@ -0,0 +1,2 @@
+const e=require("../schemas/task.cjs"),t=require("../tui/taskSpace.cjs");function n(n,r){n.registerCommand(e.COMMAND_NAME,{description:`Open Task Space for this session tree`,handler:async(n,i)=>{if(!i.hasUI){i.ui.notify(e.ERR_REQUIRES_INTERACTIVE,`error`);return}r.read(),await t.openTaskSpace(i,{store:r})}})}exports.registerTasksCommand=n;
+//# sourceMappingURL=index.cjs.map

package/dist/commands/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["COMMAND_NAME","ERR_REQUIRES_INTERACTIVE","openTaskSpace"],"sources":["../../src/commands/index.ts"],"sourcesContent":["import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';\nimport { COMMAND_NAME, ERR_REQUIRES_INTERACTIVE } from '../schemas/task.ts';\nimport type { TaskStore } from '../services/store/taskStore.ts';\nimport { openTaskSpace } from '../tui/taskSpace.ts';\n\n/**\n * `/tasks`, reachable from the leader palette as `SPC t t`.\n *\n * The command opens the Task Space overlay rather than printing a listing: the\n * overlay is the readable surface and it can edit, while a transcript dump could\n * only be read.\n */\nexport function registerTasksCommand(pi: ExtensionAPI, store: TaskStore): void {\n  pi.registerCommand(COMMAND_NAME, {\n    description: 'Open Task Space for this session tree',\n    handler: async (_args, ctx) => {\n      if (!ctx.hasUI) {\n        ctx.ui.notify(ERR_REQUIRES_INTERACTIVE, 'error');\n        return;\n      }\n\n      store.read();\n      await openTaskSpace(ctx, { store });\n    },\n  });\n}\n"],"mappings":"yEAYA,SAAgB,EAAqB,EAAkB,EAAwB,CAC7E,EAAG,gBAAgBA,EAAAA,aAAc,CAC/B,YAAa,wCACb,QAAS,MAAO,EAAO,IAAQ,CAC7B,GAAI,CAAC,EAAI,MAAO,CACd,EAAI,GAAG,OAAOC,EAAAA,yBAA0B,OAAO,EAC/C,MACF,CAEA,EAAM,KAAK,EACX,MAAMC,EAAAA,cAAc,EAAK,CAAE,OAAM,CAAC,CACpC,CACF,CAAC,CACH"}

package/dist/commands/index.d.cts

@@ -0,0 +1,15 @@
+import { TaskStore } from "../adapters/store/taskStore.cjs";
+import "../services/store/taskStore.cjs";
+import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+//#region src/commands/index.d.ts
+/**
+ * `/tasks`, reachable from the leader palette as `SPC t t`.
+ *
+ * The command opens the Task Space overlay rather than printing a listing: the
+ * overlay is the readable surface and it can edit, while a transcript dump could
+ * only be read.
+ */
+declare function registerTasksCommand(pi: ExtensionAPI, store: TaskStore): void;
+//#endregion
+export { registerTasksCommand };
+//# sourceMappingURL=index.d.cts.map

package/dist/commands/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/commands/index.ts"],"mappings":";;;;;;;;;;;iBAYgB,qBAAqB,IAAI,cAAc,OAAO"}

package/dist/commands/index.d.mts

@@ -0,0 +1,15 @@
+import { TaskStore } from "../adapters/store/taskStore.mjs";
+import "../services/store/taskStore.mjs";
+import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+//#region src/commands/index.d.ts
+/**
+ * `/tasks`, reachable from the leader palette as `SPC t t`.
+ *
+ * The command opens the Task Space overlay rather than printing a listing: the
+ * overlay is the readable surface and it can edit, while a transcript dump could
+ * only be read.
+ */
+declare function registerTasksCommand(pi: ExtensionAPI, store: TaskStore): void;
+//#endregion
+export { registerTasksCommand };
+//# sourceMappingURL=index.d.mts.map

package/dist/commands/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/commands/index.ts"],"mappings":";;;;;;;;;;;iBAYgB,qBAAqB,IAAI,cAAc,OAAO"}

package/dist/commands/index.mjs

@@ -0,0 +1,2 @@
+import{COMMAND_NAME as e,ERR_REQUIRES_INTERACTIVE as t}from"../schemas/task.mjs";import{openTaskSpace as n}from"../tui/taskSpace.mjs";function r(r,i){r.registerCommand(e,{description:`Open Task Space for this session tree`,handler:async(e,r)=>{if(!r.hasUI){r.ui.notify(t,`error`);return}i.read(),await n(r,{store:i})}})}export{r as registerTasksCommand};
+//# sourceMappingURL=index.mjs.map

package/dist/commands/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/commands/index.ts"],"sourcesContent":["import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';\nimport { COMMAND_NAME, ERR_REQUIRES_INTERACTIVE } from '../schemas/task.ts';\nimport type { TaskStore } from '../services/store/taskStore.ts';\nimport { openTaskSpace } from '../tui/taskSpace.ts';\n\n/**\n * `/tasks`, reachable from the leader palette as `SPC t t`.\n *\n * The command opens the Task Space overlay rather than printing a listing: the\n * overlay is the readable surface and it can edit, while a transcript dump could\n * only be read.\n */\nexport function registerTasksCommand(pi: ExtensionAPI, store: TaskStore): void {\n  pi.registerCommand(COMMAND_NAME, {\n    description: 'Open Task Space for this session tree',\n    handler: async (_args, ctx) => {\n      if (!ctx.hasUI) {\n        ctx.ui.notify(ERR_REQUIRES_INTERACTIVE, 'error');\n        return;\n      }\n\n      store.read();\n      await openTaskSpace(ctx, { store });\n    },\n  });\n}\n"],"mappings":"sIAYA,SAAgB,EAAqB,EAAkB,EAAwB,CAC7E,EAAG,gBAAgB,EAAc,CAC/B,YAAa,wCACb,QAAS,MAAO,EAAO,IAAQ,CAC7B,GAAI,CAAC,EAAI,MAAO,CACd,EAAI,GAAG,OAAO,EAA0B,OAAO,EAC/C,MACF,CAEA,EAAM,KAAK,EACX,MAAM,EAAc,EAAK,CAAE,OAAM,CAAC,CACpC,CACF,CAAC,CACH"}

package/dist/commands/task/promptGuidelines.cjs

@@ -0,0 +1,2 @@
+const e=["Use `task` for work with 3+ steps, when the user gives you a list of tasks, or immediately after receiving new instructions to capture requirements. Skip it for single trivial tasks and purely conversational requests.",`Capture a whole plan in one call: {"action":"upsert","tasks":[{"subject":"Research existing tool"},{"subject":"Write the reducer"},{"subject":"Add tests"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.`,`Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.`,`Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status "failed" or keep it in_progress and add a new task for the blocker in the same upsert.`,`When every non-deleted task is completed, review the full task list once more and call task {"action":"clear"} to close it. Do not leave an all-completed list open.`,`Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.`,`One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {"action":"upsert","tasks":[{"id":3,"status":"completed"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.`,`Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a "ref" and list the ref string in place of an id: [{"ref":"api","subject":"Design the API"},{"subject":"Implement the API","blockedBy":["api"]}]. A ref must be declared before it is used. Cycles are rejected.`,`upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.`,`Before assigning work, call subagent with {"action":"agents"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.`,`Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {"action":"assign","assignments":[{"id":1,"agent":"researcher"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.`,`A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.`,`Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.`,`After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.`,`When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.`,`If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.`,`assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {"action":"cancel","id":3} to stop a running delegation; the task returns to pending.`,`Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.`,`The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.`,`Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.`];exports.DEFAULT_PROMPT_GUIDELINES=e;
+//# sourceMappingURL=promptGuidelines.cjs.map

package/dist/commands/task/promptGuidelines.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptGuidelines.cjs","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"sourcesContent":["export const DEFAULT_PROMPT_GUIDELINES: string[] = [\n  'Use `task` for work with 3+ steps, when the user gives you a list of tasks, or immediately after receiving new instructions to capture requirements. Skip it for single trivial tasks and purely conversational requests.',\n  'Capture a whole plan in one call: {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Research existing tool\"},{\"subject\":\"Write the reducer\"},{\"subject\":\"Add tests\"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.',\n  'Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.',\n  'Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status \"failed\" or keep it in_progress and add a new task for the blocker in the same upsert.',\n  'When every non-deleted task is completed, review the full task list once more and call task {\"action\":\"clear\"} to close it. Do not leave an all-completed list open.',\n  \"Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.\",\n  'One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.',\n  'Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a \"ref\" and list the ref string in place of an id: [{\"ref\":\"api\",\"subject\":\"Design the API\"},{\"subject\":\"Implement the API\",\"blockedBy\":[\"api\"]}]. A ref must be declared before it is used. Cycles are rejected.',\n  'upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.',\n  'Before assigning work, call subagent with {\"action\":\"agents\"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.',\n  'Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {\"action\":\"assign\",\"assignments\":[{\"id\":1,\"agent\":\"researcher\"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.',\n  'A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.',\n  'Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.',\n  'After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.',\n  'When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.',\n  'If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.',\n  'assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {\"action\":\"cancel\",\"id\":3} to stop a running delegation; the task returns to pending.',\n  'Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.',\n  'The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.',\n  \"Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.\",\n];\n"],"mappings":"AAAA,MAAa,EAAsC,CACjD,4NACA,6XACA,ukBACA,mNACA,uKACA,kPACA,qXACA,0fACA,qTACA,sRACA,iuBACA,0MACA,4sBACA,yHACA,qNACA,8LACA,4LACA,+LACA,8KACA,uXACF"}

package/dist/commands/task/promptGuidelines.d.cts

@@ -0,0 +1,5 @@
+//#region src/commands/task/promptGuidelines.d.ts
+declare const DEFAULT_PROMPT_GUIDELINES: string[];
+//#endregion
+export { DEFAULT_PROMPT_GUIDELINES };
+//# sourceMappingURL=promptGuidelines.d.cts.map

package/dist/commands/task/promptGuidelines.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptGuidelines.d.cts","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"mappings":";cAAa"}

package/dist/commands/task/promptGuidelines.d.mts

@@ -0,0 +1,5 @@
+//#region src/commands/task/promptGuidelines.d.ts
+declare const DEFAULT_PROMPT_GUIDELINES: string[];
+//#endregion
+export { DEFAULT_PROMPT_GUIDELINES };
+//# sourceMappingURL=promptGuidelines.d.mts.map

package/dist/commands/task/promptGuidelines.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptGuidelines.d.mts","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"mappings":";cAAa"}

package/dist/commands/task/promptGuidelines.mjs

@@ -0,0 +1,2 @@
+const e=["Use `task` for work with 3+ steps, when the user gives you a list of tasks, or immediately after receiving new instructions to capture requirements. Skip it for single trivial tasks and purely conversational requests.",`Capture a whole plan in one call: {"action":"upsert","tasks":[{"subject":"Research existing tool"},{"subject":"Write the reducer"},{"subject":"Add tests"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.`,`Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.`,`Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status "failed" or keep it in_progress and add a new task for the blocker in the same upsert.`,`When every non-deleted task is completed, review the full task list once more and call task {"action":"clear"} to close it. Do not leave an all-completed list open.`,`Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.`,`One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {"action":"upsert","tasks":[{"id":3,"status":"completed"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.`,`Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a "ref" and list the ref string in place of an id: [{"ref":"api","subject":"Design the API"},{"subject":"Implement the API","blockedBy":["api"]}]. A ref must be declared before it is used. Cycles are rejected.`,`upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.`,`Before assigning work, call subagent with {"action":"agents"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.`,`Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {"action":"assign","assignments":[{"id":1,"agent":"researcher"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.`,`A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.`,`Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.`,`After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.`,`When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.`,`If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.`,`assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {"action":"cancel","id":3} to stop a running delegation; the task returns to pending.`,`Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.`,`The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.`,`Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.`];export{e as DEFAULT_PROMPT_GUIDELINES};
+//# sourceMappingURL=promptGuidelines.mjs.map

package/dist/commands/task/promptGuidelines.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptGuidelines.mjs","names":[],"sources":["../../../src/commands/task/promptGuidelines.ts"],"sourcesContent":["export const DEFAULT_PROMPT_GUIDELINES: string[] = [\n  'Use `task` for work with 3+ steps, when the user gives you a list of tasks, or immediately after receiving new instructions to capture requirements. Skip it for single trivial tasks and purely conversational requests.',\n  'Capture a whole plan in one call: {\"action\":\"upsert\",\"tasks\":[{\"subject\":\"Research existing tool\"},{\"subject\":\"Write the reducer\"},{\"subject\":\"Add tests\"}]}. Batch whenever you are writing the plan down — the initial list, a revised plan, or wiring dependencies across several tasks — because one call keeps ids and blockers consistent and shows the user the whole plan at once.',\n  'Do not batch parent progress. Mark a task in_progress with its own call BEFORE beginning work, and completed with its own call IMMEDIATELY when it is done. upsert accepts many tasks, but a batch of completions sent at the end of a turn is still wrong: upsert batching is for writing a plan down, single calls are for reporting progress, and the user watches the task list to see where you are. Native assignments[] fan-out is separate from progress reporting. Exactly one task should be in_progress for your own work; delegated tasks run in parallel and do not count against that.',\n  'Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors, use status \"failed\" or keep it in_progress and add a new task for the blocker in the same upsert.',\n  'When every non-deleted task is completed, review the full task list once more and call task {\"action\":\"clear\"} to close it. Do not leave an all-completed list open.',\n  \"Status is a state machine: pending → in_progress → completed, plus failed (recoverable, can go back to pending or in_progress) and deleted as a tombstone. Pass activeForm (present-continuous, e.g. 'writing tests') when marking in_progress.\",\n  'One call does both: an entry with an id changes that task, an entry without an id creates one. To change status, upsert the task by id, e.g. {\"action\":\"upsert\",\"tasks\":[{\"id\":3,\"status\":\"completed\"}]}. Never omit the id when you meant to change an existing task — an entry with no id creates a new one instead. An entry that carries an id and no other field is rejected.',\n  'Use blockedBy for dependencies (A is blocked by B). On an entry with no id pass blockedBy as the initial set; on an entry with an id use addBlockedBy / removeBlockedBy (additive merge, do not resend the full array). To depend on a task created earlier in the SAME call, give that earlier entry a \"ref\" and list the ref string in place of an id: [{\"ref\":\"api\",\"subject\":\"Design the API\"},{\"subject\":\"Implement the API\",\"blockedBy\":[\"api\"]}]. A ref must be declared before it is used. Cycles are rejected.',\n  'upsert applies each entry independently: the entries that pass are committed and the failures are reported with their array index. A failed entry changed nothing, so resend only the corrected failures — never resend the whole call, because an already-applied entry with no id would create a duplicate task.',\n  'Before assigning work, call subagent with {\"action\":\"agents\"} and match each task to an exact discovered agent name. Prefer a discovered general-purpose write-capable agent such as delegate or worker when no specialist fits. Use a focused inlineAgent only for read-only work.',\n  'Assign every unblocked pending task, including implementation tasks. Use assignments[] for every assign call, including one task: {\"action\":\"assign\",\"assignments\":[{\"id\":1,\"agent\":\"researcher\"}]}. Put all assign-time fields — including model, inlineAgent, instructions, relevantFiles, priorFindings, and context — inside each assignments[] entry; assign has no top-level single-task form. For two or more independent ready tasks, use one native batch instead of repeated calls. Do not wrap repeated task assign calls in multi_tool; assignments[] reduces tool overhead and returns one indexed result. Do not use a direct subagent run for work already represented in the shared task list, so ownership and terminal results stay visible.',\n  'A batched assign applies each entry independently. Successful entries are already running if another entry fails; retry only failed entries after correcting them, and never resend successful entries.',\n  'Hand over what you already know when you assign. Pass relevantFiles with the paths you have actually read or located for that task, and priorFindings with the facts you established: symbol names, call sites, the approach you picked, what you ruled out. A fresh-context child starts with none of your context and will otherwise spend most of its run re-reading the repo. It treats this verified pack as satisfying initial context exploration, reads known paths directly, and widens discovery only for a concrete missing dependency. Send at most a dozen files and only ones you really opened — a guessed path costs the child more than an omitted one — and keep priorFindings to a few lines of facts, not directives.',\n  'After assigning work, continue non-overlapping parent work or end your turn. Do not poll or duplicate delegated scope.',\n  'When a delegated task completes and unblocks another task, repeat agent discovery if needed and assign that newly eligible task promptly. Do not poll in a loop. Completion notifications wake the parent session.',\n  'If a child asks for a decision through intercom, or an assignment fails to start for another concrete issue, respond, rescope, or retry explicitly. Do not silently leave the task pending.',\n  'assign refuses tasks that are blocked, already delegated, or completed. Resolve blockers first. Use {\"action\":\"cancel\",\"id\":3} to stop a running delegation; the task returns to pending.',\n  'Doom Task records delegated lifecycle and results on the shared task. The child does not update task status directly. Read the completion or failure result before deciding what to do next.',\n  'The task list is scoped to this session tree: delegated subagents share it, while unrelated sessions start empty. It persists for later inspection until retention cleanup.',\n  \"Subject must be short and imperative (e.g. 'Research existing tool'); description is long-form detail written when you plan the task, and the delegated brief is that description plus the assign-time instructions, relevantFiles and priorFindings. Put durable scope in description and what you learned while exploring in the assign-time pack — do not repeat one in the other.\",\n];\n"],"mappings":"AAAA,MAAa,EAAsC,CACjD,4NACA,6XACA,ukBACA,mNACA,uKACA,kPACA,qXACA,0fACA,qTACA,sRACA,iuBACA,0MACA,4sBACA,yHACA,qNACA,8LACA,4LACA,+LACA,8KACA,uXACF"}

package/dist/commands/task/responseEnvelope.cjs

@@ -0,0 +1,7 @@
+const e=require("../../services/store/taskGraph.cjs"),t=`All tasks are completed. Review the full task list once more, then close it with task {"action":"clear"}.`,n=`The applied entries are committed. Resend only the failed entries, corrected — a failed entry changed nothing, so a corrected retry is safe. Do not resend an entry that already applied: an entry without an id creates a second task.`,r=`No task changed, so the whole call can be resent once corrected.`,i=`Successful assignments are already running. Retry only the failed entries after correcting their task state or arguments; do not resend successful entries.`;function a(e){if(e.length===1)return e[0].message;let t=e.filter(e=>e.ok).length,n=e.length-t,r=[`Assigned ${t}/${e.length} tasks${n>0?`; ${n} failed`:``}.`,...e.map(e=>e.ok?`- [${e.index}] Delegated #${e.id} to ${e.agent}`:`- [${e.index}] Failed #${e.id} → ${e.agent}: ${e.message}`)];return n>0&&t>0&&r.push(``,i),n===0&&r.push(``,`All assignments are running independently in the background. Continue non-overlapping work, or end your turn.`),r.join(`
+`)}function o(e){let t=e.blockedBy?.length?` ⛓ ${e.blockedBy.map(e=>`#${e}`).join(`,`)}`:``,n=e.status===`in_progress`&&e.activeForm?` (${e.activeForm})`:``,r=e.delegation&&e.delegation.state!==`cancelled`?` [${e.delegation.agent}]`:``;return`[${e.status}] #${e.id} ${e.subject}${n}${r}${t}`}function s(e){let t=e.delegation;if(!t)return[];let n=[`  delegated to: ${t.agent} (${t.state})`];return t.model&&n.push(`  model: ${t.model}`),t.result?.error&&n.push(`  error: ${t.result.error}`),t.result?.outputPath&&n.push(`  output file: ${t.result.outputPath}`),t.result?.output&&n.push(`  output: ${t.result.output}`),n}function c(t,n){let r=e.deriveBlocks(n.tasks).get(t.id)??[],i=[`#${t.id} [${t.status}] ${t.subject}`];return t.description&&i.push(`  description: ${t.description}`),t.activeForm&&i.push(`  activeForm: ${t.activeForm}`),t.blockedBy?.length&&i.push(`  blockedBy: ${t.blockedBy.map(e=>`#${e}`).join(`, `)}`),r.length&&i.push(`  blocks: ${r.map(e=>`#${e}`).join(`, `)}`),t.owner&&i.push(`  owner: ${t.owner}`),i.push(...s(t)),i.join(`
+`)}function l(e){switch(e.kind){case`created`:{let t=e.ref?` (ref "${e.ref}")`:``,n=e.blockedBy?.length?` — blocked by ${e.blockedBy.map(e=>`#${e}`).join(`, `)}`:``;return`Created #${e.id}${t}: ${e.subject} (${e.status})${n}`}case`updated`:{let t=e.fromStatus===e.toStatus?``:` (${e.fromStatus} -> ${e.toStatus})`;return`Updated #${e.id}${t}`}case`unchanged`:return`No change: #${e.id} already matches the requested values (status: ${e.status})`;case`failed`:return`Failed${e.id===void 0?``:` #${e.id}`}: ${e.message}`}}function u(e){return e.items.length===1?e.items[0].kind===`failed`?e.items[0].message:`no entry was applied`:[`no entry was applied.`,...e.items.map(e=>`- [${e.index}] ${l(e)}`),r].join(`
+`)}function d(r,i){switch(r.kind){case`upsert`:{let a=r.items.length===1?[l(r.items[0])]:[`Upsert applied ${r.applied}/${r.items.length} entries${r.failed>0?`; ${r.failed} failed`:``}.`,...r.items.map(e=>`- [${e.index}] ${l(e)}`),...r.failed>0?[``,n]:[]];return r.applied>0&&e.isTaskListComplete(i.tasks)&&a.push(t),a.join(`
+`)}case`delete`:return`Deleted #${r.id}: ${r.subject}`;case`clear`:return`Closed task list (cleared ${r.count} tasks)`;case`list`:{let e=i.tasks;return r.includeDeleted||(e=e.filter(e=>e.status!==`deleted`)),r.statusFilter&&(e=e.filter(e=>e.status===r.statusFilter)),e.length===0?`No tasks`:e.map(o).join(`
+`)}case`get`:return c(r.task,i);case`error`:return`Error: ${r.message}`}}function f(e,t,n,r){return{content:[{type:`text`,text:d(r,n)}],details:{action:e,params:t,tasks:n.tasks,nextId:n.nextId,rev:n.rev,...r.kind===`error`?{error:r.message}:{},...r.kind===`upsert`?{upsert:{applied:r.items.flatMap(e=>e.kind===`failed`?[]:[e.id]),failed:r.failed}}:{}}}}function p(e,t,n,r){return{content:[{type:`text`,text:n}],details:{action:`assign`,params:e,tasks:t.tasks,nextId:t.nextId,rev:t.rev,assignment:r}}}function m(e,t,n,r,i){return{content:[{type:`text`,text:i?`Error: ${i}`:r}],details:{action:e,params:t,tasks:n.tasks,nextId:n.nextId,rev:n.rev,...i?{error:i}:{}}}}exports.MSG_ALL_COMPLETE_CLEAR=t,exports.MSG_ASSIGN_PARTIAL=i,exports.MSG_UPSERT_NONE_APPLIED=r,exports.MSG_UPSERT_PARTIAL=n,exports.buildAssignmentResult=p,exports.buildTextResult=m,exports.buildToolResult=f,exports.formatAssignmentResults=a,exports.formatContent=d,exports.formatUpsertFailureText=u;
+//# sourceMappingURL=responseEnvelope.cjs.map

package/dist/commands/task/responseEnvelope.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseEnvelope.cjs","names":["deriveBlocks","isTaskListComplete"],"sources":["../../../src/commands/task/responseEnvelope.ts"],"sourcesContent":["import type { Op } from '../../services/store/reducer.ts';\nimport { deriveBlocks, isTaskListComplete } from '../../services/store/taskGraph.ts';\nimport type {\n  AssignmentSummary,\n  Task,\n  TaskAction,\n  TaskDetails,\n  TaskDocument,\n  TaskMutationParams,\n  UpsertItemOutcome,\n} from '../../services/store/types.ts';\n\nexport const MSG_ALL_COMPLETE_CLEAR =\n  'All tasks are completed. Review the full task list once more, then close it with task {\"action\":\"clear\"}.';\n\n/**\n * Steering for a mixed batch. Unlike a batch of spawned subagents, a failed\n * entry here had no side effect at all, so retrying the failures is the safe\n * move and the model must be told so or it will do nothing. The hazard is the\n * other half: resending an applied create would make a second task.\n */\nexport const MSG_UPSERT_PARTIAL =\n  'The applied entries are committed. Resend only the failed entries, corrected — a failed entry changed nothing, so a corrected retry is safe. Do not resend an entry that already applied: an entry without an id creates a second task.';\n\nexport const MSG_UPSERT_NONE_APPLIED = 'No task changed, so the whole call can be resent once corrected.';\n\nexport const MSG_ASSIGN_PARTIAL =\n  'Successful assignments are already running. Retry only the failed entries after correcting their task state or arguments; do not resend successful entries.';\n\nexport interface AssignmentItemResult {\n  index: number;\n  id: number;\n  agent: string;\n  ok: boolean;\n  message: string;\n}\n\n/** LLM-facing report for a native assignment batch. */\nexport function formatAssignmentResults(items: readonly AssignmentItemResult[]): string {\n  if (items.length === 1) return items[0].message;\n\n  const succeeded = items.filter((item) => item.ok).length;\n  const failed = items.length - succeeded;\n  const lines = [\n    `Assigned ${succeeded}/${items.length} tasks${failed > 0 ? `; ${failed} failed` : ''}.`,\n    ...items.map((item) =>\n      item.ok\n        ? `- [${item.index}] Delegated #${item.id} to ${item.agent}`\n        : `- [${item.index}] Failed #${item.id} → ${item.agent}: ${item.message}`,\n    ),\n  ];\n\n  if (failed > 0 && succeeded > 0) lines.push('', MSG_ASSIGN_PARTIAL);\n  if (failed === 0) {\n    lines.push(\n      '',\n      'All assignments are running independently in the background. Continue non-overlapping work, or end your turn.',\n    );\n  }\n  return lines.join('\\n');\n}\n\n/** `[status] #id subject (activeForm) [agent] ⛓ #dep` — the `list` line format. */\nfunction formatListLine(task: Task): string {\n  const block = task.blockedBy?.length ? ` ⛓ ${task.blockedBy.map((id) => `#${id}`).join(',')}` : '';\n  const form = task.status === 'in_progress' && task.activeForm ? ` (${task.activeForm})` : '';\n  const delegated = task.delegation && task.delegation.state !== 'cancelled' ? ` [${task.delegation.agent}]` : '';\n  return `[${task.status}] #${task.id} ${task.subject}${form}${delegated}${block}`;\n}\n\nfunction formatDelegationLines(task: Task): string[] {\n  const delegation = task.delegation;\n  if (!delegation) return [];\n\n  const lines = [`  delegated to: ${delegation.agent} (${delegation.state})`];\n  if (delegation.model) lines.push(`  model: ${delegation.model}`);\n  if (delegation.result?.error) lines.push(`  error: ${delegation.result.error}`);\n  if (delegation.result?.outputPath) lines.push(`  output file: ${delegation.result.outputPath}`);\n  if (delegation.result?.output) lines.push(`  output: ${delegation.result.output}`);\n  return lines;\n}\n\nfunction formatGetLines(task: Task, document: TaskDocument): string {\n  const blocks = deriveBlocks(document.tasks).get(task.id) ?? [];\n  const lines = [`#${task.id} [${task.status}] ${task.subject}`];\n  if (task.description) lines.push(`  description: ${task.description}`);\n  if (task.activeForm) lines.push(`  activeForm: ${task.activeForm}`);\n  if (task.blockedBy?.length) lines.push(`  blockedBy: ${task.blockedBy.map((id) => `#${id}`).join(', ')}`);\n  if (blocks.length) lines.push(`  blocks: ${blocks.map((id) => `#${id}`).join(', ')}`);\n  if (task.owner) lines.push(`  owner: ${task.owner}`);\n  lines.push(...formatDelegationLines(task));\n  return lines.join('\\n');\n}\n\n/** One entry's outcome. Batch lines prefix this with `- [n] `. */\nfunction formatUpsertItem(item: UpsertItemOutcome): string {\n  switch (item.kind) {\n    case 'created': {\n      const ref = item.ref ? ` (ref \"${item.ref}\")` : '';\n      const deps = item.blockedBy?.length ? ` — blocked by ${item.blockedBy.map((id) => `#${id}`).join(', ')}` : '';\n      return `Created #${item.id}${ref}: ${item.subject} (${item.status})${deps}`;\n    }\n    case 'updated': {\n      const transition = item.fromStatus === item.toStatus ? '' : ` (${item.fromStatus} -> ${item.toStatus})`;\n      return `Updated #${item.id}${transition}`;\n    }\n    case 'unchanged':\n      return `No change: #${item.id} already matches the requested values (status: ${item.status})`;\n    case 'failed':\n      return `Failed${item.id === undefined ? '' : ` #${item.id}`}: ${item.message}`;\n  }\n}\n\n/**\n * The thrown message when an upsert applied nothing. Kept separate from\n * `formatContent` because the caller wraps it in the actionable Options block\n * rather than returning it as a successful result.\n */\nexport function formatUpsertFailureText(op: Extract<Op, { kind: 'upsert' }>): string {\n  if (op.items.length === 1) return op.items[0].kind === 'failed' ? op.items[0].message : 'no entry was applied';\n  return [\n    'no entry was applied.',\n    ...op.items.map((item) => `- [${item.index}] ${formatUpsertItem(item)}`),\n    MSG_UPSERT_NONE_APPLIED,\n  ].join('\\n');\n}\n\n/**\n * Pure formatter: `(op, document) -> string`. The switch is closed over `Op`,\n * so a new reducer variant fails to compile until it is handled here.\n */\nexport function formatContent(op: Op, document: TaskDocument): string {\n  switch (op.kind) {\n    case 'upsert': {\n      // A batch of one is the common case and must not read like a bulk\n      // report, so it keeps the exact single-line shape it has always had.\n      const lines =\n        op.items.length === 1\n          ? [formatUpsertItem(op.items[0])]\n          : [\n              `Upsert applied ${op.applied}/${op.items.length} entries${op.failed > 0 ? `; ${op.failed} failed` : ''}.`,\n              ...op.items.map((item) => `- [${item.index}] ${formatUpsertItem(item)}`),\n              ...(op.failed > 0 ? ['', MSG_UPSERT_PARTIAL] : []),\n            ];\n      // Once, last, and only when something landed: emitting it per entry\n      // would repeat it for every completion in a batch.\n      if (op.applied > 0 && isTaskListComplete(document.tasks)) lines.push(MSG_ALL_COMPLETE_CLEAR);\n      return lines.join('\\n');\n    }\n    case 'delete':\n      return `Deleted #${op.id}: ${op.subject}`;\n    case 'clear':\n      return `Closed task list (cleared ${op.count} tasks)`;\n    case 'list': {\n      let view = document.tasks;\n      if (!op.includeDeleted) view = view.filter((task) => task.status !== 'deleted');\n      if (op.statusFilter) view = view.filter((task) => task.status === op.statusFilter);\n      return view.length === 0 ? 'No tasks' : view.map(formatListLine).join('\\n');\n    }\n    case 'get':\n      return formatGetLines(op.task, document);\n    case 'error':\n      return `Error: ${op.message}`;\n  }\n}\n\nexport interface ToolResult {\n  content: Array<{ type: 'text'; text: string }>;\n  details: TaskDetails;\n}\n\n/** Build the LLM-facing envelope. `details` carries the post-mutation snapshot. */\nexport function buildToolResult(\n  action: TaskAction,\n  params: TaskMutationParams,\n  document: TaskDocument,\n  op: Op,\n): ToolResult {\n  return {\n    content: [{ type: 'text', text: formatContent(op, document) }],\n    details: {\n      action,\n      params: params as Record<string, unknown>,\n      tasks: document.tasks,\n      nextId: document.nextId,\n      rev: document.rev,\n      ...(op.kind === 'error' ? { error: op.message } : {}),\n      // Deliberately no `error` on a partial success: renderResult treats\n      // `details.error` as total failure and would hide the rows for the\n      // entries that did land.\n      ...(op.kind === 'upsert'\n        ? {\n            upsert: {\n              applied: op.items.flatMap((item) => (item.kind === 'failed' ? [] : [item.id])),\n              failed: op.failed,\n            },\n          }\n        : {}),\n    },\n  };\n}\n\n/** Envelope for a native assignment batch, including ids used by the consolidated TUI result. */\nexport function buildAssignmentResult(\n  params: TaskMutationParams,\n  document: TaskDocument,\n  text: string,\n  assignment: AssignmentSummary,\n): ToolResult {\n  return {\n    content: [{ type: 'text', text }],\n    details: {\n      action: 'assign',\n      params: params as Record<string, unknown>,\n      tasks: document.tasks,\n      nextId: document.nextId,\n      rev: document.rev,\n      assignment,\n    },\n  };\n}\n\n/** Envelope for delegation actions, which do not flow through the reducer. */\nexport function buildTextResult(\n  action: TaskAction,\n  params: TaskMutationParams,\n  document: TaskDocument,\n  text: string,\n  error?: string,\n): ToolResult {\n  return {\n    content: [{ type: 'text', text: error ? `Error: ${error}` : text }],\n    details: {\n      action,\n      params: params as Record<string, unknown>,\n      tasks: document.tasks,\n      nextId: document.nextId,\n      rev: document.rev,\n      ...(error ? { error } : {}),\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/commands/task/responseEnvelope.d.cts

@@ -0,0 +1,51 @@
+import { AssignmentSummary, TaskAction, TaskDetails, TaskDocument, TaskMutationParams } from "../../services/store/types.cjs";
+import { Op } from "../../services/store/reducer.cjs";
+//#region src/commands/task/responseEnvelope.d.ts
+declare const MSG_ALL_COMPLETE_CLEAR = "All tasks are completed. Review the full task list once more, then close it with task {\"action\":\"clear\"}.";
+/**
+ * Steering for a mixed batch. Unlike a batch of spawned subagents, a failed
+ * entry here had no side effect at all, so retrying the failures is the safe
+ * move and the model must be told so or it will do nothing. The hazard is the
+ * other half: resending an applied create would make a second task.
+ */
+declare const MSG_UPSERT_PARTIAL = "The applied entries are committed. Resend only the failed entries, corrected — a failed entry changed nothing, so a corrected retry is safe. Do not resend an entry that already applied: an entry without an id creates a second task.";
+declare const MSG_UPSERT_NONE_APPLIED = "No task changed, so the whole call can be resent once corrected.";
+declare const MSG_ASSIGN_PARTIAL = "Successful assignments are already running. Retry only the failed entries after correcting their task state or arguments; do not resend successful entries.";
+interface AssignmentItemResult {
+  index: number;
+  id: number;
+  agent: string;
+  ok: boolean;
+  message: string;
+}
+/** LLM-facing report for a native assignment batch. */
+declare function formatAssignmentResults(items: readonly AssignmentItemResult[]): string;
+/**
+ * The thrown message when an upsert applied nothing. Kept separate from
+ * `formatContent` because the caller wraps it in the actionable Options block
+ * rather than returning it as a successful result.
+ */
+declare function formatUpsertFailureText(op: Extract<Op, {
+  kind: 'upsert';
+}>): string;
+/**
+ * Pure formatter: `(op, document) -> string`. The switch is closed over `Op`,
+ * so a new reducer variant fails to compile until it is handled here.
+ */
+declare function formatContent(op: Op, document: TaskDocument): string;
+interface ToolResult {
+  content: Array<{
+    type: 'text';
+    text: string;
+  }>;
+  details: TaskDetails;
+}
+/** Build the LLM-facing envelope. `details` carries the post-mutation snapshot. */
+declare function buildToolResult(action: TaskAction, params: TaskMutationParams, document: TaskDocument, op: Op): ToolResult;
+/** Envelope for a native assignment batch, including ids used by the consolidated TUI result. */
+declare function buildAssignmentResult(params: TaskMutationParams, document: TaskDocument, text: string, assignment: AssignmentSummary): ToolResult;
+/** Envelope for delegation actions, which do not flow through the reducer. */
+declare function buildTextResult(action: TaskAction, params: TaskMutationParams, document: TaskDocument, text: string, error?: string): ToolResult;
+//#endregion
+export { AssignmentItemResult, MSG_ALL_COMPLETE_CLEAR, MSG_ASSIGN_PARTIAL, MSG_UPSERT_NONE_APPLIED, MSG_UPSERT_PARTIAL, ToolResult, buildAssignmentResult, buildTextResult, buildToolResult, formatAssignmentResults, formatContent, formatUpsertFailureText };
+//# sourceMappingURL=responseEnvelope.d.cts.map

package/dist/commands/task/responseEnvelope.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseEnvelope.d.cts","names":[],"sources":["../../../src/commands/task/responseEnvelope.ts"],"mappings":";;;cAYa;;;;;;;cASA;cAGA;cAEA;UAGI;EACf;EACA;EACA;EACA;EACA;;;iBAIc,wBAAwB,gBAAgB;;;;;;iBAgFxC,wBAAwB,IAAI,QAAQ;EAAM;;;;;;iBAa1C,cAAc,IAAI,IAAI,UAAU;UAmC/B;EACf,SAAS;IAAQ;IAAc;;EAC/B,SAAS;;;iBAIK,gBACd,QAAQ,YACR,QAAQ,oBACR,UAAU,cACV,IAAI,KACH;;iBA0Ba,sBACd,QAAQ,oBACR,UAAU,cACV,cACA,YAAY,oBACX;;iBAea,gBACd,QAAQ,YACR,QAAQ,oBACR,UAAU,cACV,cACA,iBACC"}

package/dist/commands/task/responseEnvelope.d.mts

@@ -0,0 +1,51 @@
+import { AssignmentSummary, TaskAction, TaskDetails, TaskDocument, TaskMutationParams } from "../../services/store/types.mjs";
+import { Op } from "../../services/store/reducer.mjs";
+//#region src/commands/task/responseEnvelope.d.ts
+declare const MSG_ALL_COMPLETE_CLEAR = "All tasks are completed. Review the full task list once more, then close it with task {\"action\":\"clear\"}.";
+/**
+ * Steering for a mixed batch. Unlike a batch of spawned subagents, a failed
+ * entry here had no side effect at all, so retrying the failures is the safe
+ * move and the model must be told so or it will do nothing. The hazard is the
+ * other half: resending an applied create would make a second task.
+ */
+declare const MSG_UPSERT_PARTIAL = "The applied entries are committed. Resend only the failed entries, corrected — a failed entry changed nothing, so a corrected retry is safe. Do not resend an entry that already applied: an entry without an id creates a second task.";
+declare const MSG_UPSERT_NONE_APPLIED = "No task changed, so the whole call can be resent once corrected.";
+declare const MSG_ASSIGN_PARTIAL = "Successful assignments are already running. Retry only the failed entries after correcting their task state or arguments; do not resend successful entries.";
+interface AssignmentItemResult {
+  index: number;
+  id: number;
+  agent: string;
+  ok: boolean;
+  message: string;
+}
+/** LLM-facing report for a native assignment batch. */
+declare function formatAssignmentResults(items: readonly AssignmentItemResult[]): string;
+/**
+ * The thrown message when an upsert applied nothing. Kept separate from
+ * `formatContent` because the caller wraps it in the actionable Options block
+ * rather than returning it as a successful result.
+ */
+declare function formatUpsertFailureText(op: Extract<Op, {
+  kind: 'upsert';
+}>): string;
+/**
+ * Pure formatter: `(op, document) -> string`. The switch is closed over `Op`,
+ * so a new reducer variant fails to compile until it is handled here.
+ */
+declare function formatContent(op: Op, document: TaskDocument): string;
+interface ToolResult {
+  content: Array<{
+    type: 'text';
+    text: string;
+  }>;
+  details: TaskDetails;
+}
+/** Build the LLM-facing envelope. `details` carries the post-mutation snapshot. */
+declare function buildToolResult(action: TaskAction, params: TaskMutationParams, document: TaskDocument, op: Op): ToolResult;
+/** Envelope for a native assignment batch, including ids used by the consolidated TUI result. */
+declare function buildAssignmentResult(params: TaskMutationParams, document: TaskDocument, text: string, assignment: AssignmentSummary): ToolResult;
+/** Envelope for delegation actions, which do not flow through the reducer. */
+declare function buildTextResult(action: TaskAction, params: TaskMutationParams, document: TaskDocument, text: string, error?: string): ToolResult;
+//#endregion
+export { AssignmentItemResult, MSG_ALL_COMPLETE_CLEAR, MSG_ASSIGN_PARTIAL, MSG_UPSERT_NONE_APPLIED, MSG_UPSERT_PARTIAL, ToolResult, buildAssignmentResult, buildTextResult, buildToolResult, formatAssignmentResults, formatContent, formatUpsertFailureText };
+//# sourceMappingURL=responseEnvelope.d.mts.map

package/dist/commands/task/responseEnvelope.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseEnvelope.d.mts","names":[],"sources":["../../../src/commands/task/responseEnvelope.ts"],"mappings":";;;cAYa;;;;;;;cASA;cAGA;cAEA;UAGI;EACf;EACA;EACA;EACA;EACA;;;iBAIc,wBAAwB,gBAAgB;;;;;;iBAgFxC,wBAAwB,IAAI,QAAQ;EAAM;;;;;;iBAa1C,cAAc,IAAI,IAAI,UAAU;UAmC/B;EACf,SAAS;IAAQ;IAAc;;EAC/B,SAAS;;;iBAIK,gBACd,QAAQ,YACR,QAAQ,oBACR,UAAU,cACV,IAAI,KACH;;iBA0Ba,sBACd,QAAQ,oBACR,UAAU,cACV,cACA,YAAY,oBACX;;iBAea,gBACd,QAAQ,YACR,QAAQ,oBACR,UAAU,cACV,cACA,iBACC"}

package/dist/commands/task/responseEnvelope.mjs

@@ -0,0 +1,7 @@
+import{deriveBlocks as e,isTaskListComplete as t}from"../../services/store/taskGraph.mjs";const n=`All tasks are completed. Review the full task list once more, then close it with task {"action":"clear"}.`,r=`The applied entries are committed. Resend only the failed entries, corrected — a failed entry changed nothing, so a corrected retry is safe. Do not resend an entry that already applied: an entry without an id creates a second task.`,i=`No task changed, so the whole call can be resent once corrected.`,a=`Successful assignments are already running. Retry only the failed entries after correcting their task state or arguments; do not resend successful entries.`;function o(e){if(e.length===1)return e[0].message;let t=e.filter(e=>e.ok).length,n=e.length-t,r=[`Assigned ${t}/${e.length} tasks${n>0?`; ${n} failed`:``}.`,...e.map(e=>e.ok?`- [${e.index}] Delegated #${e.id} to ${e.agent}`:`- [${e.index}] Failed #${e.id} → ${e.agent}: ${e.message}`)];return n>0&&t>0&&r.push(``,a),n===0&&r.push(``,`All assignments are running independently in the background. Continue non-overlapping work, or end your turn.`),r.join(`
+`)}function s(e){let t=e.blockedBy?.length?` ⛓ ${e.blockedBy.map(e=>`#${e}`).join(`,`)}`:``,n=e.status===`in_progress`&&e.activeForm?` (${e.activeForm})`:``,r=e.delegation&&e.delegation.state!==`cancelled`?` [${e.delegation.agent}]`:``;return`[${e.status}] #${e.id} ${e.subject}${n}${r}${t}`}function c(e){let t=e.delegation;if(!t)return[];let n=[`  delegated to: ${t.agent} (${t.state})`];return t.model&&n.push(`  model: ${t.model}`),t.result?.error&&n.push(`  error: ${t.result.error}`),t.result?.outputPath&&n.push(`  output file: ${t.result.outputPath}`),t.result?.output&&n.push(`  output: ${t.result.output}`),n}function l(t,n){let r=e(n.tasks).get(t.id)??[],i=[`#${t.id} [${t.status}] ${t.subject}`];return t.description&&i.push(`  description: ${t.description}`),t.activeForm&&i.push(`  activeForm: ${t.activeForm}`),t.blockedBy?.length&&i.push(`  blockedBy: ${t.blockedBy.map(e=>`#${e}`).join(`, `)}`),r.length&&i.push(`  blocks: ${r.map(e=>`#${e}`).join(`, `)}`),t.owner&&i.push(`  owner: ${t.owner}`),i.push(...c(t)),i.join(`
+`)}function u(e){switch(e.kind){case`created`:{let t=e.ref?` (ref "${e.ref}")`:``,n=e.blockedBy?.length?` — blocked by ${e.blockedBy.map(e=>`#${e}`).join(`, `)}`:``;return`Created #${e.id}${t}: ${e.subject} (${e.status})${n}`}case`updated`:{let t=e.fromStatus===e.toStatus?``:` (${e.fromStatus} -> ${e.toStatus})`;return`Updated #${e.id}${t}`}case`unchanged`:return`No change: #${e.id} already matches the requested values (status: ${e.status})`;case`failed`:return`Failed${e.id===void 0?``:` #${e.id}`}: ${e.message}`}}function d(e){return e.items.length===1?e.items[0].kind===`failed`?e.items[0].message:`no entry was applied`:[`no entry was applied.`,...e.items.map(e=>`- [${e.index}] ${u(e)}`),i].join(`
+`)}function f(e,i){switch(e.kind){case`upsert`:{let a=e.items.length===1?[u(e.items[0])]:[`Upsert applied ${e.applied}/${e.items.length} entries${e.failed>0?`; ${e.failed} failed`:``}.`,...e.items.map(e=>`- [${e.index}] ${u(e)}`),...e.failed>0?[``,r]:[]];return e.applied>0&&t(i.tasks)&&a.push(n),a.join(`
+`)}case`delete`:return`Deleted #${e.id}: ${e.subject}`;case`clear`:return`Closed task list (cleared ${e.count} tasks)`;case`list`:{let t=i.tasks;return e.includeDeleted||(t=t.filter(e=>e.status!==`deleted`)),e.statusFilter&&(t=t.filter(t=>t.status===e.statusFilter)),t.length===0?`No tasks`:t.map(s).join(`
+`)}case`get`:return l(e.task,i);case`error`:return`Error: ${e.message}`}}function p(e,t,n,r){return{content:[{type:`text`,text:f(r,n)}],details:{action:e,params:t,tasks:n.tasks,nextId:n.nextId,rev:n.rev,...r.kind===`error`?{error:r.message}:{},...r.kind===`upsert`?{upsert:{applied:r.items.flatMap(e=>e.kind===`failed`?[]:[e.id]),failed:r.failed}}:{}}}}function m(e,t,n,r){return{content:[{type:`text`,text:n}],details:{action:`assign`,params:e,tasks:t.tasks,nextId:t.nextId,rev:t.rev,assignment:r}}}function h(e,t,n,r,i){return{content:[{type:`text`,text:i?`Error: ${i}`:r}],details:{action:e,params:t,tasks:n.tasks,nextId:n.nextId,rev:n.rev,...i?{error:i}:{}}}}export{n as MSG_ALL_COMPLETE_CLEAR,a as MSG_ASSIGN_PARTIAL,i as MSG_UPSERT_NONE_APPLIED,r as MSG_UPSERT_PARTIAL,m as buildAssignmentResult,h as buildTextResult,p as buildToolResult,o as formatAssignmentResults,f as formatContent,d as formatUpsertFailureText};
+//# sourceMappingURL=responseEnvelope.mjs.map

package/dist/commands/task/responseEnvelope.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"responseEnvelope.mjs","names":[],"sources":["../../../src/commands/task/responseEnvelope.ts"],"sourcesContent":["import type { Op } from '../../services/store/reducer.ts';\nimport { deriveBlocks, isTaskListComplete } from '../../services/store/taskGraph.ts';\nimport type {\n  AssignmentSummary,\n  Task,\n  TaskAction,\n  TaskDetails,\n  TaskDocument,\n  TaskMutationParams,\n  UpsertItemOutcome,\n} from '../../services/store/types.ts';\n\nexport const MSG_ALL_COMPLETE_CLEAR =\n  'All tasks are completed. Review the full task list once more, then close it with task {\"action\":\"clear\"}.';\n\n/**\n * Steering for a mixed batch. Unlike a batch of spawned subagents, a failed\n * entry here had no side effect at all, so retrying the failures is the safe\n * move and the model must be told so or it will do nothing. The hazard is the\n * other half: resending an applied create would make a second task.\n */\nexport const MSG_UPSERT_PARTIAL =\n  'The applied entries are committed. Resend only the failed entries, corrected — a failed entry changed nothing, so a corrected retry is safe. Do not resend an entry that already applied: an entry without an id creates a second task.';\n\nexport const MSG_UPSERT_NONE_APPLIED = 'No task changed, so the whole call can be resent once corrected.';\n\nexport const MSG_ASSIGN_PARTIAL =\n  'Successful assignments are already running. Retry only the failed entries after correcting their task state or arguments; do not resend successful entries.';\n\nexport interface AssignmentItemResult {\n  index: number;\n  id: number;\n  agent: string;\n  ok: boolean;\n  message: string;\n}\n\n/** LLM-facing report for a native assignment batch. */\nexport function formatAssignmentResults(items: readonly AssignmentItemResult[]): string {\n  if (items.length === 1) return items[0].message;\n\n  const succeeded = items.filter((item) => item.ok).length;\n  const failed = items.length - succeeded;\n  const lines = [\n    `Assigned ${succeeded}/${items.length} tasks${failed > 0 ? `; ${failed} failed` : ''}.`,\n    ...items.map((item) =>\n      item.ok\n        ? `- [${item.index}] Delegated #${item.id} to ${item.agent}`\n        : `- [${item.index}] Failed #${item.id} → ${item.agent}: ${item.message}`,\n    ),\n  ];\n\n  if (failed > 0 && succeeded > 0) lines.push('', MSG_ASSIGN_PARTIAL);\n  if (failed === 0) {\n    lines.push(\n      '',\n      'All assignments are running independently in the background. Continue non-overlapping work, or end your turn.',\n    );\n  }\n  return lines.join('\\n');\n}\n\n/** `[status] #id subject (activeForm) [agent] ⛓ #dep` — the `list` line format. */\nfunction formatListLine(task: Task): string {\n  const block = task.blockedBy?.length ? ` ⛓ ${task.blockedBy.map((id) => `#${id}`).join(',')}` : '';\n  const form = task.status === 'in_progress' && task.activeForm ? ` (${task.activeForm})` : '';\n  const delegated = task.delegation && task.delegation.state !== 'cancelled' ? ` [${task.delegation.agent}]` : '';\n  return `[${task.status}] #${task.id} ${task.subject}${form}${delegated}${block}`;\n}\n\nfunction formatDelegationLines(task: Task): string[] {\n  const delegation = task.delegation;\n  if (!delegation) return [];\n\n  const lines = [`  delegated to: ${delegation.agent} (${delegation.state})`];\n  if (delegation.model) lines.push(`  model: ${delegation.model}`);\n  if (delegation.result?.error) lines.push(`  error: ${delegation.result.error}`);\n  if (delegation.result?.outputPath) lines.push(`  output file: ${delegation.result.outputPath}`);\n  if (delegation.result?.output) lines.push(`  output: ${delegation.result.output}`);\n  return lines;\n}\n\nfunction formatGetLines(task: Task, document: TaskDocument): string {\n  const blocks = deriveBlocks(document.tasks).get(task.id) ?? [];\n  const lines = [`#${task.id} [${task.status}] ${task.subject}`];\n  if (task.description) lines.push(`  description: ${task.description}`);\n  if (task.activeForm) lines.push(`  activeForm: ${task.activeForm}`);\n  if (task.blockedBy?.length) lines.push(`  blockedBy: ${task.blockedBy.map((id) => `#${id}`).join(', ')}`);\n  if (blocks.length) lines.push(`  blocks: ${blocks.map((id) => `#${id}`).join(', ')}`);\n  if (task.owner) lines.push(`  owner: ${task.owner}`);\n  lines.push(...formatDelegationLines(task));\n  return lines.join('\\n');\n}\n\n/** One entry's outcome. Batch lines prefix this with `- [n] `. */\nfunction formatUpsertItem(item: UpsertItemOutcome): string {\n  switch (item.kind) {\n    case 'created': {\n      const ref = item.ref ? ` (ref \"${item.ref}\")` : '';\n      const deps = item.blockedBy?.length ? ` — blocked by ${item.blockedBy.map((id) => `#${id}`).join(', ')}` : '';\n      return `Created #${item.id}${ref}: ${item.subject} (${item.status})${deps}`;\n    }\n    case 'updated': {\n      const transition = item.fromStatus === item.toStatus ? '' : ` (${item.fromStatus} -> ${item.toStatus})`;\n      return `Updated #${item.id}${transition}`;\n    }\n    case 'unchanged':\n      return `No change: #${item.id} already matches the requested values (status: ${item.status})`;\n    case 'failed':\n      return `Failed${item.id === undefined ? '' : ` #${item.id}`}: ${item.message}`;\n  }\n}\n\n/**\n * The thrown message when an upsert applied nothing. Kept separate from\n * `formatContent` because the caller wraps it in the actionable Options block\n * rather than returning it as a successful result.\n */\nexport function formatUpsertFailureText(op: Extract<Op, { kind: 'upsert' }>): string {\n  if (op.items.length === 1) return op.items[0].kind === 'failed' ? op.items[0].message : 'no entry was applied';\n  return [\n    'no entry was applied.',\n    ...op.items.map((item) => `- [${item.index}] ${formatUpsertItem(item)}`),\n    MSG_UPSERT_NONE_APPLIED,\n  ].join('\\n');\n}\n\n/**\n * Pure formatter: `(op, document) -> string`. The switch is closed over `Op`,\n * so a new reducer variant fails to compile until it is handled here.\n */\nexport function formatContent(op: Op, document: TaskDocument): string {\n  switch (op.kind) {\n    case 'upsert': {\n      // A batch of one is the common case and must not read like a bulk\n      // report, so it keeps the exact single-line shape it has always had.\n      const lines =\n        op.items.length === 1\n          ? [formatUpsertItem(op.items[0])]\n          : [\n              `Upsert applied ${op.applied}/${op.items.length} entries${op.failed > 0 ? `; ${op.failed} failed` : ''}.`,\n              ...op.items.map((item) => `- [${item.index}] ${formatUpsertItem(item)}`),\n              ...(op.failed > 0 ? ['', MSG_UPSERT_PARTIAL] : []),\n            ];\n      // Once, last, and only when something landed: emitting it per entry\n      // would repeat it for every completion in a batch.\n      if (op.applied > 0 && isTaskListComplete(document.tasks)) lines.push(MSG_ALL_COMPLETE_CLEAR);\n      return lines.join('\\n');\n    }\n    case 'delete':\n      return `Deleted #${op.id}: ${op.subject}`;\n    case 'clear':\n      return `Closed task list (cleared ${op.count} tasks)`;\n    case 'list': {\n      let view = document.tasks;\n      if (!op.includeDeleted) view = view.filter((task) => task.status !== 'deleted');\n      if (op.statusFilter) view = view.filter((task) => task.status === op.statusFilter);\n      return view.length === 0 ? 'No tasks' : view.map(formatListLine).join('\\n');\n    }\n    case 'get':\n      return formatGetLines(op.task, document);\n    case 'error':\n      return `Error: ${op.message}`;\n  }\n}\n\nexport interface ToolResult {\n  content: Array<{ type: 'text'; text: string }>;\n  details: TaskDetails;\n}\n\n/** Build the LLM-facing envelope. `details` carries the post-mutation snapshot. */\nexport function buildToolResult(\n  action: TaskAction,\n  params: TaskMutationParams,\n  document: TaskDocument,\n  op: Op,\n): ToolResult {\n  return {\n    content: [{ type: 'text', text: formatContent(op, document) }],\n    details: {\n      action,\n      params: params as Record<string, unknown>,\n      tasks: document.tasks,\n      nextId: document.nextId,\n      rev: document.rev,\n      ...(op.kind === 'error' ? { error: op.message } : {}),\n      // Deliberately no `error` on a partial success: renderResult treats\n      // `details.error` as total failure and would hide the rows for the\n      // entries that did land.\n      ...(op.kind === 'upsert'\n        ? {\n            upsert: {\n              applied: op.items.flatMap((item) => (item.kind === 'failed' ? [] : [item.id])),\n              failed: op.failed,\n            },\n          }\n        : {}),\n    },\n  };\n}\n\n/** Envelope for a native assignment batch, including ids used by the consolidated TUI result. */\nexport function buildAssignmentResult(\n  params: TaskMutationParams,\n  document: TaskDocument,\n  text: string,\n  assignment: AssignmentSummary,\n): ToolResult {\n  return {\n    content: [{ type: 'text', text }],\n    details: {\n      action: 'assign',\n      params: params as Record<string, unknown>,\n      tasks: document.tasks,\n      nextId: document.nextId,\n      rev: document.rev,\n      assignment,\n    },\n  };\n}\n\n/** Envelope for delegation actions, which do not flow through the reducer. */\nexport function buildTextResult(\n  action: TaskAction,\n  params: TaskMutationParams,\n  document: TaskDocument,\n  text: string,\n  error?: string,\n): ToolResult {\n  return {\n    content: [{ type: 'text', text: error ? `Error: ${error}` : text }],\n    details: {\n      action,\n      params: params as Record<string, unknown>,\n      tasks: document.tasks,\n      nextId: document.nextId,\n      rev: document.rev,\n      ...(error ? { error } : {}),\n    },\n  };\n}\n"],"mappings":"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"}