mindwire 0.1.46 → 0.1.48

package/dist/target/index.d.ts

@@ -35,6 +35,8 @@ export interface TargetHandle {
     getToken?: TokenGetter;
     /** Release destination-owned resources (per the factory's `stopOnExit`). Idempotent. */
     stop(): Promise<void>;
+    /** Local process liveness when this target owns a daemon; remote targets use health(). */
+    isAlive?(): boolean;
 }
 /**
  * A destination for the mindwire daemon. Given a {@link ConnectSpec}, provision (or reuse) the
@@ -48,6 +50,10 @@ export interface Target {
     readonly name: string;
     connect(spec: ConnectSpec): Promise<TargetHandle>;
 }
+export interface LocalTarget extends Target {
+    /** v1 supports a private environment, separate host auth source, and an owned daemon lifetime. */
+    readonly profileVersion: number;
+}
 /**
  * The default destination: an **embedded** daemon on loopback. On a server runtime (Node/Bun/Deno)
  * `connect()` auto-spawns the bundled `mindwired` on a free `127.0.0.1` port and points the SDK at it,
@@ -55,9 +61,9 @@ export interface Target {
  *
  * Embedded daemons are memoized by config (see embedded.ts): two zero-config `local()` clients share
  * one loopback daemon (one environment), while `local({ cwd })` / `local({ statePath })` isolate into
- * their own. `stop()` is a **no-op** — the shared daemon is reaped on process exit (Risk 5).
+ * their own. Shared targets stay alive until host exit. With `shared: false`, close() stops the owned daemon.
  */
