tinker-agent 2.8.0 → 2.10.0

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/runner-dependencies.ts

@@ -34,13 +34,14 @@ Use WebSearch, when it is available, to look up current information on the web s
 Use WebFetch to read the content of a specific URL, such as documentation pages found via WebSearch.
 Prefer Read for reading files instead of using cat on large files.
 Prefer Write or Edit for changing files instead of shell redirection.
-Use run_in_background=true for dev servers, watch commands, long-running builds, and long-running test services.
+Use run_in_background=true for persistent processes such as dev servers and watch commands, or when you have independent work to do while a command runs.
+For finite commands whose result is needed next, such as builds, tests, and checks, prefer foreground execution when no independent work remains. Set a sufficient foreground timeout; the call returns as soon as the command finishes.
 Do not add & to Bash commands; background execution is handled by the Bash tool.
 Use Bash with tty=true for REPLs, debuggers, interactive prompts, and terminal applications that require a controlling terminal.
-Use TaskList to list background shell tasks in the current session.
-Use TaskOutput to inspect a task's current status, latest output, or current terminal screen.
-Use TaskInput with the returned task ID to send characters to a PTY task. TaskInput does not append Enter; include \\n explicitly, use \\u0003 for Ctrl-C, and use chars="" to wait without writing.
-Use TaskStop to stop a background task that is no longer needed.
+TaskList lists background shell tasks in the current session.
+TaskOutput reports a task's current status, latest output, or current terminal screen. For non-PTY logs, offset (1-based) and limit select consecutive lines instead of the default head/tail preview; PTY tasks ignore them. Range truncated=true means byte limits shortened requested content, not that lines outside the range exist. The last observed line of a running log may still be growing; rereading it when polling captures further changes to that line.
+TaskInput sends characters to a PTY task identified by the returned task ID. TaskInput does not append Enter; an explicit \\n sends Enter, \\u0003 sends Ctrl-C, and chars="" waits without writing.
+TaskStop stops a background task that is no longer needed.
 Do not use ad-hoc kill commands to manage tasks created by Bash.
 Bash and TaskOutput return outputFilePath. Use Read on outputFilePath when you need complete or paginated output.
 Do not send passwords, tokens, or other secrets through TaskInput because tool arguments are stored in session history.

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-automation-policy.ts

