@archmax-ai/harness 0.4.1 → 0.5.0

package/skills/archmax-harness/references/backend-integration.md

@@ -106,7 +106,7 @@ All optional (`CreateAgentParams`, `src/assembly/index.ts`):
 | `checkpointer` | `BaseCheckpointSaver` | Custom-adapter escape hatch; takes precedence over the session store for checkpoint persistence. Defaults to a durable `BackendCheckpointSaver` writing through the session store. Use `MemorySaver` for ephemeral runs. |
 | `middleware` | `AgentMiddleware[]` | Extra middleware appended after workflow instrumentation. |
 | `onEvent` | `WorkflowEventHandler` | Subscribe to all lifecycle diagnostics; suppresses console output when set. |
-| `promptCache` | `PromptCacheOptions` | `{ enabled?, ttl?: "5m" \| "1h" }`. Provider prompt caching for the stable prefix; on by default. Falls back to `settings.prompt_cache`, then `ARCHMAX_PROMPT_CACHE`/`_TTL`. |
+| `promptCache` | `PromptCacheOptions` | `{ enabled?, ttl?: "5m" \| "1h" }`. Provider prompt caching for the stable prefix; on by default. Falls back to `settings.prompt_cache`, then `ARCHMAX_PROMPT_CACHE`/`_TTL`. Turning it off does not stop `ChatAnthropic` or `ChatBedrockConverse` caching: Deep Agents installs LangChain's caching middleware for them itself (5-minute lifetime). |
 | `pricing` | `PricingTable` | USD per 1M tokens, keyed by model id (`default` matches any): `{ input?, output?, cacheRead?, cacheWrite? }`. Looked up by the id the response reported, else the id the runtime was configured to run — so a keyed table prices a workload behind a proxy that echoes no model back. Input rate applies to the input tokens the cache did not serve. Makes `costUsd` appear on usage events, run metadata, and the CLI footer. Falls back to `ARCHMAX_PRICE_*`. Unpriced → tokens only. |
 
 Fails closed: throws `WorkflowLoadError` if the named workflow's `workflow.yaml`
@@ -333,9 +333,11 @@ turn ended in — the position, variables, transcript and files are already ther
 message.
 
 The runtime does not reposition a later turn, so nothing is injected into the
-transcript to explain a jump. When a turn needs a path the current state cannot
-reach, the agent calls `archmax_reset` to return to the state the conversation began
-in (available in every state). To continue *mid-state* instead — inside the state
+transcript to explain a jump. When the current state can serve the new message, the
+agent answers there without a reset. That includes a terminal state that is also the
+state the conversation began in, such as a one-state chat workflow. When a turn needs
+a path the current state cannot reach, the agent calls `archmax_reset` to return to
+the state the conversation began in (available in every state). To continue *mid-state* instead — inside the state
 that stopped, with the arrival in its transcript — the turn must park rather than
 finish.
 
