@zhivex-ai/harness 1.2.0-rc.8 → 1.2.0

package/dist/{service-client-cli-s3ee2hrj.js → service-client-cli-yx56n0hc.js}

@@ -1,15 +1,17 @@
 import {
+  ActivityHistory,
   CLI_EVENT_SCHEMA_VERSION,
   CLI_JSON_SCHEMA_VERSION,
   ConsoleInput,
+  ToolActivity,
   changeEnvelopeSchema,
-  formatComposer,
+  formatAppliedFiles,
   formatConsoleHelp,
   formatConsoleWelcome,
   navigateConsole,
   sanitizeTerminalText,
   serializeStreamResult
-} from "./cli-entry-hkxakkng.js";
+} from "./cli-entry-c2f58zj2.js";
 import {
   HARNESS_VERSION
 } from "./cli-entry-64pdp3k5.js";
@@ -18,8 +20,9 @@ import {
   HARNESS_ERROR_SCHEMA_VERSION,
   HarnessConfigError,
   HarnessStateConflictError,
-  PROVIDERS
-} from "./cli-entry-t3bay5k5.js";
+  PROVIDERS,
+  reasoningEffortSchema
+} from "./cli-entry-427869g9.js";
 import {
   __require
 } from "./cli-entry-1bx83sw4.js";
