@orkestrel/agent 0.0.42 → 0.0.43

package/dist/src/core/index.cjs

@@ -5228,6 +5228,32 @@ function intersectFilters(parent, child) {
 	};
 }
 /**
+* Resolves the workspace a run renders and acts on: the one `selected` names, else the registry's
+* active one, kept only while `allowed` admits its id.
+*
+* @remarks
+* A selection the registry does not hold resolves to `undefined` and never falls back to the active
+* workspace. `allowed` is three-way, as {@link import('../helpers.js').filterAllowList} reads it.
+* `AgentContext.build`, the caller an agent run hands each tool call, and a ledger's calibration
+* resolve through it, so what a request renders and what a call receives come from one rule.
+*
+* @param workspaces - The workspace registry to read
+* @param selected - The id a `switch` call or the `workspace` option selected, or `undefined`
+* @param allowed - The ceiling's `workspaces` list (`undefined` ⇒ every id, `[]` ⇒ none)
+* @returns The workspace, or `undefined` when none resolves
+*
+* @example
+* ```ts
+* import { resolveWorkspace } from '@orkestrel/agent'
+*
+* resolveWorkspace(agent.context.workspaces, 'returns', ['returns']) // the registered returns workspace
+* ```
+*/
+function resolveWorkspace(workspaces, selected, allowed) {
+	const workspace = selected === void 0 ? workspaces.active : workspaces.workspace(selected);
+	return workspace !== void 0 && filterAllowList(allowed, [workspace.id], (id) => id).length > 0 ? workspace : void 0;
+}
+/**
 * Renders one index line for a memo or a skill — `- name: description`, the built-in `render` of
 * the memo and skill managers.
 *
@@ -6283,10 +6309,8 @@ var AgentContext = class {
 			return skill === void 0 || skill.content.trim() === "" ? [] : [skill];
 		}), renderSkillBody, void 0);
 		if (bodies !== void 0) parts.push(bodies);
-		const selected = options?.disclosure?.workspace;
-		const workspace = selected === void 0 ? this.#workspaces.active : this.#workspaces.workspace(selected);
-		const shown = filterAllowList(scope.workspaces, workspace === void 0 ? [] : [workspace], (one) => one.id);
-		const files = filterAllowList(scope.files, shown.flatMap((one) => one.files()), (one) => one.path);
+		const workspace = resolveWorkspace(this.#workspaces, options?.disclosure?.workspace, scope.workspaces);
+		const files = filterAllowList(scope.files, workspace?.files() ?? [], (one) => one.path);
 		const documented = renderSection(WORKSPACE_SECTION_HEADER, files.flatMap((file) => (0, _orkestrel_workspace.isTextContent)(file.content) ? [{
 			path: file.path,
 			language: file.content.language,
@@ -7253,6 +7277,35 @@ function isAuthorityDecision(value) {
 		reason: _orkestrel_contract.isString
 	}, ["reason"])(value);
 }
+/**
+* Checks whether a value is an agent caller: a plain record whose own keys are exactly `workspace`
+* and `files`, whose `workspace` is `undefined` or an object, and whose `files` is `undefined` or an
+* array of strings.
+*
+* @remarks
+* Total: each member is read once, and an omitted, inherited, or undeclared member, a throwing
+* accessor, and a revoked `Proxy` return false rather than throw. It checks the shape a caller
+* carries, never that `workspace` is a live workspace: a value that crossed a wire passes when it
+* holds that shape, so accept its `workspace` only as the very instance your own registry holds
+* under that id.
+*
+* @param value - The unknown caller candidate, such as `ToolContext.caller`
+* @returns True if the value satisfies the caller contract; false otherwise
+*
+* @example
+* ```ts
+* isAgentCaller({ workspace: undefined, files: undefined }) // true
+* isAgentCaller({ workspace: 'returns' }) // false
+* ```
+*/
+function isAgentCaller(value) {
+	return (0, _orkestrel_contract.holds)(() => {
+		if (!(0, _orkestrel_contract.isRecord)(value) || !(0, _orkestrel_contract.matchesExactKeys)(value, ["workspace", "files"])) return false;
+		const workspace = value.workspace;
+		const files = value.files;
+		return (workspace === void 0 || (0, _orkestrel_contract.isObject)(workspace)) && (files === void 0 || (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString)(files));
+	});
+}
 // src/core/agents/helpers.ts
 /**
 * Projects an unknown value onto a fresh, exact `JSONValue` representation of an
@@ -8617,6 +8670,7 @@ function collectDisclosure(conversation, builtins) {
 * registers under a built-in's name is never read: `tool` and `execute` answer a built-in's name
 * from the run's manager and every other name from the host's. Each handler reads the ceiling when
 * it runs, the context scope intersected with the run scope at that moment, never a turn's copy.
+* The `caller` each call receives reads the ceiling the same way, as the call starts.
 */
 var AgentRun = class {
 	#context;
@@ -8629,6 +8683,7 @@ var AgentRun = class {
 	#ceiling = {};
 	#shown = { skills: [] };
 	#ids = [];
+	#files = [];
 	#advertised = [];
 	#snapshot;
 	#selection;
@@ -8712,6 +8767,31 @@ var AgentRun = class {
 		return this.#advertised.some((definition) => definition.name === "switch");
 	}
 	/**
+	* Returns what a tool call receives as `ToolContext.caller`: the workspace instance the working
+	* head rendered, kept only while the ceiling at this moment admits its id, and that ceiling's
+	* `files` list.
+	*
+	* @remarks
+	* The instance is the one the head's build resolved, never the registry's `active` pointer at the
+	* call, so a host's `switch` made while the provider answers reaches the next turn's head and not
+	* this call. Each read of this getter reads the `workspaces` and `files` lists of the context
+	* scope and the run scope one time each, and no other list, so a call reads them as it starts, a
+	* narrowing made after the turn's decision reaches that call, and a turn still reads its `tools`
+	* list once.
+	*
+	* @returns A fresh caller
+	*/
+	get caller() {
+		const outer = this.#context.scope;
+		const inner = this.#scope;
+		const rendered = this.#head?.rendered;
+		const [workspace] = filterAllowList(intersectKeys(outer?.workspaces, inner?.workspaces), rendered === void 0 ? [] : [rendered], (one) => one.id);
+		return {
+			workspace,
+			files: intersectKeys(outer?.files, inner?.files)
+		};
+	}
+	/**
 	* Returns the selection the working head rendered.
 	*
 	* @returns The selection, or undefined before the first build
@@ -8735,8 +8815,10 @@ var AgentRun = class {
 	* `load`, `unload`, or `switch` is enabled, and only the records of an enabled built-in count.
 	* Registered skills hold their tools back only while `load` is enabled. The view compared with
 	* the working head's is the ceiling's `instructions`, `skills`, `memos`, `files`, and
-	* `workspaces` lists, the shown skills by id, the shown workspace, and whether `switch` is
-	* advertised.
+	* `workspaces` lists, the shown skills by id, the shown workspace, the files that workspace
+	* renders under the ceiling's `files` list, compared by identity, and whether `switch` is
+	* advertised. An edit to a rendered file, by a tool or by the host, therefore makes the head
+	* stale, and an edit to a file no build renders does not.
 	*
 	* @returns True if the working head was built with another view and must be rebuilt; false otherwise
 	*/
@@ -8751,13 +8833,19 @@ var AgentRun = class {
 		this.#ceiling = ceiling;
 		this.#shown = shown;
 		this.#ids = shown.skills.flatMap((name) => this.#context.skills.skill(name)?.id ?? []);
+		this.#files = filterAllowList(ceiling.files, resolveWorkspace(this.#context.workspaces, shown.workspace, ceiling.workspaces)?.files() ?? [], (file) => file.path);
 		this.#advertised = filterAdvertisedTools(this.#candidates(ceiling), ceiling.tools, this.#builtins.has("load") ? this.#context.skills.skills() : [], shown.skills);
 		const head = this.#head;
-		return head === void 0 || !matchesHeadLists(head.ceiling, ceiling) || head.ids.length !== this.#ids.length || head.ids.some((id, index) => id !== this.#ids[index]) || head.workspace !== shown.workspace || head.switchable !== this.switchable;
+		return head === void 0 || !matchesHeadLists(head.ceiling, ceiling) || head.ids.length !== this.#ids.length || head.ids.some((id, index) => id !== this.#ids[index]) || head.workspace !== shown.workspace || head.switchable !== this.switchable || head.files.length !== this.#files.length || head.files.some((file, index) => file !== this.#files[index]);
 	}
 	/**
-	* Records what the working head was built with: the selection, the built array's length, and
-	* the view the last `observe` resolved.
+	* Records what the working head was built with: the selection, the built array's length, the
+	* view the last `observe` resolved, and the workspace instance the build rendered.
+	*
+	* @remarks
+	* Call it right after the build: it resolves the rendered workspace from the inputs the build
+	* read, the shown workspace and the context scope's `workspaces` list intersected with the
+	* snapshot's.
 	*
 	* @param selection - The selection the build rendered
 	* @param length - The length of the built array
@@ -8769,7 +8857,9 @@ var AgentRun = class {
 			ceiling: this.#ceiling,
 			ids: this.#ids,
 			workspace: this.#shown.workspace,
-			switchable: this.switchable
+			switchable: this.switchable,
+			files: this.#files,
+			rendered: resolveWorkspace(this.#context.workspaces, this.#shown.workspace, intersectKeys(this.#context.scope?.workspaces, this.#snapshot?.workspaces))
 		};
 	}
 	/**
@@ -9674,7 +9764,10 @@ var Agent = class {
 		const { allowed, denials } = authorization;
 		const entries = [...allowed].sort(([left], [right]) => left - right);
 		const started = entries.map(([, { call, tool }]) => {
-			if (!this.#changed(run, call, tool, advertised)) return run.execute(call, { signal });
+			if (!this.#changed(run, call, tool, advertised)) return run.execute(call, {
+				signal,
+				caller: run.caller
+			});
 			this.#emitter.emit("deny", call, `${call.name} changed after its decision`, void 0);
 			return denyCall(call, AUTHORITY_NOTES.denied);
 		});
@@ -13675,8 +13768,7 @@ var Ledger = class {
 	async #measureScale(head, bare, signal) {
 		const rate = bare / estimateMessages(head);
 		const workspace = this.#show(intersectFilters(this.#agent.context.scope, void 0)).workspace;
-		const workspaces = this.#agent.context.workspaces;
-		const files = ((workspace === void 0 ? workspaces.active : workspaces.workspace(workspace))?.files() ?? []).flatMap((file) => (0, _orkestrel_workspace.isTextContent)(file.content) ? [file.path] : []);
+		const files = (resolveWorkspace(this.#agent.context.workspaces, workspace, void 0)?.files() ?? []).flatMap((file) => (0, _orkestrel_workspace.isTextContent)(file.content) ? [file.path] : []);
 		const shown = this.#agent.context.build({
 			selection: {
 				messages: [],
@@ -14960,6 +15052,7 @@ exports.instructionInputShape = instructionInputShape;
 exports.intersectFilters = intersectFilters;
 exports.intersectKeys = intersectKeys;
 exports.isAgentBuiltin = isAgentBuiltin;
+exports.isAgentCaller = isAgentCaller;
 exports.isAgentError = isAgentError;
 exports.isAgentJobError = isAgentJobError;
 exports.isAuthorityDecision = isAuthorityDecision;
@@ -15092,6 +15185,7 @@ exports.requireWorkspace = requireWorkspace;
 exports.resolveDecision = resolveDecision;
 exports.resolveDisclosure = resolveDisclosure;
 exports.resolvePredict = resolvePredict;
+exports.resolveWorkspace = resolveWorkspace;
 exports.sanitizeToken = sanitizeToken;
 exports.sanitizeUsage = sanitizeUsage;
 exports.scanAmendments = scanAmendments;