@intentic/sandbox-contract 1.334.0 → 1.336.0

package/src/schemas/providers/usage.ts

@@ -23,6 +23,12 @@ export const UsageTurnSchema = z.object({
         .optional()
         .describe("The model that was asked for, when one was named. Differs from `model` when something resolved it."),
     harness: z.string().describe("Which agentic loop it ran on."),
+    // The runtime that served it, resolved from provider and harness: `harness` is what was asked for, and rows written
+    // before requests were normalized carry "claude-code" for providers that only ever run their own loop.
+    runtime: z
+        .string()
+        .optional()
+        .describe("The runtime that actually served it (claude-code, codex, opencode, cursor, acp, pi…). Absent on rows written before it was recorded."),
     // cancelled: stopped before it finished, not a failure: the user pressed Stop, or a daemon restart cut it (then
     // `errorCode` is `interrupted` and `errorMessage` says what became of it).
     // error: the provider or request killed the turn.
@@ -81,7 +87,8 @@ export const UsageTurnSchema = z.object({
     mapArm: z.boolean().optional(),
     mapChars: z.number().optional(),
     // Which comparison `mapArm` belongs to: absent on the first map-or-none rows; "compact-vs-full" from 2026-10-06 to
-    // 10-12, when the arm was the compact map and the holdout the full one; "map-vs-none" since, the map against none.
+    // 10-12, when the arm was the compact map and the holdout the full one; "map-vs-none" for 2026-10-12 to 10-13, the map
+    // against none; "map-vs-none-2" since, the same with readings off the main agent's calls and spawned children out.
     mapCohort: z.string().optional(),
     // Arm of the field-notes experiment, stable per conversation; notesChars is what the budget let through.
     notesArm: z.boolean().optional(),

package/src/schemas/settings.ts

@@ -11,6 +11,7 @@ import { SessionsPlacementSchema } from "./offload.js";
 import { LimitPolicySchema, RetryPolicySchema, RoomPolicySchema } from "./turn-break.js";
 import { ZoneSchema } from "../time/zone.js";
 import { VoiceSettingsSchema } from "./voice.js";
+import { AiNoticeSchema, AuditSettingsSchema, RetentionSettingsSchema } from "./data-protection.js";
 // Which prompt base the agent runs before this turn composes anything on top: Intentic's own (default), Claude Code's
 // preset, or the owner's text. Declared out here since both the daemon and the browser branch on it.
 // Kept in the daemon's auth root, never in SandboxSettings: an agent cannot edit its execution boundary.
@@ -566,6 +567,25 @@ export const SandboxSettingsSchema = z.object({
     voice: VoiceSettingsSchema.prefault({}).describe(
         "How the agent's replies are spoken aloud: whether a hands-free conversation is answered out loud, which voice speaks each language, and a speech provider of your own if you connected one.",
     ),
+    // What a data protection officer asks about (schemas/data-protection.ts). Every default is the behaviour from before
+    // these existed; the public-office preset on the data protection page is what turns them on, never a default.
+    retention: RetentionSettingsSchema.prefault({}).describe(
+        "How long this sandbox keeps each kind of copy it makes of what people and agents wrote: transcripts, restore points, the privacy shield's memory, converted documents and raw command output. Each defaults to forever.",
+    ),
+    audit: AuditSettingsSchema.prefault({}).describe(
+        "The audit trail: who changed a policy, a member, a gate or a setting, and optionally who read what. How long it is kept, and where a copy is sent.",
+    ),
+    // Read by the editor, not the daemon: the product analytics run in the browser, so the switch is honoured there for
+    // as long as this sandbox is the one open.
+    productAnalytics: z
+        .boolean()
+        .default(true)
+        .describe(
+            "Let Intentic's product analytics (usage events and session recordings in the editor, for people who agreed to them) run while this sandbox is open. Off sends nothing about any visit to this sandbox, whatever each person agreed to.",
+        ),
+    aiNotice: AiNoticeSchema.prefault({}).describe(
+        "A notice members confirm once, telling them they are working with an AI and what to check before relying on it.",
+    ),
     // Defaults all-allow, so a fresh sandbox behaves as it did before this floor existed.
     admission: AdmissionPolicySchema.prefault({}).describe(
         "Whether work started from outside may run, per kind of trigger: let it, hold it for approval, or refuse it. Composes with each automation's own setting, and the stricter of the two wins, so holding every visitor's message needs no edit to each automation.",
@@ -601,6 +621,18 @@ export const SandboxSettingsSchema = z.object({
         .max(10)
         .default(3)
         .describe("How many levels deep the delegation may go, since a subagent can start subagents of its own."),
+    // Width again, for a team-chat automation rather than a turn: each thread a message lands in is a conversation of
+    // its own, and threads of one automation are worked on side by side up to this many (automations/scheduler.ts in
+    // the daemon); one more waits, told it is queued, until a slot frees. Read per fire, so a change holds from the next
+    // thread on.
+    automationThreadsAtOnce: z
+        .number()
+        .min(1)
+        .max(20)
+        .default(3)
+        .describe(
+            "How many threads of one team-chat automation may be worked on at the same time. Each is its own agent turn, so this is how many agents one busy channel can start at once.",
+        ),
 });
 export type SandboxSettings = z.infer<typeof SandboxSettingsSchema>;
 // What a save takes: the settings as read, less what is only read. `turn.ending` holds only the checks a repository
@@ -685,17 +717,19 @@ export const InputSavingsSchema = z.object({
 export type InputSavings = z.infer<typeof InputSavingsSchema>;
 // One arm of a turn-level experiment; mean is per turn, since the two arms never hold the same count.
 // `mean` is over samples capped at both arms' pooled 95th percentile, so one runaway conversation cannot carry an arm.
+// For a yes/no reading (`openedWithListing`) it is the share of yeses, 0 to 1, and uncapped.
 export const SavingsArmSchema = z.object({ turns: z.number(), mean: z.number() });
 // One metric's reading of a turn-level experiment (the two arms, plus the arithmetic over them). `metric` says what
 // `mean`/`deltaPct` count:
 // searchCalls: searches a turn ran (the search teaching).
 // openingSearches: same, narrowed to before the turn first touched a file.
-// openingListings: directory listings a turn ran to orient itself (the project map).
+// openedWithListing: whether a turn listed directories to orient itself, as a share of turns (the project map).
 // callsBeforeTarget: how far a turn walked before touching a file it went on to edit.
 // failedCalls: tool calls that ended in error (the field notes, whose largest section is a failure taxonomy).
+// Every reading is the main agent's own: a subagent's calls are counted toward the turn and read for nothing.
 // Never cost: each mechanism moves one small part of a turn's work, inside the noise of the rest.
 export const TurnMetricReadingSchema = z.object({
-    metric: z.enum(["searchCalls", "openingSearches", "openingListings", "callsBeforeTarget", "failedCalls"]),
+    metric: z.enum(["searchCalls", "openingSearches", "openedWithListing", "callsBeforeTarget", "failedCalls"]),
     on: SavingsArmSchema,
     off: SavingsArmSchema,
     // Additional control turns to reach a fixed target resolution, not today's delta (which inherits noise and always
@@ -728,6 +762,12 @@ export const TurnExperimentSchema = z.object({
     // Content-addressed treatment version; the reader filters to the latest so two instruction revisions don't blur
     // into one experiment.
     cohort: z.string().optional(),
+    // The latest earlier cohort that reached an answer, with only its answered readings (a margin, with or without a
+    // delta), so restarting a comparison does not wipe a finding off the screen while the new one is early. `from` and
+    // `to` are its first and last measured turn inside the window read, epoch ms. Absent when no earlier one answered.
+    previous: z
+        .object({ from: z.number(), to: z.number(), cohort: z.string().optional(), metrics: z.array(TurnMetricReadingSchema) })
+        .optional(),
 });
 export type TurnExperiment = z.infer<typeof TurnExperimentSchema>;
 // What the settings row can say about the brief without opening it: whether there is one, how much of it this budget

package/src/schemas/system.ts

@@ -390,6 +390,7 @@ export const DaemonHealthSchema = z.object({
     // How the world reaches here: a dialed tunnel, or loopback only.
     reachedBy: z.enum(["tunnel", "loopback"]),
     build: BuildStampSchema,
+    atRestEncryption: z.object({ active: z.boolean(), stores: z.array(z.string()) }),
     // Which proofs this daemon takes to open a session, read before any sign-in since the route list arrives only after
     // one. Absent on a daemon from before email sign-in: Google, and the owner ticket on a hosted machine.
     signIn: z.object({ proofs: z.array(ProofMethodSchema) }).optional(),
@@ -410,6 +411,7 @@ export const DaemonHealthReadingSchema = z.object({
     reach: ReachStateSchema.optional().catch(undefined),
     reachedBy: z.string().optional().catch(undefined),
     build: BuildStampSchema.optional().catch(undefined),
+    atRestEncryption: z.object({ active: z.boolean(), stores: z.array(z.string()) }).optional().catch(undefined),
     // Proof names this build may not know are kept as text, so a newer daemon's list still reads.
     signIn: z
         .object({ proofs: z.array(z.string()).catch([]) })

package/src/schemas/workspace/workspace-tree.ts

@@ -295,9 +295,34 @@ export const WorkspaceResolveQuerySchema = WorkspaceScopeSchema.extend({
             "The reference as somebody wrote it. Often only the tail of the real path, which is why this is matched against the tree rather than read as-is.",
         ),
 });
+// Three answers, told apart by which fields are present: one file (`path` alone), several equally plausible ones (`path`
+// with `others`), or none (no `path`, perhaps `nearby`). "None" is an answer, not a path to try: opening the reference as
+// written then fails as if the file had been deleted, when it never existed under that name.
 export const WorkspaceResolveSchema = z.object({
-    path: z.string().optional().describe("The real path it means. Absent when nothing in the workspace ends that way."),
+    path: z
+        .string()
+        .optional()
+        .describe(
+            "The real path it means: the only match, or the most likely of several. Absent when nothing in that copy of the workspace ends that way.",
+        ),
+    others: z
+        .array(z.string())
+        .optional()
+        .describe("The other files it could just as well mean, most likely first, when more than one ends that way. Absent when it names exactly one."),
+    renamedFrom: z
+        .string()
+        .optional()
+        .describe(
+            "The path the reference named, when the conversation has since renamed or moved that file to `path`. Absent for a file still under the name it was given.",
+        ),
+    nearby: z
+        .array(z.string())
+        .optional()
+        .describe(
+            "Only when nothing matched: files it may have meant instead, most likely first. A file in the folder it named whose name contains the one asked for (renamed in place), then files with that same name elsewhere (moved).",
+        ),
 });
+export type WorkspaceResolve = z.infer<typeof WorkspaceResolveSchema>;
 // Direct file management (delete, new folder, rename/move, copy). Byte writes and editor saves go through POST
 // /workspace/upload instead, since oRPC can't carry a body.
 export const WorkspaceDirSchema = z.object({ path: z.string().min(1).describe("The folder to create. Missing folders above it are created too.") });

package/src/state/history-state.ts

@@ -35,7 +35,14 @@ export const HISTORY_STATE_FILES: readonly StateFile[] = [
     // address (settings/member-getting-started.ts). Carried for the same reason: a checklist someone put away should not
     // come back after a move.
     { path: "member-getting-started.json", portability: "carry" },
+    // Who confirmed the AI notice, and which wording (settings/member-ai-literacy.ts). Carried: it is the record an office
+    // shows for the AI Act's literacy duty, and a move must not make everyone confirm again or lose who already did.
+    { path: "member-ai-literacy.json", portability: "carry" },
     { path: "activity.jsonl", portability: "carry" },
+    // The audit trail (one hash-chained file per month, the checkpoint retention leaves, the forwarder's cursor and the
+    // audit settings last seen). Carried: an office's trail has to survive the sandbox moving, and a fresh chain on the
+    // target would read as the old one having been deleted.
+    { path: "audit/", portability: "carry" },
     { path: "usage.jsonl", portability: "carry" },
     { path: "account-usage.json", portability: "carry" },
     // Per-account stay-away for a provider's usage endpoint. Carried, not re-earned: earning one costs the very read it