@@ -1,122 +1,16 @@
-import { stableJsonStringify, sha256 } from "../model/model-request-preflight";
-import { RECALL_TOOL_DEFINITIONS } from "../tools/recall";
-import type { ToolDefinition } from "../tools/types";
-import type { StoredContextSurfaceV8 } from "./context-surface";
-import {
-  CURRENT_RECALL_RETIREMENT_CONTRACT_VERSION,
-  renderRecallRetirementContract,
-} from "./recall-retirement-contract";
-
-export const I4_ACTIVE_RECALL_QUALIFICATION = Object.freeze({
-  qualificationId: "deepseek-v4-flash-floor-v1",
-  evaluatedProfile: "deepseek-v4-flash",
-  manifestVersion: "active-recall-manifest-v1",
-  manifestSha256: "093679e221e02b71ba5acf54693faa7a299d05dd25f6faabbeb84645d4db4d2d",
-  graderVersion: "active-recall-deterministic-grader-v1",
-  fixtureVersion: "active-recall-long-session-fixture-v1",
-  policyVersion: "active-recall-qualification-policy-v1",
-  policySha256: "77ca611594d4e9b7b5a597a3a33e35fcaaffae284dc2ac9953ce9a63cce1c009",
-  positiveReportSha256:
-    "e827e5e94171328bb2dd7fcaeff91881f04bdfc78361a45e2548da323229b02a",
-  negativeReportSha256:
-    "ed379843aee0f193f398a4dff9a18ed338f0edab2cbaf9b628d0dfc402d925a4",
-  resolvedModel: "deepseek-v4-flash",
-  recallContractVersion: CURRENT_RECALL_RETIREMENT_CONTRACT_VERSION,
-  recallContractSha256:
-    "3b6d1a452efea1db5920eb13542571b038667ef4f635551bea375bda6562a39f",
-  recallToolDefinitionSha256:
-    "e63ada7cdf9591d1e933cf5e190ea30586e02bbf73aeb5e648db449d75aae009",
-  metrics: Object.freeze({
-    fullHistoryTaskSuccessRate: 0.9667,
-    swapOnlyTaskSuccessRate: 0.9667,
-    recallOnlyTaskSuccessRate: 1,
-    recallOnlyActiveRecallRate: 1,
-    recallOnlySearchGetSuccessRate: 0.3333,
-    minimumCounterfactualGroupTaskSuccessRate: 1,
-    invalidRecallCallsPerRecallOnlyTrial: 0,
-    negativeUnnecessaryRecallRate: 0,
-    recallOnlyTokenRatioToFullHistory: 1.3739,
-    recallOnlyLatencyRatioToFullHistory: 1.207,
-  }),
-  passed: true,
-} as const);
-
-export const I4_SWAP_ONLY_QUALIFICATION_ID = "swap-only-engineering-v1";
-
-export type ActiveRecallQualificationEvidence = {
-  readonly qualificationId: string;
-  readonly recallContractVersion: string;
-  readonly recallContractSha256: string;
-  readonly recallToolDefinitionSha256: string;
-  readonly passed: boolean;
-};
-
-export type ContextAutomationDecision = {
-  readonly automaticSwapOnly: boolean;
+/** Product defaults only. Evaluation results and model identities never select these flags.
+ * Planners and session boundaries independently validate each operation before execution.
+ */
+export type ContextAutomationPolicy = {
+  readonly policyId: string;
+  readonly automaticSwap: boolean;
   readonly automaticPrefixRetirement: boolean;
-  readonly reason:
-    | "qualified"
-    | "swap_only_qualified"
-    | "qualification_pending"
-    | "unprofiled_model"
-    | "recall_contract_mismatch"
-    | "recall_tool_mismatch";
-  readonly qualificationId?: string;
 };
 
-export function selectContextAutomation(
-  input: {
-    readonly profileName?: string;
-    readonly surface: StoredContextSurfaceV8;
-  },
-  evidence: ActiveRecallQualificationEvidence = I4_ACTIVE_RECALL_QUALIFICATION,
-): ContextAutomationDecision {
-  if (input.profileName === undefined) {
-    return disabled("unprofiled_model");
-  }
-  if (
-    input.surface.recallContractVersion !== evidence.recallContractVersion ||
-    sha256(renderRecallRetirementContract()) !== evidence.recallContractSha256
-  ) {
-    return disabled("recall_contract_mismatch");
-  }
-  const recallTools = input.surface.toolDefinitions.filter(
-    (definition) =>
-      definition.name === "RecallSearch" || definition.name === "RecallGet",
-  );
-  if (
-    recallTools.length !== 2 ||
-    toolDefinitionsHash(recallTools) !== evidence.recallToolDefinitionSha256 ||
-    toolDefinitionsHash(RECALL_TOOL_DEFINITIONS) !== evidence.recallToolDefinitionSha256
-  ) {
-    return disabled("recall_tool_mismatch");
-  }
-  if (!evidence.passed) {
-    return Object.freeze({
-      automaticSwapOnly: true,
-      automaticPrefixRetirement: false,
-      reason: "swap_only_qualified",
-      qualificationId: I4_SWAP_ONLY_QUALIFICATION_ID,
-    });
-  }
-  return Object.freeze({
-    automaticSwapOnly: true,
+export const DEFAULT_CONTEXT_AUTOMATION_POLICY: ContextAutomationPolicy = Object.freeze(
+  {
+    policyId: "context-automation-v1",
+    automaticSwap: true,
     automaticPrefixRetirement: true,
-    reason: "qualified",
-    qualificationId: evidence.qualificationId,
-  });
-}
-
-function disabled(
-  reason: Exclude<ContextAutomationDecision["reason"], "qualified">,
-): ContextAutomationDecision {
-  return Object.freeze({
-    automaticSwapOnly: false,
-    automaticPrefixRetirement: false,
-    reason,
-  });
-}
-
-function toolDefinitionsHash(definitions: readonly ToolDefinition[]): string {
-  return sha256(stableJsonStringify(definitions));
-}
+  },
+);

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/events/types.ts

@@ -56,6 +56,8 @@ export type ContextRevisionStartedData =
       reason: "manual" | "runtime_pressure" | "model_directed";
       policyVersion: "swap-only-v1";
       rendererFormat: "swap-observation-v1";
+      automationPolicyId?: string;
+      /** Legacy event metadata only; never controls runtime automation. */
       qualificationId?: string;
     }
   | {
@@ -69,6 +71,8 @@ export type ContextRevisionStartedData =
       reason: "manual" | "runtime_pressure";
       policyVersion: "recall-first-retirement-v1";
       baseRevisionNumber: number;
+      automationPolicyId?: string;
+      /** Legacy event metadata only; never controls runtime automation. */
       qualificationId?: string;
     }
   | {
@@ -102,6 +106,8 @@ export type ContextRevisionFinishedData =
       targetTokens: number;
       planHash?: string;
       durationMs: number;
+      automationPolicyId?: string;
+      /** Legacy event metadata only; never controls runtime automation. */
       qualificationId?: string;
     }
   | {
@@ -143,6 +149,8 @@ export type ContextRevisionFinishedData =
       transactionDurationMs?: number;
       activationDurationMs?: number;
       durationMs: number;
+      automationPolicyId?: string;
+      /** Legacy event metadata only; never controls runtime automation. */
       qualificationId?: string;
     }
   | {
@@ -166,6 +174,8 @@ export type ContextRevisionFailedData =
       stage: "snapshot" | "plan" | "validate" | "commit" | "activate";
       errorCode: string;
       error: string;
+      automationPolicyId?: string;
+      /** Legacy event metadata only; never controls runtime automation. */
       qualificationId?: string;
     }
   | {
@@ -183,6 +193,8 @@ export type ContextRevisionFailedData =
       errorCode: string;
       error: string;
       committed: boolean;
+      automationPolicyId?: string;
+      /** Legacy event metadata only; never controls runtime automation. */
       qualificationId?: string;
     }
   | {

package/src/memory/memory-get-tool.ts

@@ -10,7 +10,7 @@ import { MAX_MEMORY_ID_BYTES, MEMORY_GET_TOOL_NAME } from "./contracts";
 export const MEMORY_GET_TOOL_DEFINITION: ToolDefinition = Object.freeze({
   name: MEMORY_GET_TOOL_NAME,
   description:
-    "Read one stored memory in full by its memoryId from a MemorySearch result. Use this when a search hit's summary is truncated or you need its exact stored text, summary, and source metadata. The record is a derived historical summary that may be stale or wrong; verify current workspace facts with current tools, and use RecallSearch on its source session for the full original context.",
+    "Read one stored memory in full by its memoryId from a MemorySearch result. Use this when a search hit's summary is truncated or you need its exact stored text, summary, and source metadata. The record is a derived historical summary that may be stale or wrong; verify current workspace facts with current tools.",
   parameters: {
     type: "object",
     additionalProperties: false,