@@ -441,7 +444,8 @@ var cliInitDocumentSchema = observationalDocument({
     path: z6.string().min(1),
     schemaVersion: nonnegativeInteger,
     provider: z6.enum(PROVIDERS),
-    model: z6.string().min(1)
+    model: z6.string().min(1),
+    reasoningEffort: reasoningEffortSchema.optional()
   }),
   credential: observationalDocument({
     configured: z6.boolean(),
@@ -783,6 +787,9 @@ var runServiceCli = async (options, annotate) => {
   } else
     session2 = await create(options.idempotencyKey);
   let activeRun;
+  let consoleInput;
+  const history = new ActivityHistory;
+  const seenMutations = new Set;
   const currentRun = async (runId = activeRun ?? session2.runs.at(-1)?.runId) => {
     if (!runId)
       return;
@@ -808,6 +815,27 @@ var runServiceCli = async (options, annotate) => {
   const invoke = async (command) => {
     let cursor = await cursorAtEnd();
     let finished = false, streamed = false;
+    consoleInput?.startBackground();
+    const activity = new ToolActivity((text) => {
+      process.stderr.write(text);
+    }, Boolean(consoleInput && process.stdout.isTTY), () => process.stdout.columns || 80, () => consoleInput?.backgroundStatus ?? "");
+    const observe = (a) => {
+      if (options.json || options.jsonl)
+        return;
+      history.observeService(a);
+      if (a.type === "agent-step-start" || a.type === "agent-run-start")
+        activity.phase("Waiting for model response");
+      else if (a.type === "agent-compaction")
+        activity.phase("Updating context");
+      else if (a.type === "tool-call")
+        activity.start(typeof a.toolName === "string" ? a.toolName : undefined);
+      else if (a.type === "tool-result")
+        activity.finish(typeof a.toolName === "string" ? a.toolName : "tool", a.isError !== true);
+      else if (["agent-run-finish", "tool-approval-request", "agent-approval-request"].includes(String(a.type)))
+        activity.flush();
+      else if (a.type === "text-delta")
+        activity.pause();
+    };
     const pending = call(command).finally(() => {
       finished = true;
     });
@@ -825,6 +853,7 @@ var runServiceCli = async (options, annotate) => {
           const a = event.activity;
           if (a.type === "checkpoint" || a.type === "user-message")
             continue;
+          observe(a);
           if (options.jsonl)
             process.stdout.write(JSON.stringify({ ...a, schemaVersion: 1, kind: "run-event", sequence: ++sequence }) + `
 `);
@@ -848,6 +877,7 @@ var runServiceCli = async (options, annotate) => {
           const a = event.activity;
           if (a.type === "checkpoint" || a.type === "user-message")
             continue;
+          observe(a);
           if (options.jsonl)
             process.stdout.write(JSON.stringify({ ...a, schemaVersion: 1, kind: "run-event", sequence: ++sequence }) + `
 `);
@@ -868,6 +898,8 @@ var runServiceCli = async (options, annotate) => {
     } catch (e) {
       throw annotate(e, sequence);
     } finally {
+      activity.flush();
+      consoleInput?.stopBackground();
       activeRun = undefined;
     }
   };
@@ -885,6 +917,18 @@ var runServiceCli = async (options, annotate) => {
 Run ${run2.runId} · ${run2.status} · session ${session2.sessionId}
 `);
     }
+    if (!options.json && !options.jsonl) {
+      const fresh = document.mutations.filter((entry) => !seenMutations.has(entry.id));
+      for (const entry of fresh)
+        seenMutations.add(entry.id);
+      while (seenMutations.size > 2000)
+        seenMutations.delete(seenMutations.values().next().value);
+      const receipt = formatAppliedFiles(fresh, "Review changes in the host workspace");
+      if (receipt) {
+        process.stdout.write(receipt);
+        history.add(receipt.trim());
+      }
+    }
     if (["failed", "cancelled", "timed_out"].includes(run2.status))
       process.exitCode = 1;
   };
@@ -928,6 +972,7 @@ Run ${run2.runId} · ${run2.status} · session ${session2.sessionId}
     }
     const input = new ConsoleInput(process.stdin, process.stdout, Boolean(process.stdin.isTTY), "service");
     input.onInterrupt = interrupt;
+    consoleInput = input;
     try {
       process.stdout.write(formatConsoleWelcome({ version: HARNESS_VERSION, workspace: projectId, sessionId: session2.sessionId, service: true }, { columns: process.stdout.columns ?? 80 }) + `
 `);
@@ -935,9 +980,8 @@ Run ${run2.runId} · ${run2.status} · session ${session2.sessionId}
       if (previous)
         print(previous);
       for (;; ) {
-        process.stdout.write(formatComposer({ model: "local service", status: session2.runs.at(-1)?.status === "waiting_approval" ? "approval pending · /pending" : "ready", ...session2.title ? { title: session2.title } : {}, automaticApprovals: options.yes === true }, process.stdout.columns));
-        const raw = await input.question(`
-> `, true).catch((e) => {
+        input.setQueueEnabled(!session2.runs.some((run2) => ["created", "running", "waiting_approval"].includes(run2.status)));
+        const raw = await input.compose({ model: "local service", status: session2.runs.at(-1)?.status === "waiting_approval" ? "approval pending · /pending" : "ready", ...session2.title ? { title: session2.title } : {}, automaticApprovals: options.yes === true }).catch((e) => {
           if (input.isClosed)
             return "/exit";
           if (e instanceof Error && e.name === "AbortError")
@@ -961,11 +1005,23 @@ Run ${run2.runId} · ${run2.status} · session ${session2.sessionId}
             }
             if (text === "/help" || text === "/help all")
               process.stdout.write(formatConsoleHelp("service", text === "/help all"));
+            else if (text === "/activity" || text === "/activity clear") {
+              if (text.endsWith(" clear"))
+                history.clear();
+              process.stdout.write(history.render());
+            } else if (text === "/queue clear") {
+              input.clearQueue();
+              process.stdout.write(`Queued tasks cleared.
+`);
+            } else if (text === "/queue")
+              process.stdout.write(input.queueSummary());
             else if (text === "/sessions" || text.startsWith("/sessions "))
               print(await list(text.slice(9).trim() || undefined));
             else if (text === "/new") {
               session2 = await create();
               input.clearHistory();
+              history.clear();
+              seenMutations.clear();
               process.stdout.write(`Session ${session2.sessionId}.
 `);
             } else if (text === "/resume" || text.startsWith("/resume ")) {
@@ -978,6 +1034,8 @@ Run ${run2.runId} · ${run2.status} · session ${session2.sessionId}
               }
               session2 = await getSession(id2);
               input.clearHistory();
+              history.clear();
+              seenMutations.clear();
               print(await currentRun());
             } else if (text.startsWith("/rename ")) {
               const r = await call({ method: "session.rename", sessionId: session2.sessionId, expectedRevision: session2.revision, idempotencyKey: key("rename"), title: text.slice(8) });

package/dist/tools/dependency-read.d.ts

@@ -1,16 +1,63 @@
 import { z } from "zod";
 export declare const dependencyReadSchema: z.ZodObject<{
     package: z.ZodString;
+    action: z.ZodDefault<z.ZodEnum<{
+        list: "list";
+        read: "read";
+        search: "search";
+    }>>;
     file: z.ZodDefault<z.ZodString>;
+    path: z.ZodDefault<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    caseSensitive: z.ZodDefault<z.ZodBoolean>;
     startLine: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
-/** Dedicated read-only boundary. No arbitrary dependency source, scripts, links,
- * nested packages or writes; exports are available through package.json. */
-export declare function readDependency(root: string, input: z.infer<typeof dependencyReadSchema>): Promise<{
+type DependencyInput = z.input<typeof dependencyReadSchema>;
+type DependencyReadResult = {
     package: string;
     file: string;
     startLine: number;
     content: string;
     digest: string;
     truncated: boolean;
-}>;
+};
+type DependencyPage = {
+    package: string;
+    path: string;
+    skippedFiles: number;
+    truncated: boolean;
+    nextOffset: number | null;
+    notice?: string;
+};
+type DependencyListResult = DependencyPage & {
+    action: "list";
+    entries: {
+        path: string;
+        type: "file" | "directory";
+    }[];
+};
+type DependencySearchResult = DependencyPage & {
+    action: "search";
+    matches: {
+        file: string;
+        line: number;
+        text: string;
+    }[];
+};
+type DependencyResult = DependencyReadResult | DependencyListResult | DependencySearchResult;
+/** Dedicated read-only package boundary. Reads never execute source, follow links,
+ * enter nested dependencies or expose hidden files. Content reads are descriptor-bound. */
+export declare function readDependency(root: string, input: DependencyInput & {
+    action?: "read";
+}): Promise<DependencyReadResult>;
+export declare function readDependency(root: string, input: DependencyInput & {
+    action: "list";
+}): Promise<DependencyListResult>;
+export declare function readDependency(root: string, input: DependencyInput & {
+    action: "search";
+}): Promise<DependencySearchResult>;
+export declare function readDependency(root: string, input: DependencyInput): Promise<DependencyResult>;
+export {};

package/dist/tools/execution.d.ts

@@ -4,13 +4,13 @@ import { Workspace } from "../workspace/workspace.js";
 export declare const createExecutionEnvironmentTools: (workspace: Workspace, execution?: Extract<HarnessConfig["execution"], {
     backend: "oci";
 }>) => {
-    run_environment_command: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    run_environment_command: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         command: z.ZodEnum<{
             [x: string]: string;
         }> | z.ZodString;
         args: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    run_environment_batch: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    run_environment_batch: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         commands: z.ZodArray<z.ZodObject<{
             command: z.ZodEnum<{
                 [x: string]: string;
@@ -18,22 +18,22 @@ export declare const createExecutionEnvironmentTools: (workspace: Workspace, exe
             args: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    run_environment_shell?: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    run_environment_shell?: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         script: z.ZodString;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    environment_status: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    inspect_environment_patch: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    apply_environment_patch: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    environment_status: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
+    inspect_environment_patch: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
+    apply_environment_patch: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         patchId: z.ZodString;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    verify_and_apply_environment_patch: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    verify_and_apply_environment_patch: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         patchId: z.ZodString;
         command: z.ZodEnum<{
             [x: string]: string;
         }> | z.ZodString;
         args: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    verify_and_apply_reviewed_edits: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    verify_and_apply_reviewed_edits: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         changes: z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             expectedDigest: z.ZodNullable<z.ZodString>;

package/dist/tools/workspace.d.ts

@@ -1,37 +1,48 @@
 import { z } from "zod";
 import { Workspace } from "../workspace/workspace.js";
 export declare const createWorkspaceTools: (workspace: Workspace, allowedChecks: readonly string[]) => {
-    read_dependency: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    read_dependency: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         package: z.ZodString;
+        action: z.ZodDefault<z.ZodEnum<{
+            list: "list";
+            read: "read";
+            search: "search";
+        }>>;
         file: z.ZodDefault<z.ZodString>;
+        path: z.ZodDefault<z.ZodString>;
+        query: z.ZodOptional<z.ZodString>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+        caseSensitive: z.ZodDefault<z.ZodBoolean>;
         startLine: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        offset: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    list_files: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    list_files: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         path: z.ZodDefault<z.ZodString>;
         limit: z.ZodDefault<z.ZodNumber>;
         includeDigests: z.ZodDefault<z.ZodBoolean>;
         cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    read_file: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    read_file: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         path: z.ZodString;
         startLine: z.ZodDefault<z.ZodNumber>;
         endLine: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    read_files: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    read_files: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         files: z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             startLine: z.ZodDefault<z.ZodNumber>;
             endLine: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    search_files: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    search_files: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         query: z.ZodString;
         path: z.ZodDefault<z.ZodString>;
         caseSensitive: z.ZodDefault<z.ZodBoolean>;
         limit: z.ZodDefault<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    search_many: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    search_many: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         queries: z.ZodArray<z.ZodObject<{
             query: z.ZodString;
             caseSensitive: z.ZodDefault<z.ZodBoolean>;
@@ -39,14 +50,14 @@ export declare const createWorkspaceTools: (workspace: Workspace, allowedChecks:
         path: z.ZodDefault<z.ZodString>;
         limitPerQuery: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    propose_edits: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    propose_edits: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         changes: z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             expectedDigest: z.ZodNullable<z.ZodString>;
             content: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    apply_patch: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    apply_patch: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         proposalId: z.ZodString;
         changes: z.ZodArray<z.ZodObject<{
             path: z.ZodString;
@@ -54,37 +65,37 @@ export declare const createWorkspaceTools: (workspace: Workspace, allowedChecks:
             content: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    apply_reviewed_replacement: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    apply_reviewed_replacement: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         path: z.ZodString;
         expectedDigest: z.ZodString;
         oldText: z.ZodString;
         newText: z.ZodString;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    apply_reviewed_edits: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    apply_reviewed_edits: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         changes: z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             expectedDigest: z.ZodNullable<z.ZodString>;
             content: z.ZodString;
         }, z.core.$strict>>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    move_file: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    move_file: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         source: z.ZodString;
         destination: z.ZodString;
         expectedDigest: z.ZodString;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    quarantine_file: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    quarantine_file: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         path: z.ZodString;
         expectedDigest: z.ZodString;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    restore_file: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    restore_file: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         quarantineId: z.ZodString;
         destination: z.ZodOptional<z.ZodString>;
         expectedDigest: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, import("@zhivex-ai/core").JsonValue, unknown>;
-    run_check: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{
+    run_check: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{
         check: z.ZodString;
         expectedScript: z.ZodString;
     }, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    mutation_audit: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
-    git_diff: import("@zhivex-ai/agents").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
+    mutation_audit: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
+    git_diff: import("@zhivex-ai/core").ToolDefinition<z.ZodObject<{}, z.core.$strip>, import("@zhivex-ai/core").JsonValue, unknown>;
 };