@@ -378,7 +380,7 @@ const outcome = await agent.workflow!.send(sessionId, { message: "Refund the ord
 
 - `signatureJsonSchema(entries)` → `{ type: "object", properties, required }`:
   one property per entry in declaration order, every name required,
-  `date`/`date-time` as `{ type: "string", format }`, an untyped entry as `{}`,
+  `date`/`date-time`/`file` as `{ type: "string", format }`, an untyped entry as `{}`,
   an entry's `description` carried over. It adds no `additionalProperties`; set
   it for your own ingress.
 - `signatureValueIssues(entries, values)` → one issue per missing name and per
@@ -387,6 +389,19 @@ const outcome = await agent.workflow!.send(sessionId, { message: "Refund the ord
   `"4"` to `4` before it validates or seeds.
 - A trigger's `description` is written for the caller. Use it as the MCP tool
   or operation description. The session's own model never sees it.
+- **A `file` entry** (`format: "file"` in the schema) takes a workspace path. To
+  hand a session an uploaded file, pass it on the turn rather than writing into
+  the store yourself:
+  `send(sessionId, { message, files: { invoice: { name: "invoice.pdf", content: bytes } } })`.
+  The runtime places the bytes in the session's `scratchpad/attachments/` (a taken
+  name gets `-1`, `-2`, …), seeds `invoice`, locked, with the placed path, and the
+  turn boundary then checks that the file is there and readable. `send` throws
+  `InvalidTurnFileError`, before anything is written, for a bad variable or file
+  name, a variable also given in `variables`, a session parked at a human state, or
+  bytes the store cannot hold exactly (a non-text file needs a store with
+  `uploadFiles`). `signatureValueIssues` checks only a `file` value's shape, so a
+  start form validates the path the upload will produce, or skips the entry and
+  lets `files` supply it.
 - A host that reads specs itself must read `requires`/`returns` through
   `normalizeSignature` (both spellings → `{ name, type?, description? }[]`),
   never as `string[]`: an entry may be an object. Hosts must be on the release
@@ -618,6 +633,10 @@ and a delete itself. Deep Agents is handed the workspace without `delete`, so it
 own recursive `delete` tool never exists: `remove_file` is the one way to delete
 a file.
 
+A store's `grep` receives the call's match cap as its fourth argument,
+`maxCount` (the agent's `max_count`, else Deep Agents' 1,000). A store may stop
+there and return `truncated: true`; the workspace caps one that ignores it.
+
 ### Host tools
 
 A host tool built with `toolsFromMap` reaches the workspace the way the
@@ -704,7 +723,7 @@ real). A bespoke target that intercepts by other means sets
 `capabilities.toolMocks` itself. Mockless cases run against any
 workflow-governed target.
 
-**Sub-workflows inherit the assembly.** When a workflow delegates (by advancing
+**Sub-workflows inherit the assembly.** When a workflow delegates (by calling
 an `archmax_workflow_<slug>` tool), the child runtime is
 composed from the *same* resolved inputs as the parent — model and
 `modelFactory`, `backend` and `mounts`, `sessionStore` and `checkpointer`, host
@@ -717,11 +736,14 @@ never delegated to is never loaded, and one delegated from many places is
 composed once. A child whose spec is broken surfaces as a *dispatch* failure, not
 an assembly failure — a parent still assembles.
 
-The child runs on the parent's **session id** (which is what gives it the same
-run zone) under a nested checkpoint namespace, so `sessions.list()` reports one
-session and the parent session's metrics include the child's tokens.
-`capabilities.subWorkflows` is stamped `true` for a governed assembly and `false`
-for the plain one.
+The child runs as a **separate session**, `<parent>~<state>:<workflow>:<n>`, in
+the same session store, with its own checkpoints, its own token accounting and its
+own file space: its `scratchpad/` is not its caller's, so it can neither read nor
+overwrite a file of its caller's. `sessions.list()` reports it beside its caller
+with `parentSessionId` naming the caller, and `sessions.delete` removes it by its
+own id. The only files that cross are the runtime's copies of declared `file` arguments and
+`file` returns. `capabilities.subWorkflows` is stamped `true` for a governed
+assembly and `false` for the plain one.
 
 Omit both options and behavior is identical to `archmax test`. Cases run
 sequentially (`tests.maxConcurrency` above 1 is rejected, not silently

package/skills/archmax-harness/references/hook-and-test-scripts.md

@@ -322,7 +322,8 @@ state fails that call closed with `parked`.
 Scripts still may not call `archmax_advance` (moving the state machine is the model's governed
 decision) or `archmax_set_variables`. Concurrent calls succeed or fail **independently**, so a script
 can act on what worked — `Promise.allSettled` is the honest shape when partial success is
-meaningful. Give each sub-run its own output path: they share one run zone.
+meaningful. Each sub-run is its own session with its own `scratchpad/`, so concurrent sub-runs
+never collide on a path; a `file` return comes back as a copy under a name no other file holds.
 
 ### Worked example: a `before` gate
 

package/skills/archmax-harness/references/workflow-schema.md

@@ -557,7 +557,9 @@ states:
 - **`type`** is one of `string`, `integer` (no fractional part), `number`
   (finite), `boolean`, `date` (RFC 3339 `YYYY-MM-DD`, a real calendar day),
   `date-time` (RFC 3339 with a mandatory `Z`/`±hh:mm` offset), `object` (not an
-  array) or `array`. Nothing is coerced (`"4"` is not an `integer`) and a typed
+  array), `array` or `file` (a path from the workspace root, such as
+  `scratchpad/attachments/invoice.pdf` or `skills/billing/assets/template.pdf`; see
+  [Passing files](#passing-files)). Nothing is coerced (`"4"` is not an `integer`) and a typed
   entry never takes `null`. It is held **at the start** (a mistyped seed is
   refused before any model call), **at the write** (`archmax_set_variables` of a
   mistyped typed return of the current trigger is a correctable refusal,
@@ -565,6 +567,17 @@ states:
   run — in practice a script or hook write). There are no enums, item or
   property schemas, ranges or optional inputs. An unknown `type`, an unknown
   entry key (`default:`) or an empty `description` fails load.
+- **A `file` value must name a readable file.** The pure rule checks only the
+  path's shape (a host runs it in a browser). At the start, at the write, at
+  completion and at a delegation call the runtime also requires a **file** (not a
+  folder) at the path that the session may read **on runtime authority** — the
+  rules a hook is bound by: zone rules (`checkpoints/`, `artifacts/`, `_specs/`
+  never) and every workflow-wide `forbid_always`, inherited ones included; the
+  state's allow list and mount/skill grants do not narrow it. So tell the agent to
+  write the file *before* it sets a `file` return: `archmax_set_variables` refuses
+  a path with nothing there. A host hands a file in with `TurnInput.files` (CLI:
+  `archmax run … --file invoice=./invoice.pdf`), which places it under
+  `scratchpad/attachments/` and seeds the path.
 - **When to type.** Type an entry when something outside the session reads the
   contract: a delegating model that must build the argument, a host publishing an
   MCP tool or a start form. Leave it bare when any value will do. Typing a
@@ -1015,7 +1028,8 @@ the host at assembly (`variables`, every seed locked), the agent mid-run
 
 `trigger` holds the current turn's trigger id. `title` holds a short one-line label
 naming the task the run is doing; the platform system prompt asks the agent to set
-one as its first activity and update it when the task changes significantly, so a
+one as its first activity, and to rename it only when the whole conversation has
+moved to a different subject (a follow-up on the same subject keeps it), so a
 host can name a run instead of showing a session id. A sub-workflow's child is not
 asked — its title names a session nothing lists and is never returned — so its
 prompt leaves the step out; do not write "set the title" into a child's state
@@ -1340,7 +1354,7 @@ enrich:
   delegation may happen is decided by the caller's `tools.allow` entry. A target
   with no `manual` entry has no state to start in and fails closed. `session:` and
   `message:` on that trigger are host-facing keys a delegation ignores: a sub-run
-  shares its parent's session, and carries no message. `sub-workflow` is no longer
+  is its own session, derived from its caller's, and carries no message. `sub-workflow` is no longer
   a trigger id — load and `validate` report it with the rename.
 - **Declare the child's signature** on that trigger — the contract, enforced both
   ways and at both ingresses:
@@ -1400,14 +1414,17 @@ enrich:
   state's work. A workspace overriding the platform prompt
   (`.platform/system/GRAPH_STATE.md`) keeps that by wrapping what children skip
   in `<!-- top-level-only -->` … `<!-- /top-level-only -->` lines.
-- **Same agent, isolated context, shared session.** Same model, backend, host
+- **Same agent, isolated context, own session.** Same model, backend, host
   tools; its **own** grading rubrics, from its own spec; a fresh transcript; the child's *own* per-state
-  `tools.allow`. It shares the run's session, so it writes `scratchpad/…` and
-  `scratchpad/…` exactly as the parent does and the parent reads them afterwards.
+  `tools.allow`. It is a separate session (`<parent>~<state>:<workflow>:<n>`)
+  with its own checkpoints and its own `scratchpad/`: a path it reads or writes
+  resolves inside its own session, so it can neither see nor overwrite a file of
+  its caller's, and concurrent sub-runs cannot collide on a path.
 - **Nothing crosses implicitly.** Down: only the arguments the call passed —
   the calling run's own variables are not copied. Up: only the result message
-  and the files. Everything the child sets is discarded when it finishes.
-- **Give each concurrent sub-run its own output path** — they share one run zone.
+  and the declared returns. Everything else the child sets or writes stays in its
+  session. The only files that cross are runtime-made copies of `file` arguments
+  and `file` returns (see "Passing files" below).
 - **Bounds** — the dispatcher's `bounds: { maxDepth: 3, maxConcurrent: 4 }`. No longer a spec key: the strict schema rejects `settings.sub_workflows` by name.
   Excess concurrency queues; depth and cycles are refused.
 - **Params are the sub-run's initial variables** — same construction, same name
@@ -1435,6 +1452,46 @@ parent reading a field the child does not return is an **error**; a state whose
 still carry it), and a fan-out is exempt from that warning because its
 entries' keys are not knowable statically.
 
+### Passing files
+
+A sub-run's `scratchpad/` is not its caller's, so a bare path string returned by a
+child (`returns: [result_file]`, untyped) names a file the caller **cannot
+read**. Type the entry `file` instead, and the runtime copies the file across:
+
+```yaml
+# the child
+triggers:
+  manual:
+    requires: [{ name: invoice, type: file }]
+    returns: [{ name: report, type: file }]
+```
+
+- **Down.** The caller passes any path in its workspace (`scratchpad/inbox/a.pdf`,
+  `skills/billing/assets/template.pdf`). Before the child starts, the runtime
+  copies the exact bytes into the **child's** `scratchpad/attachments/` (same name;
+  two arguments with one name take `-1`, `-2`) and seeds the child with that path,
+  so its opening message shows it. The child edits its own copy and never the
+  caller's file. The argument is a `read` path argument of the delegation tool, so
+  a `paths:` guard on the allow entry and the zone and mount rules bind it. An
+  argument naming nothing is refused `invalid-param` before the child runs. A
+  failed call's record names the caller's path.
+- **Up.** On completion, each `file` return the child set is copied into the
+  **caller's** `scratchpad/attachments/` and the result names that path. A taken
+  name gets the lowest free `-1`, `-2`, … before the extension (`report-1.pdf`), so
+  repeated or parallel calls never overwrite each other or the caller's files. A
+  return whose file is gone at completion fails the call `invalid-return`.
+- **No laundering.** A `file` value must name a file the session may read on
+  runtime authority, and a child inherits every ancestor's `forbid_always`. So a
+  child cannot hand back a file its caller's workflow denies: its agent's write
+  is refused, and a script's write is rejected at completion.
+- **Instructions to write.** Tell the child to write the file *first* and then set
+  the return to its path. Tell the caller the returned path is under
+  `scratchpad/attachments/`. Name files for what they hold (`<order_id>.json`):
+  the name survives the copy.
+- **Mocks and cases.** A mocked `file` return names a file in the case's own
+  session (seed it with `workspace:`), and it arrives copied into
+  `scratchpad/attachments/` like a real one. Assert the copy's path.
+
 ### A parked run may speak, never act
 
 A park does not end the conversation. Two moments get a **reply-only turn** — one

package/skills/archmax-harness/references/workflow-yaml.md

@@ -50,7 +50,7 @@ states:
           - { name: due, type: date, description: The day it is due. }  # typed: held at the boundary
         returns: [result_file]   #   variables the run guarantees on completion (a caller's result);
                                  #   short of them: a child returns what it set + a `note`; a top-level run is rejected
-                                 #   entry types: string integer number boolean date date-time object array
+                                 #   entry types: string integer number boolean date date-time object array file
     instructions: >-
       Record the decision in scratchpad/refund.json, then archmax_advance to
       review; never close the case yourself.

package/dist/workflow/prompt-pruning.d.ts

@@ -1,20 +0,0 @@
-/**
- * Pruning of upstream Deep Agents prompt guidance for built-in tools an
- * assembly withholds: guidance for a tool the model cannot call only teaches it
- * to try.
- */
-/** The upstream headings that document `tool`'s guidance (empty when unknown). */
-export declare function upstreamSectionsFor(tool: string): readonly string[];
-export interface PruneResult {
-    /** The prompt text with matched sections removed. */
-    text: string;
-    /** Headings that were found and removed. */
-    removed: string[];
-    /**
-     * Tools whose guidance was found nowhere. A partial match is a successful
-     * prune (upstream may carry only some of a tool's sections).
-     */
-    missingTools?: string[];
-}
-/** Prune the upstream guidance for every tool in `undisclosed`; tools with no known sections are ignored. */
-export declare function pruneUndisclosedToolSections(text: string, undisclosed: readonly string[]): PruneResult;

package/dist/workflow/prompt-pruning.js

@@ -1,83 +0,0 @@
-/**
- * Pruning of upstream Deep Agents prompt guidance for built-in tools an
- * assembly withholds: guidance for a tool the model cannot call only teaches it
- * to try.
- */
-/**
- * Upstream section headings owned by a built-in tool's guidance.
- *
- * `task`'s guidance is two sections, and both must be named: the spawner
- * overview carries the bulk of it, and the notes section follows. A partial
- * match counts as a successful prune, so listing only one of them silently ships
- * the other.
- */
-const SECTIONS_BY_TOOL = {
-    task: ["## `task` (subagent spawner)", "## Important Task Tool Usage Notes to Remember"],
-};
-/** The upstream headings that document `tool`'s guidance (empty when unknown). */
-export function upstreamSectionsFor(tool) {
-    return SECTIONS_BY_TOOL[tool] ?? [];
-}
-/** A section spans its heading line to the next heading of the same or higher level. */
-function sectionEnd(lines, start, level) {
-    for (let i = start + 1; i < lines.length; i++) {
-        const match = /^(#{1,6})\s/.exec(lines[i]);
-        if (match && match[1].length <= level)
-            return i;
-    }
-    return lines.length;
-}
-function headingLevel(heading) {
-    return /^(#{1,6})\s/.exec(heading)?.[1].length ?? 2;
-}
-/**
- * Put a target heading on its own line when composition glued it to the end of
- * the previous one.
- *
- * Upstream concatenates its prompt fragments without a separating newline, so a
- * section can arrive as `…within files## \`task\` (subagent spawner)`. Matching is
- * line-anchored (a `##` mid-sentence is prose, not a heading), so without this
- * the section is silently kept and billed on every call. Narrow by construction:
- * only a heading we were asked to remove is ever split out.
- */
-function unglueHeadings(text, headings) {
-    let out = text;
-    for (const heading of headings) {
-        let at = out.indexOf(heading);
-        while (at > 0) {
-            if (out[at - 1] !== "\n") {
-                out = `${out.slice(0, at)}\n${out.slice(at)}`;
-                at += 1;
-            }
-            at = out.indexOf(heading, at + heading.length);
-        }
-    }
-    return out;
-}
-/** Remove each heading's section. Matching is exact on the trimmed heading line. */
-function pruneSections(text, headings) {
-    if (!text || headings.length === 0)
-        return { text, removed: [] };
-    const removed = [];
-    let lines = unglueHeadings(text, headings).split("\n");
-    for (const heading of headings) {
-        const index = lines.findIndex((line) => line.trim() === heading);
-        if (index === -1)
-            continue;
-        const end = sectionEnd(lines, index, headingLevel(heading));
-        lines = [...lines.slice(0, index), ...lines.slice(end)];
-        removed.push(heading);
-    }
-    // Collapse the blank runs left behind so the result is byte-stable however many sections were cut.
-    return { text: lines.join("\n").replace(/\n{3,}/g, "\n\n").trim(), removed };
-}
-/** Prune the upstream guidance for every tool in `undisclosed`; tools with no known sections are ignored. */
-export function pruneUndisclosedToolSections(text, undisclosed) {
-    const result = pruneSections(text, undisclosed.flatMap((tool) => [...upstreamSectionsFor(tool)]));
-    const missingTools = undisclosed.filter((tool) => {
-        const owned = upstreamSectionsFor(tool);
-        return owned.length > 0 && !owned.some((heading) => result.removed.includes(heading));
-    });
-    return { ...result, ...(missingTools.length > 0 ? { missingTools } : {}) };
-}
-//# sourceMappingURL=prompt-pruning.js.map

package/dist/workflow/prompt-pruning.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt-pruning.js","sourceRoot":"","sources":["../../src/workflow/prompt-pruning.ts"],"names":[],"mappings":"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"}