-export declare function local(opts?: EmbeddedOptions): Target;
+export declare function local(opts?: EmbeddedOptions): LocalTarget;
 /** Options for {@link remote}. */
 export interface RemoteOptions {
     /** Bearer token for the daemon, if it requires one. */

package/dist/types.d.ts

@@ -265,6 +265,59 @@ export type Support = "none" | "native" | "emulated";
 export type Protocol = "cli" | "http" | "persistent";
 /** How an agent emits a turn's output. */
 export type OutputMode = "structured_json" | "terminal";
+/** Voice exposed by the harness itself, independently of model input modalities. */
+export interface VoiceCapability {
+    mode: "conversation" | "dictation" | "none";
+    support: Support;
+    remote: boolean;
+    detail?: string;
+}
+export interface VoiceStatus {
+    capability: VoiceCapability;
+    available: boolean;
+    code?: string;
+    detail?: string;
+    voices?: string[];
+}
+export interface VoiceOptions {
+    clientId: string;
+    voice?: string;
+}
+export interface VoiceAudio {
+    /** Base64 PCM16 little-endian. Input batches are at most 500 ms. */
+    data: string;
+    sampleRate: number;
+    channels: number;
+}
+export interface VoiceEvent {
+    type: "connecting" | "ready" | "audio" | "transcript" | "listening" | "error" | "closed" | "heartbeat";
+    audio?: VoiceAudio;
+    text?: string;
+    role?: string;
+    itemId?: string;
+    final?: boolean;
+}
+/** A native action, settings selector, or command/skill. Route by kind; never send controls as text. */
+export interface HarnessCommand {
+    name: string;
+    label: string;
+    description?: string;
+    kind: "settings" | "compact" | "prompt" | "new_chat" | "history" | "rename";
+    aliases?: string[];
+    argumentHint?: string;
+    acceptsArguments?: boolean;
+    settingCanons?: string[];
+    requiresIdle?: boolean;
+    requiresSession?: boolean;
+}
+export interface CommandCatalog {
+    commands: HarnessCommand[];
+    warning?: string;
+}
+export interface CommandInvocation {
+    name: string;
+    arguments?: string;
+}
 /** Per-agent feature matrix. The core switches on some fields; the client reads the rest as UI hints. */
 export interface Capabilities {
     protocol: Protocol;
@@ -278,12 +331,18 @@ export interface Capabilities {
     cancel: boolean;
     persistent: boolean;
     models: boolean;
+    /** Native commands and settings selectors, discovered on demand. */
+    commands?: boolean;
     authLogout?: boolean;
     /**
      * Client hint: image attachments are delivered as true vision content (the model sees the image),
      * not just a path it must open with a Read tool. Attachments themselves are ungated.
      */
     imageInput: boolean;
+    /** Supports native audio for models whose inputModalities include audio; otherwise sends the original file. */
+    audioInput?: boolean;
+    /** Native voice interface exposed by the harness; unrelated to model audio files. */
+    voice?: VoiceCapability;
     /** User-in-loop ingress — each gates its route: answer an interaction, inject a follow-up, soft-stop. */
     respond: boolean;
     input: boolean;
@@ -597,6 +656,12 @@ export interface AuthMethod {
     /** Reuses the settings `Field` shape. */
     fields?: Field[];
     sections?: AuthSection[];
+    /** A native connection offered for explicit reuse. Contains display metadata, never credentials. */
+    existing?: ExistingAuthConnection;
+}
+export interface ExistingAuthConnection {
+    name: string;
+    model?: string;
 }
 /** The current step of an in-progress auth flow. */
 export interface AuthState {
@@ -682,6 +747,8 @@ export interface UserInput {
     error?: string;
 }
 export interface Message {
+    /** Explicit command selected by the user, when the native transcript or receipt identifies it. */
+    command?: CommandInvocation;
     id: string;
     chatId: string;
     /** `"system"` marks a non-conversational boundary such as a compaction marker. */
@@ -711,12 +778,20 @@ export interface MessagePage {
     hasMore: boolean;
     /** Pass as `before` to read the preceding page. */
     before?: string;
+    /** Opaque revision covering native files, fork ancestors and daemon history. */
+    revision?: string;
+    /** True when `ifRevision` still matches. Keep the existing messages and cursor. */
+    notModified?: boolean;
 }
 /**
  * Per-turn parameters distinct from the agent's sticky settings (persisted via `setConfig`). Passed
  * to {@link Mindwire.turn}; every field is optional, so a bare `{ chatId, message }` turn is unchanged.
  */
 export interface TurnOptions {
+    /** Execute a prompt/skill advertised by commands(); controls use compact() or setConfig(). */
+    command?: CommandInvocation;
+    /** Explicit native voice conversation. Prefer the client.voice.start helper. */
+    voice?: VoiceOptions;
     /**
      * Per-turn setting OVERRIDES addressed by canonical key (see {@link Field.canon}). Resolved
      * canon→the selected agent's key and filtered to declared non-secret keys server-side; overrides
@@ -1019,6 +1094,8 @@ export interface NotifyChannelTestResult {
 }
 /** `GET /healthz` — the daemon's liveness probe. */
 export interface Health {
+    /** Host connection reuse through the native authentication methods API. */
+    nativeAuthSource?: boolean;
     historyPageVersion?: number;
     surfaceProtocolVersion?: number;
     /** Opt-in Mac Screen Sharing through the existing paired SSH connection. */

package/dist/voice.d.ts

@@ -0,0 +1,37 @@
+import type { AgentScoped, Mindwire } from "./client.js";
+import type { Http } from "./http.js";
+import { Run } from "./run.js";
+import type { ProjectAuth } from "./workspace.js";
+import type { VoiceAudio, VoiceEvent, VoiceStatus } from "./types.js";
+/** Harness-native voice; independent from a coding model's audio-file modalities. */
+export declare class VoiceApi {
+    private readonly client;
+    constructor(client: Mindwire);
+    status(scoped?: AgentScoped): Promise<VoiceStatus>;
+    /** Start in an idle chat. Keep requestId/clientId when retrying a lost receipt. */
+    start(input: AgentScoped & {
+        chatId: string;
+        cwd?: string;
+        voice?: string;
+        requestId?: string;
+        clientId?: string;
+        gitAuth?: ProjectAuth;
+    }): Promise<VoiceSession>;
+}
+/** Ephemeral PCM stream. Ending voice leaves any started coding task running. */
+export declare class VoiceSession {
+    private readonly http;
+    readonly run: Run;
+    readonly clientId: string;
+    private sequence;
+    private sending;
+    private ended;
+    private streaming;
+    constructor(http: Http, run: Run, clientId: string);
+    private get path();
+    /** Await each ordered batch. No automatic audio replay after a network failure. */
+    appendAudio(audio: VoiceAudio, signal?: AbortSignal): Promise<void>;
+    /** Subscribe before sending audio; wait for ready. Breaking the loop ends voice. */
+    stream(signal?: AbortSignal): AsyncGenerator<VoiceEvent>;
+    stop(): Promise<void>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindwire",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "bin": {