tinker-agent 2.9.0 → 2.10.0

package/src/cli/output.ts

@@ -4,7 +4,7 @@ const TRUNCATION_MARKER = "...[truncated]";
 const ESCAPE = String.fromCharCode(27);
 const ANSI_CSI_PATTERN = new RegExp(`${ESCAPE}\\[[0-?]*[ -/]*[@-~]`, "g");
 
-export type CliCommandScope = "root" | "run" | "update";
+export type CliCommandScope = "root" | "run" | "update" | "serve" | "connect";
 
 export interface CliOutputWriter {
   write(chunk: string): boolean | void;

package/src/cli/public-cli-contract.ts

@@ -47,6 +47,24 @@ export const PUBLIC_CLI_CONTRACT = Object.freeze({
     description: "Start the interactive terminal interface.",
     profileOption: PROFILE_OPTION,
   }),
+  serve: Object.freeze({
+    command: "serve",
+    description: "Run the local daemon for paired remote clients.",
+    configOption: Object.freeze({
+      flags: "--config <path>",
+      description: "Read the service JSON configuration.",
+      valueName: "path",
+    } satisfies PublicCliOption),
+  }),
+  connect: Object.freeze({
+    command: "connect",
+    description: "Attach a terminal client to a service; exiting detaches only.",
+    configOption: Object.freeze({
+      flags: "--config <path>",
+      description: "Read the paired client JSON configuration.",
+      valueName: "path",
+    } satisfies PublicCliOption),
+  }),
   run: Object.freeze({
     command: "run [prompt]",
     description: "Run one prompt non-interactively.",

package/src/cli/public-config-contract.ts

@@ -174,7 +174,7 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
     valueKind: "positive-integer",
     requiredIn: "never",
     appliesIn: "always",
-    defaultValue: 5_000,
+    defaultValue: 60_000,
     secret: false,
     section: "tooling",
     description: "Default Bash foreground timeout in milliseconds.",

package/src/cli/serve-runner.ts

@@ -0,0 +1,45 @@
+import { loadRemoteConfig } from "../remote/config";
+import { startRemoteHttpServer } from "../remote/http-server";
+import { RemoteService } from "../remote/service";
+import { RemoteServiceStore } from "../remote/service-store";
+import { defaultHomeRoot } from "../session/workspace-storage";
+import { createHostedRuntimeFactory } from "./serve-runtime";
+import { writeCliOutput, type CliOutputWriter } from "./output";
+
+export async function runServe(input: {
+  configPath: string;
+  env: NodeJS.ProcessEnv;
+  stdout: CliOutputWriter;
+}): Promise<number> {
+  const config = await loadRemoteConfig(input.configPath);
+  const homeRoot = defaultHomeRoot(input.env);
+  const store = await RemoteServiceStore.open(config.stateDirectory);
+  const service = new RemoteService(
+    store,
+    config.workspaces,
+    createHostedRuntimeFactory(config.workspaces, input.env, homeRoot),
+    homeRoot,
+  );
+  let transport: ReturnType<typeof startRemoteHttpServer> | undefined;
+  try {
+    await service.initialize();
+    transport = startRemoteHttpServer(service, config);
+    await writeCliOutput(
+      input.stdout,
+      `Tinker service listening on https://${config.hostname}:${transport.port}; ${config.workspaces.length} workspace(s).\nClient disconnects detach only. Stop the process to shut down hosted sessions.\n`,
+    );
+    await new Promise<void>((resolve) => {
+      const stop = () => {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        resolve();
+      };
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+    });
+    return 0;
+  } finally {
+    await transport?.stopTransport();
+    await service.close();
+  }
+}

package/src/cli/serve-runtime.ts

@@ -0,0 +1,100 @@
+import { createRuntimeSession } from "../agent/runtime-session";
+import { parseSessionId } from "../ids/runtime-id";
+import {
+  buildSystemPrompt,
+  loadProjectInstructions,
+  projectInstructionManifest,
+} from "../instructions/project-instructions";
+import { createReasoningEffortController } from "../model/reasoning-effort";
+import { resolveSessionDatabasePath } from "../session/session-store";
+import { SessionCatalog } from "../session/session-catalog";
+import { loadSkillCatalog } from "../skills/skill-loader";
+import type { RemoteWorkspaceConfig } from "../remote/config";
+import type { HostedRuntimeFactory } from "../agent/runtime-hosted-session";
+import { deriveRunnerConfig, resolvePublicConfig } from "./config";
+import { resolveSessionProfileName } from "./model-profiles";
+import {
+  createRunnerModelClient,
+  createWebFetchRefiner,
+  RUNTIME_INSTRUCTIONS,
+} from "./runner-dependencies";
+
+/** Service composition reuses the existing configuration/provider/runtime contracts. */
+export function createHostedRuntimeFactory(
+  workspaces: readonly RemoteWorkspaceConfig[],
+  env: NodeJS.ProcessEnv,
+  homeRoot?: string,
+): HostedRuntimeFactory {
+  return async ({ record, sink }) => {
+    const workspace = workspaces.find((entry) => entry.id === record.workspaceId);
+    if (!workspace || workspace.path !== record.workspacePath)
+      throw new Error("Managed workspace configuration changed.");
+    const sessionId = parseSessionId(record.id);
+    const publicConfig = await resolvePublicConfig({
+      env: { ...env, TINKER_WORKSPACE: workspace.path },
+      cwd: workspace.path,
+    });
+    let profileName = workspace.profile;
+    if (record.initialized && publicConfig.mode === "profile") {
+      const summary = await new SessionCatalog({
+        workspaceRoot: workspace.path,
+        homeRoot,
+      }).get(sessionId);
+      profileName = resolveSessionProfileName(publicConfig.profiles, summary);
+    }
+    const config = deriveRunnerConfig(publicConfig, {
+      sessionId,
+      ...(profileName ? { profileName } : {}),
+    });
+    const reasoning = createReasoningEffortController(config.reasoning);
+    const projectInstructions = await loadProjectInstructions(workspace.path);
+    const runtime = await createRuntimeSession({
+      workspaceRoot: workspace.path,
+      ...(homeRoot === undefined ? {} : { homeRoot }),
+      ...(record.initialized
+        ? { selection: { mode: "resume" as const, sessionId } }
+        : { selection: { mode: "new" as const, sessionId } }),
+      modelName: config.modelName,
+      profileName: config.profileName,
+      maxIterations: config.maxIterations,
+      includeReasoningContent: config.includeReasoningContent,
+      contextProfile: config.contextProfile,
+      contextBudget: config.contextBudget,
+      modelClient: createRunnerModelClient(config, undefined, env, reasoning),
+      systemPrompt: buildSystemPrompt({
+        workspaceRoot: workspace.path,
+        runtimeInstructions: RUNTIME_INSTRUCTIONS(workspace.path),
+        projectInstructions,
+      }),
+      projectInstruction: projectInstructionManifest(projectInstructions),
+      skillCatalog: await loadSkillCatalog({ workspaceRoot: workspace.path }),
+      presentationSinks: [sink],
+      assistantTextDeltaSink: sink,
+      toolingConfig: publicConfig.tooling,
+      webFetchRefiner: createWebFetchRefiner(config, env, reasoning),
+      enableAskUser: true,
+      bashGuard: {
+        mode: config.bashGuardMode,
+        source: config.bashGuardSource,
+        surface: "tui",
+      },
+    });
+    try {
+      return {
+        runtime,
+        databasePath: await resolveSessionDatabasePath(
+          workspace.path,
+          sessionId,
+          homeRoot,
+        ),
+        modelName: config.modelName,
+      };
+    } catch (error) {
+      await runtime.dispose({
+        type: "initialization_failed",
+        error: "Cannot open remote history reader.",
+      });
+      throw error;
+    }
+  };
+}

package/src/context/context-swap-renderer.ts

@@ -193,6 +193,11 @@ function metadataEntries(
         ["pattern", raw.pattern],
         ["searchPath", raw.searchPath],
         ["matchCount", raw.matchCount],
+        ["totalMatches", raw.totalMatches],
+        ["returnedCount", raw.returnedCount],
+        ["appliedOffset", raw.appliedOffset],
+        ["hasMore", raw.hasMore],
+        ["nextOffset", raw.nextOffset],
       ];
     case "grep":
       return [
@@ -200,6 +205,15 @@ function metadataEntries(
         ["searchPath", raw.searchPath],
         ["mode", raw.mode],
         ["numMatches", raw.numMatches],
+        ["numLines", raw.numLines],
+        ["paginationUnit", raw.paginationUnit],
+        ["totalResults", raw.totalResults],
+        ["returnedResults", raw.returnedResults],
+        ["appliedOffset", raw.appliedOffset],
+        ["hasMore", raw.hasMore],
+        ["nextOffset", raw.nextOffset],
+        ["searchIncomplete", raw.searchIncomplete],
+        ["contextMayBeIncomplete", raw.contextMayBeIncomplete],
         ["truncated", raw.truncated],
       ];
     case "bash":

package/src/observation/observation-builder.ts

@@ -35,6 +35,7 @@ import type {
   WriteFileRawResult,
 } from "../tools/types";
 import { MAX_MEMORY_TEXT_BYTES, truncateUtf8 } from "../memory/contracts";
+import { formatGrepPath } from "../tools/grep-path";
 
 export type ToolObservation = {
   readonly content: readonly ToolResultContent[];
@@ -181,18 +182,30 @@ function assertNever(value: never): never {
 
 function renderGlobObservation(raw: GlobRawResult): string {
   if (!raw.ok) {
-    return `Glob failed for pattern=${JSON.stringify(raw.pattern)}: ${raw.error ?? "Unknown error."}`;
+    const pattern =
+      raw.pattern === undefined ? "(missing or invalid)" : JSON.stringify(raw.pattern);
+    return `Glob failed for pattern=${pattern}, searchPath=${JSON.stringify(raw.searchPath)}: ${raw.error ?? "Unknown error."}`;
   }
 
   const matches = raw.matches ?? [];
+  const totalMatches = raw.totalMatches ?? raw.matchCount ?? matches.length;
 
   return [
     `Glob succeeded for pattern=${JSON.stringify(raw.pattern)}.`,
     `searchPath=${raw.searchPath}`,
-    `matchCount=${raw.matchCount ?? matches.length}`,
+    `totalMatches=${totalMatches}`,
+    `returnedCount=${raw.returnedCount ?? matches.length}`,
+    `hasMore=${raw.hasMore ?? false}`,
+    ...(raw.hasMore && raw.nextOffset !== undefined
+      ? [`nextOffset=${raw.nextOffset}`]
+      : []),
     `ignored=${(raw.ignored ?? []).join(",")}`,
     "matches:",
-    matches.length === 0 ? "(no matches)" : matches.join("\n"),
+    matches.length > 0
+      ? matches.join("\n")
+      : totalMatches === 0
+        ? "(no matches)"
+        : `(no results on this page at offset ${raw.appliedOffset ?? 0})`,
   ].join("\n");
 }
 
@@ -202,31 +215,51 @@ function renderGrepObservation(raw: GrepRawResult): string {
   }
 
   const sections: string[] = [];
+  const paginated = raw.appliedLimit !== undefined || (raw.appliedOffset ?? 0) > 0;
+  const incomplete = grepSearchIncomplete(raw);
+  const empty = raw.mode === "content" ? !raw.content : raw.numFiles === 0;
 
-  if (raw.mode === "files_with_matches") {
-    sections.push(
-      raw.numFiles === 0
-        ? "No files found"
-        : [
-            `Found ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}`,
-            ...raw.filenames,
-          ].join("\n"),
-    );
-  } else if (raw.mode === "count") {
-    if (raw.numFiles === 0) {
+  if (empty) {
+    if (raw.totalResults === 0 && !incomplete) {
       sections.push("No matches found");
+    } else if ((raw.appliedOffset ?? 0) > 0) {
+      sections.push(`No results on this page at offset ${raw.appliedOffset}.`);
     } else {
-      sections.push(raw.content ?? "");
       sections.push(
-        `Found ${raw.numMatches ?? 0} total occurrence${(raw.numMatches ?? 0) === 1 ? "" : "s"} across ${raw.numFiles} file${raw.numFiles === 1 ? "" : "s"}.`,
+        incomplete
+          ? "No results available in this partial output."
+          : "No matches found",
       );
     }
-  } else {
+  } else if (raw.mode === "files_with_matches") {
     sections.push(
-      raw.content === undefined || raw.content === ""
-        ? "No matches found"
-        : raw.content,
+      [
+        `${paginated || incomplete ? "Showing" : "Found"} ${raw.numFiles} matching file${raw.numFiles === 1 ? "" : "s"}${paginated ? " on this page" : ""}`,
+        ...raw.filenames.map(formatGrepPath),
+      ].join("\n"),
     );
+  } else if (raw.mode === "count" || raw.mode === "count-matches") {
+    const mode = raw.mode;
+    sections.push(
+      raw.counts !== undefined
+        ? raw.counts
+            .map(
+              (entry) =>
+                `${formatGrepPath(entry.filePath)}: ${grepCountLabel(mode, entry.count)}`,
+            )
+            .join("\n")
+        : // Legacy stored results have only display text. Never use it to compute totals.
+          (raw.content ?? "").replace(
+            /:(\d+)$/gm,
+            (_suffix, count: string) => `: ${grepCountLabel(mode, Number(count))}`,
+          ),
+    );
+    const scope = paginated ? "This page" : incomplete ? "Results shown" : "Total";
+    sections.push(
+      `${scope}: ${grepCountLabel(mode, raw.numMatches ?? 0)} across ${raw.numFiles} matching file${raw.numFiles === 1 ? "" : "s"}.`,
+    );
+  } else {
+    sections.push(raw.content ?? "");
   }
 
   const pagination = renderGrepPagination(raw);
@@ -234,27 +267,49 @@ function renderGrepObservation(raw: GrepRawResult): string {
     sections.push(pagination);
   }
 
-  if (raw.truncated === true && raw.error !== undefined) {
-    sections.push(`Warning: results are incomplete. ${raw.error}`);
+  if (incomplete) {
+    sections.push(
+      `Warning: results are incomplete. ${raw.error ?? "Search did not finish."}`,
+    );
+  }
+  if (raw.contextMayBeIncomplete === true) {
+    sections.push(
+      "Warning: requested context may be incomplete because the search stopped early. Narrow the search and retry.",
+    );
   }
 
   return sections.join("\n\n");
 }
 
-function renderGrepPagination(raw: GrepRawResult): string | undefined {
-  const parts: string[] = [];
+function grepCountLabel(mode: "count" | "count-matches", count: number): string {
+  return mode === "count"
+    ? `${count} matching line${count === 1 ? "" : "s"}`
+    : `${count} match${count === 1 ? "" : "es"}`;
+}
 
-  if (raw.appliedLimit !== undefined) {
-    parts.push(`limit: ${raw.appliedLimit}`);
+function renderGrepPagination(raw: GrepRawResult): string | undefined {
+  const incomplete = grepSearchIncomplete(raw);
+  const hasMore = raw.hasMore ?? raw.appliedLimit !== undefined;
+  const nextOffset =
+    raw.nextOffset ??
+    (raw.appliedLimit === undefined
+      ? undefined
+      : (raw.appliedOffset ?? 0) + raw.appliedLimit);
+  if (hasMore && nextOffset !== undefined) {
+    return `More ${incomplete ? "collected " : ""}results available; nextOffset=${nextOffset}.`;
   }
 
-  if (raw.appliedOffset !== undefined) {
-    parts.push(`offset: ${raw.appliedOffset}`);
+  if ((raw.appliedOffset ?? 0) > 0 && raw.totalResults !== 0) {
+    return incomplete
+      ? "End of collected results; search is incomplete."
+      : "End of results.";
   }
 
-  return parts.length === 0
-    ? undefined
-    : `[Showing results with pagination = ${parts.join(", ")}]`;
+  return undefined;
+}
+
+function grepSearchIncomplete(raw: GrepRawResult): boolean {
+  return raw.searchIncomplete ?? (raw.truncated === true && raw.error !== undefined);
 }
 
 function renderReadObservation(raw: ReadFileRawResult): string {
@@ -269,7 +324,6 @@ function renderReadObservation(raw: ReadFileRawResult): string {
 
   return [
     `Read succeeded for ${raw.filePath}.`,
-    `sha256=${raw.sha256}`,
     `sizeBytes=${raw.sizeBytes ?? 0}`,
     `contentBytes=${raw.contentBytes ?? 0}`,
     `totalLines=${raw.totalLines ?? 0}`,
@@ -489,8 +543,6 @@ function renderWriteObservation(raw: WriteFileRawResult): string {
   return [
     `Write succeeded for ${raw.filePath}.`,
     `bytesWritten=${raw.bytesWritten ?? 0}`,
-    `oldSha256=${raw.oldSha256 ?? "null"}`,
-    `newSha256=${raw.newSha256}`,
   ].join("\n");
 }
 
@@ -508,8 +560,6 @@ function renderEditObservation(raw: EditFileRawResult): string {
     `replacementCount=${raw.replacementCount ?? 0}`,
     `replaceAll=${raw.replaceAll ?? false}`,
     `created=${raw.created ?? false}`,
-    `oldSha256=${raw.oldSha256 ?? "null"}`,
-    `newSha256=${raw.newSha256}`,
   ].join("\n");
 }
 
@@ -644,7 +694,7 @@ function renderTaskInputObservation(raw: TaskInputRawResult): string {
   }
 
   return [
-    "Terminal input sent.",
+    raw.writtenBytes === 0 ? "Terminal screen polled." : "Terminal input sent.",
     `taskId=${raw.taskId}`,
     `status=${raw.status}`,
     `writtenBytes=${raw.writtenBytes}`,