@intentic/sandbox-contract 1.334.0 → 1.335.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.

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

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