@botbotgo/agent-harness 0.0.294 → 0.0.296

package/dist/client/acp.d.ts

@@ -0,0 +1,44 @@
+import { type AcpHttpClientOptions, type AcpStdioClient, type AcpStdioClientOptions } from "../acp.js";
+import type { Approval, OperatorOverview, RequestEvent, RequestTraceItem } from "../api.js";
+import type { CancelOptions, RequestSummary, RuntimeHealthSnapshot, SessionListSummary, SessionRecord, SessionSummary } from "../contracts/types.js";
+import type { HarnessClient, HarnessClientApprovalFilter, HarnessClientRequestFilter, HarnessClientRequestOptions, HarnessClientRequestResult, HarnessClientRequestStartOptions, HarnessClientStreamItem } from "./types.js";
+export type AcpHarnessTransport = Pick<AcpStdioClient, "request" | "subscribe" | "close">;
+export declare class AcpHarnessClient implements HarnessClient {
+    private readonly transport;
+    private streamSequence;
+    constructor(transport: AcpHarnessTransport);
+    request(options: HarnessClientRequestOptions): Promise<HarnessClientRequestResult>;
+    streamRequest(options: HarnessClientRequestStartOptions): AsyncGenerator<HarnessClientStreamItem>;
+    resolveApproval(options: Parameters<HarnessClient["resolveApproval"]>[0]): Promise<HarnessClientRequestResult>;
+    cancelRequest(options: CancelOptions): Promise<HarnessClientRequestResult>;
+    subscribe(listener: (event: RequestEvent) => void | Promise<void>): () => void;
+    listSessions(filter?: {
+        agentId?: string;
+        status?: RequestSummary["state"];
+    }): Promise<SessionSummary[]>;
+    listSessionSummaries(filter?: {
+        agentId?: string;
+        status?: RequestSummary["state"];
+    }): Promise<SessionListSummary[]>;
+    listRequests(filter?: HarnessClientRequestFilter): Promise<RequestSummary[]>;
+    getSession(sessionId: string): Promise<SessionRecord | null>;
+    getRequest(requestId: string): Promise<RequestSummary | null>;
+    listApprovals(filter?: HarnessClientApprovalFilter): Promise<Approval[]>;
+    getApproval(approvalId: string): Promise<Approval | null>;
+    listRequestEvents(input: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<RequestEvent[]>;
+    listRequestTraceItems(input: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<RequestTraceItem[]>;
+    getHealth(): Promise<RuntimeHealthSnapshot>;
+    getOperatorOverview(options?: {
+        limit?: number;
+    }): Promise<OperatorOverview>;
+    stop(): Promise<void>;
+}
+export declare function createAcpHarnessClient(transport: AcpHarnessTransport): HarnessClient;
+export declare function createAcpStdioHarnessClient(options: AcpStdioClientOptions): HarnessClient;
+export declare function createAcpHttpHarnessClient(options: AcpHttpClientOptions): HarnessClient;

package/dist/client/acp.js

@@ -0,0 +1,165 @@
+import { createAcpHttpClient, createAcpStdioClient, } from "../acp.js";
+function toEvent(notification) {
+    return notification.params.event;
+}
+function isRuntimeEventNotification(notification) {
+    return notification.method === "events.runtime";
+}
+function isStreamNotification(notification) {
+    return notification.method === "requests.stream";
+}
+export class AcpHarnessClient {
+    transport;
+    streamSequence = 0;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    request(options) {
+        return this.transport.request("requests.submit", options);
+    }
+    async *streamRequest(options) {
+        const streamId = `harness-stream-${++this.streamSequence}`;
+        const queued = [];
+        let notify;
+        let settled = false;
+        let streamedResult = false;
+        let responseResolved = false;
+        let failure;
+        let fallbackTimer;
+        const waitForItem = () => new Promise((resolve) => {
+            notify = resolve;
+        });
+        const push = (item) => {
+            queued.push(item);
+            notify?.();
+            notify = undefined;
+        };
+        const settle = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            notify?.();
+            notify = undefined;
+        };
+        const unsubscribe = this.transport.subscribe((notification) => {
+            if (!isStreamNotification(notification) || notification.params.streamId !== streamId) {
+                return;
+            }
+            if (notification.params.item.type === "result") {
+                streamedResult = true;
+                if (fallbackTimer) {
+                    clearTimeout(fallbackTimer);
+                    fallbackTimer = undefined;
+                }
+                if (responseResolved) {
+                    settle();
+                }
+            }
+            push(notification.params.item);
+        });
+        const resultPromise = this.transport.request("requests.submit", {
+            ...options,
+            streamId,
+        });
+        resultPromise
+            .then((result) => {
+            responseResolved = true;
+            if (streamedResult) {
+                settle();
+                return;
+            }
+            fallbackTimer = setTimeout(() => {
+                push({
+                    type: "result",
+                    result,
+                });
+                settle();
+            }, 50);
+        })
+            .catch((error) => {
+            failure = error;
+            settle();
+        })
+            .finally(() => undefined);
+        try {
+            while (!settled || queued.length > 0) {
+                if (queued.length === 0) {
+                    await waitForItem();
+                    continue;
+                }
+                const item = queued.shift();
+                if (item) {
+                    yield item;
+                }
+            }
+            if (failure) {
+                throw failure;
+            }
+        }
+        finally {
+            if (fallbackTimer) {
+                clearTimeout(fallbackTimer);
+            }
+            unsubscribe();
+        }
+    }
+    resolveApproval(options) {
+        return this.transport.request("approvals.resolve", options);
+    }
+    cancelRequest(options) {
+        return this.transport.request("requests.cancel", options);
+    }
+    subscribe(listener) {
+        return this.transport.subscribe((notification) => {
+            if (isRuntimeEventNotification(notification)) {
+                void listener(toEvent(notification));
+            }
+        });
+    }
+    listSessions(filter) {
+        return this.transport.request("sessions.list", filter);
+    }
+    listSessionSummaries(filter) {
+        return this.transport.request("sessions.summaries", filter);
+    }
+    listRequests(filter) {
+        return this.transport.request("requests.list", filter);
+    }
+    getSession(sessionId) {
+        return this.transport.request("sessions.get", { sessionId });
+    }
+    getRequest(requestId) {
+        return this.transport.request("requests.get", { requestId });
+    }
+    listApprovals(filter) {
+        return this.transport.request("approvals.list", filter);
+    }
+    getApproval(approvalId) {
+        return this.transport.request("approvals.get", { approvalId });
+    }
+    listRequestEvents(input) {
+        return this.transport.request("events.list", input);
+    }
+    listRequestTraceItems(input) {
+        return this.transport.request("requests.trace.list", input);
+    }
+    getHealth() {
+        return this.transport.request("runtime.health");
+    }
+    getOperatorOverview(options) {
+        return this.transport.request("runtime.overview", options);
+    }
+    stop() {
+        return this.transport.close();
+    }
+}
+export function createAcpHarnessClient(transport) {
+    return new AcpHarnessClient(transport);
+}
+export function createAcpStdioHarnessClient(options) {
+    return new AcpHarnessClient(createAcpStdioClient(options));
+}
+export function createAcpHttpHarnessClient(options) {
+    return new AcpHarnessClient(createAcpHttpClient(options));
+}

package/dist/client/in-process.d.ts

@@ -0,0 +1,44 @@
+import { cancelRequest, listSessionSummaries, listSessions, resolveApproval, subscribe, type CreateAgentHarnessOptions } from "../api.js";
+import type { AgentHarnessRuntime } from "../runtime/harness.js";
+import type { HarnessClient, HarnessClientApprovalFilter, HarnessClientRequestFilter, HarnessClientRequestOptions, HarnessClientRequestResult, HarnessClientRequestStartOptions, HarnessClientStreamItem } from "./types.js";
+export declare class InProcessHarnessClient implements HarnessClient {
+    readonly runtime: AgentHarnessRuntime;
+    constructor(runtime: AgentHarnessRuntime);
+    request(options: HarnessClientRequestOptions): Promise<HarnessClientRequestResult>;
+    streamRequest(options: HarnessClientRequestStartOptions): AsyncGenerator<HarnessClientStreamItem>;
+    resolveApproval(options: Parameters<typeof resolveApproval>[1]): Promise<HarnessClientRequestResult>;
+    cancelRequest(options: Parameters<typeof cancelRequest>[1]): Promise<HarnessClientRequestResult>;
+    subscribe(listener: Parameters<typeof subscribe>[1]): () => void;
+    listSessions(filter?: {
+        agentId?: string;
+        status?: Parameters<typeof listSessions>[1] extends infer T ? T extends {
+            status?: infer S;
+        } ? S : never : never;
+    }): Promise<import("../contracts/runtime.js").SessionSummary[]>;
+    listSessionSummaries(filter?: {
+        agentId?: string;
+        status?: Parameters<typeof listSessionSummaries>[1] extends infer T ? T extends {
+            status?: infer S;
+        } ? S : never : never;
+    }): Promise<import("../api.js").SessionListSummary[]>;
+    listRequests(filter?: HarnessClientRequestFilter): Promise<import("../contracts/runtime.js").SessionRequestRecord[]>;
+    getSession(sessionId: string): Promise<import("../contracts/runtime.js").SessionRecord | null>;
+    getRequest(requestId: string): Promise<import("../contracts/runtime.js").RequestRecord | null>;
+    listApprovals(filter?: HarnessClientApprovalFilter): Promise<import("../api.js").Approval[]>;
+    getApproval(approvalId: string): Promise<import("../api.js").Approval | null>;
+    listRequestEvents(input: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<import("../api.js").RequestEvent[]>;
+    listRequestTraceItems(input: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<import("../api.js").RequestTraceItem[]>;
+    getHealth(): Promise<import("../contracts/runtime.js").RuntimeHealthSnapshot>;
+    getOperatorOverview(options?: {
+        limit?: number;
+    }): Promise<import("../api.js").OperatorOverview>;
+    stop(): Promise<void>;
+}
+export declare function createInProcessHarnessClient(runtime: AgentHarnessRuntime): HarnessClient;
+export declare function createAgentHarnessClient(workspaceRoot?: string, options?: CreateAgentHarnessOptions): Promise<HarnessClient>;

package/dist/client/in-process.js

@@ -0,0 +1,69 @@
+import { cancelRequest, createAgentHarness, getApproval, getHealth, getOperatorOverview, getRequest, getSession, listApprovals, listRequestEvents, listRequests, listRequestTraceItems, listSessionSummaries, listSessions, request, resolveApproval, subscribe, stop, } from "../api.js";
+export class InProcessHarnessClient {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    request(options) {
+        return request(this.runtime, options);
+    }
+    async *streamRequest(options) {
+        for await (const item of this.runtime.streamEvents(options)) {
+            yield item;
+        }
+    }
+    resolveApproval(options) {
+        return resolveApproval(this.runtime, options);
+    }
+    cancelRequest(options) {
+        return cancelRequest(this.runtime, options);
+    }
+    subscribe(listener) {
+        return subscribe(this.runtime, listener);
+    }
+    listSessions(filter) {
+        return listSessions(this.runtime, filter);
+    }
+    listSessionSummaries(filter) {
+        return listSessionSummaries(this.runtime, filter);
+    }
+    listRequests(filter) {
+        return listRequests(this.runtime, filter);
+    }
+    getSession(sessionId) {
+        return getSession(this.runtime, sessionId);
+    }
+    getRequest(requestId) {
+        return getRequest(this.runtime, requestId);
+    }
+    listApprovals(filter) {
+        return listApprovals(this.runtime, filter);
+    }
+    getApproval(approvalId) {
+        return getApproval(this.runtime, approvalId);
+    }
+    listRequestEvents(input) {
+        return listRequestEvents(this.runtime, input);
+    }
+    listRequestTraceItems(input) {
+        return listRequestTraceItems(this.runtime, input);
+    }
+    getHealth() {
+        return getHealth(this.runtime);
+    }
+    getOperatorOverview(options) {
+        return getOperatorOverview(this.runtime, options);
+    }
+    async stop() {
+        await stop(this.runtime);
+    }
+}
+export function createInProcessHarnessClient(runtime) {
+    return new InProcessHarnessClient(runtime);
+}
+export async function createAgentHarnessClient(workspaceRoot, options) {
+    const runtime = workspaceRoot === undefined
+        ? await createAgentHarness()
+        : await createAgentHarness(workspaceRoot, options);
+    return new InProcessHarnessClient(runtime);
+}

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { AcpHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "./acp.js";
+export { InProcessHarnessClient, createAgentHarnessClient, createInProcessHarnessClient } from "./in-process.js";
+export type { HarnessClient, HarnessClientApprovalFilter, HarnessClientRequestFilter, HarnessClientRequestOptions, HarnessClientRequestResult, HarnessClientRequestStartOptions, HarnessClientStreamItem, } from "./types.js";
+export type { AcpHarnessTransport } from "./acp.js";

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export { AcpHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "./acp.js";
+export { InProcessHarnessClient, createAgentHarnessClient, createInProcessHarnessClient } from "./in-process.js";

package/dist/client/types.d.ts

@@ -0,0 +1,56 @@
+import type { Approval, OperatorOverview, PublicRequestListeners, PublicRequestOptions, PublicRequestResult, RequestEvent, RequestTraceItem } from "../api.js";
+import type { CancelOptions, HarnessStreamItem, InvocationEnvelope, MessageContent, RequestSummary, ResumeOptions, RuntimeHealthSnapshot, SessionListSummary, SessionRecord, SessionSummary } from "../contracts/types.js";
+export type HarnessClientRequestStartOptions = {
+    agentId?: string;
+    input: MessageContent;
+    sessionId?: string;
+    priority?: number;
+    invocation?: InvocationEnvelope;
+    listeners?: PublicRequestListeners;
+};
+export type HarnessClientRequestOptions = PublicRequestOptions;
+export type HarnessClientRequestResult = PublicRequestResult;
+export type HarnessClientStreamItem = HarnessStreamItem;
+export type HarnessClientRequestFilter = {
+    agentId?: string;
+    sessionId?: string;
+    state?: RequestSummary["state"];
+};
+export type HarnessClientApprovalFilter = {
+    status?: Approval["status"];
+    sessionId?: string;
+    requestId?: string;
+};
+export interface HarnessClient {
+    request(options: HarnessClientRequestOptions): Promise<HarnessClientRequestResult>;
+    streamRequest(options: HarnessClientRequestStartOptions): AsyncGenerator<HarnessClientStreamItem>;
+    resolveApproval(options: ResumeOptions): Promise<HarnessClientRequestResult>;
+    cancelRequest(options: CancelOptions): Promise<HarnessClientRequestResult>;
+    subscribe(listener: (event: RequestEvent) => void | Promise<void>): () => void;
+    listSessions(filter?: {
+        agentId?: string;
+        status?: RequestSummary["state"];
+    }): Promise<SessionSummary[]>;
+    listSessionSummaries(filter?: {
+        agentId?: string;
+        status?: RequestSummary["state"];
+    }): Promise<SessionListSummary[]>;
+    listRequests(filter?: HarnessClientRequestFilter): Promise<RequestSummary[]>;
+    getSession(sessionId: string): Promise<SessionRecord | null>;
+    getRequest(requestId: string): Promise<RequestSummary | null>;
+    listApprovals(filter?: HarnessClientApprovalFilter): Promise<Approval[]>;
+    getApproval(approvalId: string): Promise<Approval | null>;
+    listRequestEvents(input: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<RequestEvent[]>;
+    listRequestTraceItems(input: {
+        sessionId: string;
+        requestId: string;
+    }): Promise<RequestTraceItem[]>;
+    getHealth(): Promise<RuntimeHealthSnapshot>;
+    getOperatorOverview(options?: {
+        limit?: number;
+    }): Promise<OperatorOverview>;
+    stop(): Promise<void>;
+}

package/dist/client/types.js

@@ -0,0 +1 @@
+export {};

package/dist/client.d.ts

@@ -0,0 +1 @@
+export * from "./client/index.js";

package/dist/client.js

@@ -0,0 +1 @@
+export * from "./client/index.js";

package/dist/config/agents/orchestra.yaml

@@ -32,8 +32,14 @@ spec:
     - path: config/agent-context.md
   # Upstream execution feature: top-level host starts with no extra direct tool refs beyond discovered workspace tools.
   tools: []
-  # Upstream execution feature: top-level host starts with no explicit skill package refs in the default workspace.
-  skills: []
+  # Upstream execution feature: the starter runtime ships one host plus a small set of behavior skills so the
+  # first request already feels like real work instead of an empty shell.
+  skills:
+    - resource://skills/workspace-inspection
+    - resource://skills/safe-editing
+    - resource://skills/delegation-discipline
+    - resource://skills/approval-execution-policy
+    - resource://skills/completion-discipline
   # Upstream execution feature: subagent topology is empty in the repository default and can be filled in YAML.
   subagents: []
   # Upstream execution feature: host-level MCP servers are opt-in and empty by default.
@@ -79,13 +85,18 @@ spec:
   systemPrompt: |-
     You are the orchestra agent.
 
-    You are the default execution host.
+    You are the default execution host for a user-facing runtime.
+    The first request should feel like a capable working session, not a thin demo.
     Try to finish the request yourself before delegating.
     Use your own tools first when they are sufficient.
     Use your own skills first when they are sufficient.
     Delegate only when a subagent is a clearly better fit or when your own tools and skills are not enough.
     If neither you nor any suitable subagent can do the work, say so plainly.
 
+    Prefer visible progress over abstract planning. When the request is about this workspace, inspect the workspace
+    before answering. When the request would be improved by a concrete edit or command, do the smallest safe action
+    that moves the work forward instead of only describing what you might do.
+
     Do not delegate by reflex.
     Do not delegate just because a task has multiple steps.
     Do not delegate when a direct answer or a short local tool pass is enough.
@@ -95,6 +106,8 @@ spec:
     Use your own tools for lightweight discovery, inventory, and context gathering.
     Prefer the structured checkout, indexing, retrieval, and inventory tools that are already attached to you over
     ad hoc shell work when those tools are sufficient.
+    Keep answers crisp, concrete, and usable. Close the loop: explain what you inspected, what you changed, what you
+    verified, and what still needs approval or follow-up.
     Use the attached subagent descriptions as the source of truth for what each subagent is for.
     Do not delegate to a subagent whose description does not clearly match the task.
     Integrate subagent results into one coherent answer and do not claim checks or evidence you did not obtain.

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
+export { AcpHarnessClient, InProcessHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient, createAgentHarnessClient, createInProcessHarnessClient, } from "./client.js";
 export { createKnowledgeModule, readKnowledgeRuntimeConfig } from "./knowledge/index.js";
-export type { AcpApproval, AcpArtifact, AcpEventNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRequestParams, AcpServerCapabilities, AcpSessionRecord, AcpStdioClient, AcpStdioClientOptions, } from "./acp.js";
-export type { Approval, ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, OperatorOverview, RecordArtifactInput, PublicRequestListeners, RequestArtifactListing, RequestEvent, RequestEventType, RequestPackage, RequestPackageInput, RequestFlowGraphInput, RequestResult, RequestTraceItem, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, SessionListSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, UpdateMemoryInput, UserChatInput, UserChatMessage, } from "./api.js";
+export type { AcpApproval, AcpHttpClient, AcpHttpClientOptions, AcpArtifact, AcpEventNotification, AcpNotification, AcpJsonRpcError, AcpJsonRpcRequest, AcpJsonRpcResponse, AcpJsonRpcSuccess, AcpRequestRecord, AcpRequestParams, AcpServerCapabilities, AcpSessionRecord, AcpStreamNotification, AcpStdioClient, AcpStdioClientOptions, } from "./acp.js";
+export type { Approval, CreateAgentHarnessOptions, ListMemoriesInput, ListMemoriesResult, MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, OperatorOverview, RecordArtifactInput, PublicRequestListeners, RequestArtifactListing, RequestEvent, RequestEventType, RequestPackage, RequestPackageInput, RequestFlowGraphInput, RequestResult, RequestTraceItem, RecallInput, RecallResult, RemoveMemoryInput, RuntimeEvaluationExport, RuntimeEvaluationExportInput, RuntimeEvaluationReplayInput, RuntimeEvaluationReplayResult, SessionListSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, UpdateMemoryInput, UserChatInput, UserChatMessage, } from "./api.js";
+export type { AcpHarnessTransport, HarnessClient, HarnessClientApprovalFilter, HarnessClientRequestFilter, HarnessClientRequestOptions, HarnessClientRequestResult, HarnessClientRequestStartOptions, HarnessClientStreamItem, } from "./client.js";
 export type { KnowledgeListInput, KnowledgeMemorizeInput, KnowledgeModule, KnowledgeModuleDependencies, KnowledgeRecallInput, KnowledgeRuntimeConfig, KnowledgeRuntimeContext, } from "./knowledge/index.js";
 export type { A2aAgentCard, A2aHttpServer, A2aHttpServerOptions, A2aTask, A2aTaskState, AcpHttpServer, AcpHttpServerOptions, AcpStdioServer, AcpStdioServerOptions, AgUiEvent, AgUiHttpServer, AgUiHttpServerOptions, AgUiRequestAgentInput, } from "./api.js";
 export type { RuntimeMcpServerOptions, ToolMcpServerOptions } from "./mcp.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export { AgentHarnessAcpServer, AgentHarnessRuntime, cancelRequest, createAgentHarness, createAcpServer, createAcpStdioClient, createRuntimeMcpServer, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, exportEvaluationBundle, exportFlow, exportSequence, exportRequestPackage, exportSessionPackage, replayEvaluationBundle, getArtifact, getAgent, getApproval, getOperatorOverview, getRequest, getHealth, listMemories, listRequestTraceItems, getSession, listAgentSkills, listRequestArtifacts, listApprovals, listRequests, listRequestEvents, listSessionSummaries, listSessions, memorize, normalizeUserChatInput, recordArtifact, request, recall, removeMemory, resolveApproval, serveA2aHttp, serveAcpHttp, serveAcpStdio, serveAgUiHttp, serveRuntimeMcpOverStdio, serveToolsOverStdio, subscribe, stop, updateMemory, } from "./api.js";
+export { AcpHarnessClient, InProcessHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient, createAgentHarnessClient, createInProcessHarnessClient, } from "./client.js";
 export { createKnowledgeModule, readKnowledgeRuntimeConfig } from "./knowledge/index.js";
 export { tool } from "./tools.js";

package/dist/init-project.js

@@ -57,6 +57,7 @@ It is a minimal ${options.template} workspace with:
 
 ${templateLine}
 ${webSearchLine}
+- one host agent that already carries the default behavior skills for inspection, safe edits, approvals, and clean completion
 
 ## Run
 
@@ -65,6 +66,13 @@ npm install
 ${providerEnvLine}npm run start -- "Research the latest model serving stack for agent products and summarize the tradeoffs."
 \`\`\`
 
+## Fast first prompts
+
+- \`Inspect this workspace and explain the main entry points.\`
+- \`Review this project structure before making any edits.\`
+- \`Update README.md to make the setup steps clearer.\`
+- \`Find the likeliest config issue in this workspace and propose the smallest fix.\`
+
 ## Structure
 
 - \`src/run.mjs\`: minimal launcher
@@ -277,6 +285,11 @@ spec:
   backend: deepagent
   modelRef: model/default
 ${toolsBlock}  skills:
+    - workspace-inspection
+    - safe-editing
+    - delegation-discipline
+    - approval-execution-policy
+    - completion-discipline
     - deep-research
 ${subagentsBlock}  config:
     backend: default
@@ -299,6 +312,9 @@ spec:
   backend: deepagent
   modelRef: model/default
 ${toolsBlock}  skills:
+    - workspace-inspection
+    - approval-execution-policy
+    - completion-discipline
     - deep-research
   config:
     backend: default
@@ -336,6 +352,74 @@ ${stepTwo}
 5. End with a concise synthesis, explicit caveats, and source links when available.
 `;
 }
+function renderStarterSkill(name) {
+    if (name === "workspace-inspection") {
+        return `---
+name: workspace-inspection
+description: Inspect the current workspace before making claims or edits.
+---
+
+# Workspace Inspection
+
+1. Start with lightweight discovery such as \`list_files\` or \`search_files\`.
+2. Read only the files needed to establish the relevant facts.
+3. Ground each conclusion in inspected workspace evidence instead of guesses.
+4. If the workspace does not contain the needed evidence, say that plainly before proposing a next step.
+`;
+    }
+    if (name === "safe-editing") {
+        return `---
+name: safe-editing
+description: Make the smallest workspace change that solves the task, then verify it.
+---
+
+# Safe Editing
+
+1. Identify the exact file or files before editing.
+2. Prefer bounded edits over large rewrites.
+3. Keep local conventions intact.
+4. Run the smallest reasonable verification step before you finish.
+`;
+    }
+    if (name === "delegation-discipline") {
+        return `---
+name: delegation-discipline
+description: Delegate only when a subagent is clearly the best fit and the handoff can be bounded cleanly.
+---
+
+# Delegation Discipline
+
+1. Keep the next critical-path step local unless a subagent is clearly better.
+2. Delegate only with one bounded ask and a clear purpose.
+3. Integrate delegated results into one final answer instead of forwarding raw output.
+`;
+    }
+    if (name === "approval-execution-policy") {
+        return `---
+name: approval-execution-policy
+description: Treat side effects, command execution, and external actions as governed runtime decisions.
+---
+
+# Approval And Execution Policy
+
+1. Inspect first when the safest next step is still unclear.
+2. Request approval before destructive, external, privileged, or ambiguous actions.
+3. After approval, execute only the action that was approved and report the outcome plainly.
+`;
+    }
+    return `---
+name: completion-discipline
+description: Finish the task cleanly, verify what you can, and leave the user with a clear outcome.
+---
+
+# Completion Discipline
+
+1. Check whether the request is actually complete.
+2. Verify the changed or inspected area with the smallest relevant check.
+3. Distinguish completed work, unverified areas, and blocked follow-up.
+4. Return a concise final answer that makes the outcome easy to trust.
+`;
+}
 function renderRunScript(options) {
     const defaultInput = options.withWebSearch
         ? "Research the latest model and tooling trends for AI product teams. Return a concise brief with sources and caveats."
@@ -400,6 +484,11 @@ export async function initProject(projectRoot, projectName, options = {}) {
         ["config/agents/research.yaml", renderResearchAgentYaml(resolved)],
         ["resources/package.json", renderResourcePackageJson(projectSlug)],
         ["resources/skills/deep-research/SKILL.md", renderSkill(resolved)],
+        ["resources/skills/workspace-inspection/SKILL.md", renderStarterSkill("workspace-inspection")],
+        ["resources/skills/safe-editing/SKILL.md", renderStarterSkill("safe-editing")],
+        ["resources/skills/delegation-discipline/SKILL.md", renderStarterSkill("delegation-discipline")],
+        ["resources/skills/approval-execution-policy/SKILL.md", renderStarterSkill("approval-execution-policy")],
+        ["resources/skills/completion-discipline/SKILL.md", renderStarterSkill("completion-discipline")],
     ]);
     if (resolved.template === "deep-research") {
         files.set("config/agents/research-analyst.yaml", renderResearchAnalystYaml(resolved));

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.293";
+export declare const AGENT_HARNESS_VERSION = "0.0.295";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.293";
+export const AGENT_HARNESS_VERSION = "0.0.295";

package/dist/protocol/acp/client.d.ts

@@ -1,14 +1,20 @@
 import type { Readable, Writable } from "node:stream";
-import type { AcpEventNotification, AcpJsonRpcSuccess } from "../../acp.js";
+import type { AcpNotification, AcpJsonRpcSuccess } from "../../acp.js";
 export type AcpStdioClientOptions = {
     input: Writable;
     output: Readable;
     idPrefix?: string;
 };
+export type AcpHttpClientOptions = {
+    rpcUrl: string;
+    eventsUrl: string;
+};
 export type AcpStdioClient = {
     request: (method: string, params?: unknown) => Promise<AcpJsonRpcSuccess["result"]>;
     notify: (method: string, params?: unknown) => Promise<void>;
-    subscribe: (listener: (notification: AcpEventNotification) => void) => () => void;
+    subscribe: (listener: (notification: AcpNotification) => void) => () => void;
     close: () => Promise<void>;
 };
+export type AcpHttpClient = AcpStdioClient;
 export declare function createAcpStdioClient(options: AcpStdioClientOptions): AcpStdioClient;
+export declare function createAcpHttpClient(options: AcpHttpClientOptions): AcpHttpClient;