eve 0.65.0 → 0.66.0

package/dist/src/execution/tools/ask-question.d.ts

@@ -1,20 +1,19 @@
-import { z } from "#compiled/zod/index.js";
 export { executeAskQuestionTool } from "#execution/tools/ask-question-workflow.js";
 export declare const ASK_QUESTION_TOOL_DESCRIPTION: string;
-export declare const ASK_QUESTION_INPUT_SCHEMA: z.ZodObject<{
-    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        description: z.ZodString;
-        label: z.ZodString;
-    }, z.core.$strict>>>;
-    question: z.ZodString;
-}, z.core.$strict>;
-export declare const ASK_QUESTION_OUTPUT_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    answer: z.ZodString;
-    status: z.ZodLiteral<"answered">;
-}, z.core.$strict>, z.ZodObject<{
-    status: z.ZodLiteral<"dismissed">;
-}, z.core.$strict>, z.ZodObject<{
-    status: z.ZodLiteral<"unavailable">;
-}, z.core.$strict>], "status">;
-export type AskQuestionInput = z.infer<typeof ASK_QUESTION_INPUT_SCHEMA>;
-export type AskQuestionOutput = z.infer<typeof ASK_QUESTION_OUTPUT_SCHEMA>;
+export interface AskQuestionInput {
+    options?: {
+        description: string;
+        label: string;
+    }[];
+    question: string;
+}
+export type AskQuestionOutput = {
+    answer: string;
+    status: "answered";
+} | {
+    status: "dismissed";
+} | {
+    status: "unavailable";
+};
+export declare const ASK_QUESTION_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<AskQuestionInput, AskQuestionInput>;
+export declare const ASK_QUESTION_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<AskQuestionOutput, AskQuestionOutput>;

package/dist/src/execution/tools/ask-question.js

@@ -1,2 +1,2 @@
-import{z}from"#compiled/zod/index.js";import{executeAskQuestionTool}from"#execution/tools/ask-question-workflow.js";const ASK_QUESTION_TOOL_DESCRIPTION=[`Ask the user a question and wait for the answer. Use this only when you cannot make good progress without the user's input: to choose between materially different approaches, fill in a missing requirement, or confirm something risky or irreversible. Do not ask for information you can find with your other tools, and do not ask the user to confirm routine steps.`,``,`Usage:`,`- Ask one focused question that includes the context needed to answer it.`,`- For a decision, offer 2-3 mutually exclusive options. Put the option you recommend first and end its label with "(Recommended)".`,`- Do not add an "Other" option; the user can always type their own answer.`,"- The result's `answer` is the chosen option's label or the user's own words.",`- If the status is "dismissed", the user moved on without answering; respond to their next message instead.`,`- If the status is "unavailable", no one can answer in this session; continue with your best judgment and state the assumption you made.`].join(`
-`),ASK_QUESTION_OPTION_SCHEMA=z.strictObject({description:z.string().min(1).max(200).describe(`One short sentence on the impact or tradeoff of choosing this option.`),label:z.string().min(1).max(80).describe(`User-facing label, 1-5 words.`)}),ASK_QUESTION_INPUT_SCHEMA=z.strictObject({options:z.array(ASK_QUESTION_OPTION_SCHEMA).min(2).max(3).refine(e=>new Set(e.map(e=>e.label)).size===e.length,{message:`Option labels must be unique.`}).describe(`Two or three mutually exclusive choices, recommended option first. Omit for an open-ended question. Never include an "Other" option.`).optional(),question:z.string().min(1).max(2e3).describe(`The question to show the user, with the context needed to answer it.`)}),ASK_QUESTION_OUTPUT_SCHEMA=z.discriminatedUnion(`status`,[z.strictObject({answer:z.string().describe(`The chosen option's label, or the user's own words.`),status:z.literal(`answered`)}),z.strictObject({status:z.literal(`dismissed`)}),z.strictObject({status:z.literal(`unavailable`)})]);export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_OUTPUT_SCHEMA,ASK_QUESTION_TOOL_DESCRIPTION,executeAskQuestionTool};
+import{defineJsonSchema}from"#tools/schema.js";import{executeAskQuestionTool}from"#execution/tools/ask-question-workflow.js";const ASK_QUESTION_TOOL_DESCRIPTION=[`Ask the user a question and wait for the answer. Use this only when you cannot make good progress without the user's input: to choose between materially different approaches, fill in a missing requirement, or confirm something risky or irreversible. Do not ask for information you can find with your other tools, and do not ask the user to confirm routine steps.`,``,`Usage:`,`- Ask one focused question that includes the context needed to answer it.`,`- For a decision, offer 2-3 mutually exclusive options. Put the option you recommend first and end its label with "(Recommended)".`,`- Do not add an "Other" option; the user can always type their own answer.`,"- The result's `answer` is the chosen option's label or the user's own words.",`- If the status is "dismissed", the user moved on without answering; respond to their next message instead.`,`- If the status is "unavailable", no one can answer in this session; continue with your best judgment and state the assumption you made.`].join(`
+`),ASK_QUESTION_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{options:{type:`array`,minItems:2,maxItems:3,items:{type:`object`,properties:{description:{type:`string`,minLength:1,maxLength:200,description:`One short sentence on the impact or tradeoff of choosing this option.`},label:{type:`string`,minLength:1,maxLength:80,description:`User-facing label, 1-5 words.`}},required:[`description`,`label`],additionalProperties:!1},description:`Two or three mutually exclusive choices, recommended option first. Omit for an open-ended question. Never include an "Other" option.`},question:{type:`string`,minLength:1,maxLength:2e3,description:`The question to show the user, with the context needed to answer it.`}},required:[`question`],additionalProperties:!1},e=>e.options!==void 0&&new Set(e.options.map(e=>e.label)).size!==e.options.length?`Option labels must be unique.`:void 0),ASK_QUESTION_OUTPUT_SCHEMA=defineJsonSchema({oneOf:[{type:`object`,properties:{answer:{type:`string`,description:`The chosen option's label, or the user's own words.`},status:{type:`string`,const:`answered`}},required:[`answer`,`status`],additionalProperties:!1},{type:`object`,properties:{status:{type:`string`,const:`dismissed`}},required:[`status`],additionalProperties:!1},{type:`object`,properties:{status:{type:`string`,const:`unavailable`}},required:[`status`],additionalProperties:!1}]});export{ASK_QUESTION_INPUT_SCHEMA,ASK_QUESTION_OUTPUT_SCHEMA,ASK_QUESTION_TOOL_DESCRIPTION,executeAskQuestionTool};

package/dist/src/execution/tools/connection-search.js

@@ -1,2 +1,2 @@
-import{z}from"#compiled/zod/index.js";import{createLogger}from"#internal/logging.js";import{loadContext}from"#context/container.js";import{toError}from"#shared/errors.js";import{defineTool}from"#tools/definition.js";import{stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{ContextKey}from"#context/key.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{resolveApprovalPolicy}from"#approval/definition.js";import{getAuthorizationResults,requestAuthorization}from"#harness/authorization.js";import{createAuthorizationExecution}from"#runtime/connections/scoped-authorization.js";import{isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#connections/errors.js";import{resolveConnectionAuthorization}from"#runtime/connections/resolve-authorization.js";import{supportsInteractiveAuthorization}from"#shared/connection-types.js";const logger=createLogger(`framework.connection-search-dynamic`),CONNECTION_SEARCH_INPUT_SCHEMA=z.strictObject({connection:z.string().describe(`Optional: limit search to a specific connection name.`).optional(),keywords:z.string().describe(`Search keywords and expanded aliases. Distill intent into keywords; avoid stop words like 'a', 'the', 'in'.`),limit:z.number().describe(`Max results to return. Default 10.`).optional()}),connectionSchema=z.looseObject({}),CONNECTION_SEARCH_RESULT_ITEM_SCHEMA=z.strictObject({connection:z.string(),description:z.string(),error:z.string().optional(),inputSchema:connectionSchema.optional(),needsAuthorization:z.boolean().optional(),outputSchema:connectionSchema.optional(),qualifiedName:z.string().optional(),tool:z.string().optional()}),CONNECTION_SEARCH_OUTPUT_SCHEMA=z.array(CONNECTION_SEARCH_RESULT_ITEM_SCHEMA),ConnectionSearchResultsKey=new ContextKey(`eve.connectionSearchResults`);function qualifiedConnectionToolName(e,t){return`${e}__${t}`}function tokenize(e){return e.toLowerCase().split(/[\s_\-./]+/).filter(e=>e.length>1)}function scoreMatch(e,t){let n=tokenize(t.name),r=tokenize(t.description),i=0;for(let t of e){for(let e of n)(e.includes(t)||t.includes(e))&&(i+=3);for(let e of r)(e.includes(t)||t.includes(e))&&(i+=1)}return i}async function resolveInteractiveAuth(e,t){let n=e.getConnections().find(e=>e.connectionName===t);if(n===void 0)return;let r=await resolveConnectionAuthorization(n);if(r!==void 0&&supportsInteractiveAuthorization(r))return{scope:n.connectionName,instanceId:n.instanceId,connection:{url:n.url??``},authorization:r}}async function completePendingAuthorizations(e,t,n){assertPendingConnectionAuthorizationInstances(e);for(let r of t){if(!getAuthorizationResults().some(e=>e.name===r.connectionName))continue;let t=await resolveInteractiveAuth(e,r.connectionName);t!==void 0&&await n.complete(t)}}async function executeConnectionSearch(e){let t=loadContext(),n=t.get(ConnectionRegistryKey);if(n===void 0)return[];let r=e.limit??10,i=tokenize(e.keywords),a=[],o=[],s=e.connection!==void 0&&e.connection!==``?n.getConnections().filter(t=>t.connectionName===e.connection):n.getConnections();if(e.connection&&s.length===0)throw Error(`Connection "${e.connection}" is not registered. Available connections: ${n.getConnectionNames().join(`, `)}.`);let c=createAuthorizationExecution();await completePendingAuthorizations(n,s,c);let l=[];for(let e of s){let t;try{t=await n.getClient(e.connectionName).getToolMetadata()}catch(t){if(isConnectionAuthorizationRequiredError(t)){let r=await resolveInteractiveAuth(n,e.connectionName);if(r!==void 0)try{let e=await c.handleError(t,r);l.push(...e.challenges)}catch(t){let n=toError(t);logger.warn(`connection authorization failed`,{connection:e.connectionName,error:n}),o.push({connection:e.connectionName,description:e.description,error:isConnectionAuthorizationFailedError(n)?n.message:`Failed to start authorization for "${e.connectionName}": ${n.message}`});continue}o.push({connection:e.connectionName,description:e.description,needsAuthorization:!0});continue}if(isConnectionAuthorizationFailedError(t)){logger.warn(`connection authorization failed`,{connection:e.connectionName,reason:t.reason,retryable:t.retryable,error:t}),o.push({connection:e.connectionName,description:e.description,error:`Authorization failed for ${e.connectionName}: ${t.message}`});continue}let r=toError(t);logger.warn(`failed to load connection tools`,{connection:e.connectionName,error:r}),o.push({connection:e.connectionName,description:e.description,error:`Failed to load tools for "${e.connectionName}": ${r.message}`});continue}for(let n of t){let t=scoreMatch(i,n);t>0&&a.push({item:{connection:e.connectionName,description:n.description,inputSchema:n.inputSchema,outputSchema:n.outputSchema,qualifiedName:qualifiedConnectionToolName(e.connectionName,n.name),tool:n.name},score:t})}}if(l.length>0)return requestAuthorization(l);let u=o.filter(e=>e.error!==void 0);if(s.length>0&&u.length===s.length)throw Error(u.map(e=>e.error).join(`
+import{createLogger}from"#internal/logging.js";import{loadContext}from"#context/container.js";import{toError}from"#shared/errors.js";import{defineJsonSchema}from"#tools/schema.js";import{defineTool}from"#tools/definition.js";import{stampDurableDynamicToolCallbacks}from"#tools/durable-callbacks.js";import{ContextKey}from"#context/key.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{resolveApprovalPolicy}from"#approval/definition.js";import{getAuthorizationResults,requestAuthorization}from"#harness/authorization.js";import{createAuthorizationExecution}from"#runtime/connections/scoped-authorization.js";import{isConnectionAuthorizationFailedError,isConnectionAuthorizationRequiredError}from"#connections/errors.js";import{resolveConnectionAuthorization}from"#runtime/connections/resolve-authorization.js";import{supportsInteractiveAuthorization}from"#shared/connection-types.js";const logger=createLogger(`framework.connection-search-dynamic`),CONNECTION_SEARCH_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{connection:{type:`string`,description:`Optional: limit search to a specific connection name.`},keywords:{type:`string`,description:`Search keywords and expanded aliases. Distill intent into keywords; avoid stop words like 'a', 'the', 'in'.`},limit:{type:`number`,description:`Max results to return. Default 10.`}},required:[`keywords`],additionalProperties:!1}),CONNECTION_SEARCH_OUTPUT_SCHEMA=defineJsonSchema({type:`array`,items:{type:`object`,properties:{connection:{type:`string`},description:{type:`string`},error:{type:`string`},inputSchema:{type:`object`},needsAuthorization:{type:`boolean`},outputSchema:{type:`object`},qualifiedName:{type:`string`},tool:{type:`string`}},required:[`connection`,`description`],additionalProperties:!1}}),ConnectionSearchResultsKey=new ContextKey(`eve.connectionSearchResults`);function qualifiedConnectionToolName(e,t){return`${e}__${t}`}function tokenize(e){return e.toLowerCase().split(/[\s_\-./]+/).filter(e=>e.length>1)}function scoreMatch(e,t){let n=tokenize(t.name),r=tokenize(t.description),i=0;for(let t of e){for(let e of n)(e.includes(t)||t.includes(e))&&(i+=3);for(let e of r)(e.includes(t)||t.includes(e))&&(i+=1)}return i}async function resolveInteractiveAuth(e,t){let n=e.getConnections().find(e=>e.connectionName===t);if(n===void 0)return;let r=await resolveConnectionAuthorization(n);if(r!==void 0&&supportsInteractiveAuthorization(r))return{scope:n.connectionName,instanceId:n.instanceId,connection:{url:n.url??``},authorization:r}}async function completePendingAuthorizations(e,t,n){assertPendingConnectionAuthorizationInstances(e);for(let r of t){if(!getAuthorizationResults().some(e=>e.name===r.connectionName))continue;let t=await resolveInteractiveAuth(e,r.connectionName);t!==void 0&&await n.complete(t)}}async function executeConnectionSearch(e){let t=loadContext(),n=t.get(ConnectionRegistryKey);if(n===void 0)return[];let r=e.limit??10,i=tokenize(e.keywords),a=[],o=[],s=e.connection!==void 0&&e.connection!==``?n.getConnections().filter(t=>t.connectionName===e.connection):n.getConnections();if(e.connection&&s.length===0)throw Error(`Connection "${e.connection}" is not registered. Available connections: ${n.getConnectionNames().join(`, `)}.`);let c=createAuthorizationExecution();await completePendingAuthorizations(n,s,c);let l=[];for(let e of s){let t;try{t=await n.getClient(e.connectionName).getToolMetadata()}catch(t){if(isConnectionAuthorizationRequiredError(t)){let r=await resolveInteractiveAuth(n,e.connectionName);if(r!==void 0)try{let e=await c.handleError(t,r);l.push(...e.challenges)}catch(t){let n=toError(t);logger.warn(`connection authorization failed`,{connection:e.connectionName,error:n}),o.push({connection:e.connectionName,description:e.description,error:isConnectionAuthorizationFailedError(n)?n.message:`Failed to start authorization for "${e.connectionName}": ${n.message}`});continue}o.push({connection:e.connectionName,description:e.description,needsAuthorization:!0});continue}if(isConnectionAuthorizationFailedError(t)){logger.warn(`connection authorization failed`,{connection:e.connectionName,reason:t.reason,retryable:t.retryable,error:t}),o.push({connection:e.connectionName,description:e.description,error:`Authorization failed for ${e.connectionName}: ${t.message}`});continue}let r=toError(t);logger.warn(`failed to load connection tools`,{connection:e.connectionName,error:r}),o.push({connection:e.connectionName,description:e.description,error:`Failed to load tools for "${e.connectionName}": ${r.message}`});continue}for(let n of t){let t=scoreMatch(i,n);t>0&&a.push({item:{connection:e.connectionName,description:n.description,inputSchema:n.inputSchema,outputSchema:n.outputSchema,qualifiedName:qualifiedConnectionToolName(e.connectionName,n.name),tool:n.name},score:t})}}if(l.length>0)return requestAuthorization(l);let u=o.filter(e=>e.error!==void 0);if(s.length>0&&u.length===s.length)throw Error(u.map(e=>e.error).join(`
 `));a.sort((e,t)=>t.score-e.score);let d=a.slice(0,r).map(e=>e.item);if(d.length>0){let e=[...d,...o],n=t.get(ConnectionSearchResultsKey)??[],r=new Map(n.map(e=>[e.qualifiedName,e]));for(let e of d)e.qualifiedName&&r.set(e.qualifiedName,e);return t.set(ConnectionSearchResultsKey,[...r.values()]),e}return s.map(e=>o.find(t=>t.connection===e.connectionName)||{connection:e.connectionName,description:e.description})}function readDiscoveredToolClosure(e){let t=e.connectionName,n=e.toolName;if(typeof t!=`string`||typeof n!=`string`)throw Error(`Discovered connection tool callback metadata is invalid.`);return{connectionName:t,toolName:n}}async function executeDiscoveredConnectionTool(e,t,n){let{connectionName:r,toolName:i}=readDiscoveredToolClosure(e),a=loadContext().get(ConnectionRegistryKey);if(a===void 0)throw Error(`Connection registry is unavailable while replaying a discovered tool.`);assertPendingConnectionAuthorizationInstances(a);let o=await resolveInteractiveAuth(a,r),s=createAuthorizationExecution();o!==void 0&&await s.complete(o);try{return await a.getClient(r).executeTool(i,t,{abortSignal:n.abortSignal,callId:n.callId})}catch(e){return await s.handleError(e,o)}}function assertPendingConnectionAuthorizationInstances(e){let t=new Map(e.getConnections().map(e=>[e.connectionName,e]));for(let e of getAuthorizationResults())if(e.instanceId!==void 0&&t.get(e.name)?.instanceId!==e.instanceId)throw Error(`Authorization for "${e.name}" cannot complete because its resolved connection changed while sign-in was pending. Start sign-in again.`)}async function requestDiscoveredConnectionToolApproval(e,t){let{connectionName:n}=readDiscoveredToolClosure(e),r=loadContext().get(ConnectionRegistryKey)?.getConnectionApproval(n);return r===void 0?`not-applicable`:await resolveApprovalPolicy(r)(t)}async function authorizeDiscoveredConnectionToolApproval(e,t){let{connectionName:n}=readDiscoveredToolClosure(e),r=loadContext().get(ConnectionRegistryKey)?.getConnectionApproval(n),i=r===void 0||typeof r==`function`?void 0:r.response;return i===void 0?{reason:`Approval response authorization is unavailable.`,status:`rejected`}:await i(t)}async function resolveConnectionSearchDynamicTools(){let e=loadContext().get(ConnectionRegistryKey);if(!e||e.getConnections().length===0)return null;let t=e.getConnections().map(e=>e.connectionName),n=new Set(t),r=(loadContext().get(ConnectionSearchResultsKey)??[]).filter(e=>n.has(e.connection)),i={},a=defineTool({description:`Search for tools across your connections. Discovered tools become directly callable by their qualified name (e.g. \`linear__list_issues\`) in your next response. Available connections: ${t.join(`, `)}.`,inputSchema:CONNECTION_SEARCH_INPUT_SCHEMA,async execute(e){return executeConnectionSearch(e)},outputSchema:CONNECTION_SEARCH_OUTPUT_SCHEMA});stampDurableDynamicToolCallbacks(a,{inputSchema:{callback:()=>CONNECTION_SEARCH_INPUT_SCHEMA,closure:{}},outputSchema:{callback:()=>CONNECTION_SEARCH_OUTPUT_SCHEMA,closure:{}},execute:{callback:(e,t)=>executeConnectionSearch(t),closure:{}}}),i.connection_search=a;for(let t of r){let n=t.connection,r=t.tool,a=e.getConnectionApproval(n),o={connectionName:n,toolName:r},s=defineTool({description:t.description,inputSchema:t.inputSchema??{type:`object`},approval:a,outputSchema:t.outputSchema,async execute(e,t){return await executeDiscoveredConnectionTool(o,e,t)}});stampDurableDynamicToolCallbacks(s,{execute:{callback:executeDiscoveredConnectionTool,closure:o},...a===void 0?{}:{approvalRequest:{callback:requestDiscoveredConnectionToolApproval,closure:o}},...a===void 0||typeof a==`function`||a.response===void 0?{}:{approvalResponse:{callback:authorizeDiscoveredConnectionToolApproval,closure:o}}}),i[qualifiedConnectionToolName(n,r)]=s}return i}export{resolveConnectionSearchDynamicTools};

package/dist/src/execution/tools/load-skill.d.ts

@@ -1,6 +1,10 @@
-import { z } from "#compiled/zod/index.js";
-export declare const SKILL_INPUT_SCHEMA: z.ZodObject<{
-    skill: z.ZodString;
-}, z.core.$strict>;
-export declare const SKILL_OUTPUT_SCHEMA: z.ZodString;
+/**
+ * Typed input accepted by {@link executeLoadSkillTool}.
+ */
+interface LoadSkillInput {
+    skill: string;
+}
+export declare const SKILL_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<LoadSkillInput, LoadSkillInput>;
+export declare const SKILL_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<string, string>;
 export declare function executeLoadSkill(input: unknown): Promise<unknown>;
+export {};

package/dist/src/execution/tools/load-skill.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{loadContext}from"#context/container.js";import{DynamicSkillManifestKey,SandboxKey}from"#context/keys.js";import{loadSkillFromSandbox}from"#runtime/skills/sandbox-access.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";async function executeLoadSkillTool(e){let t=loadContext(),{skill:n}=e,r=t.require(BundleKey).resolvedAgent.skills,i=availableDynamicSkillNames(t),a=[...new Set([...r.map(e=>e.name),...i])].sort();try{if(i.includes(n)){let e=t.get(SandboxKey);if(e===void 0)throw Error(`The dynamic skill "${n}" requires sandbox access on the runtime context.`);return await loadSkillFromSandbox(e,n,a)}let e=r.find(e=>e.name===n);if(e!==void 0)return e.markdown;throw Error(formatSkillNotFoundError(n,a))}catch(e){let r=t.get(ConnectionRegistryKey)?.getConnectionNames().find(e=>e.toLowerCase()===n.toLowerCase());if(r===void 0||a.includes(n))throw e;let i=e instanceof Error?e.message:String(e);throw Error(`${i} "${r}" is an installed connection, not a skill. Use connection_search with connection "${r}" to find its tools.`,{cause:e})}}function availableDynamicSkillNames(e){let t=Object.values(e.get(DynamicSkillManifestKey)??{}).flat().map(e=>e.name);return[...new Set(t)].sort()}function formatSkillNotFoundError(e,t){return`No skill named "${e}".${t.length>0?` Available skills: ${t.join(`, `)}.`:``}`}const SKILL_INPUT_SCHEMA=z.strictObject({skill:z.string().describe(`Available skill name or id.`)}),SKILL_OUTPUT_SCHEMA=z.string();async function executeLoadSkill(e){return await executeLoadSkillTool(e)}export{SKILL_INPUT_SCHEMA,SKILL_OUTPUT_SCHEMA,executeLoadSkill};
+import{loadContext}from"#context/container.js";import{DynamicSkillManifestKey}from"#context/keys.js";import{defineJsonSchema}from"#tools/schema.js";import{stripSkillFrontmatter}from"#shared/skill-package.js";import{ConnectionRegistryKey}from"#context/providers/connection-key.js";import{BundleKey}from"#runtime/sessions/runtime-context-keys.js";async function executeLoadSkillTool(e){let t=loadContext(),{skill:n}=e,r=Object.values(t.get(DynamicSkillManifestKey)??{}).flat(),i=t.require(BundleKey).resolvedAgent.skills,a=r.find(e=>e.name===n);if(a!==void 0)return stripSkillFrontmatter(a.markdown);let o=i.find(e=>e.name===n);if(o!==void 0)return o.markdown;let s=formatSkillNotFoundError(n,[...new Set([...r,...i].map(e=>e.name))].sort()),c=t.get(ConnectionRegistryKey)?.getConnectionNames().find(e=>e.toLowerCase()===n.toLowerCase());throw Error(c===void 0?s:`${s} "${c}" is an installed connection, not a skill. Use connection_search with connection "${c}" to find its tools.`)}function formatSkillNotFoundError(e,t){return`No skill named "${e}".${t.length>0?` Available skills: ${t.join(`, `)}.`:``}`}const SKILL_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{skill:{type:`string`,description:`Available skill name or id.`}},required:[`skill`],additionalProperties:!1}),SKILL_OUTPUT_SCHEMA=defineJsonSchema({type:`string`});async function executeLoadSkill(e){return await executeLoadSkillTool(e)}export{SKILL_INPUT_SCHEMA,SKILL_OUTPUT_SCHEMA,executeLoadSkill};

package/dist/src/execution/tools/sleep-workflow.js

@@ -1 +1 @@
-import{sleep}from"#compiled/@workflow/core/index.js";async function executeSleepTool(e){"use workflow";return await sleep(Math.ceil(e.seconds*1e3)),{waitedSeconds:e.seconds}}executeSleepTool.workflowId=`workflow//eve@0.65.0//executeSleepTool`;export{executeSleepTool};
+import{sleep}from"#compiled/@workflow/core/index.js";async function executeSleepTool(e){"use workflow";return await sleep(Math.ceil(e.seconds*1e3)),{waitedSeconds:e.seconds}}executeSleepTool.workflowId=`workflow//eve@0.66.0//executeSleepTool`;export{executeSleepTool};

package/dist/src/execution/tools/sleep.d.ts

@@ -1,11 +1,10 @@
-import { z } from "#compiled/zod/index.js";
 export { executeSleepTool } from "#execution/tools/sleep-workflow.js";
 export declare const SLEEP_TOOL_DESCRIPTION = "Wait for a specified amount of time before continuing. Use this when a process or condition needs time to change before it is useful to check its progress or status again.";
-export declare const SLEEP_INPUT_SCHEMA: z.ZodObject<{
-    seconds: z.ZodNumber;
-}, z.core.$strict>;
-export declare const SLEEP_OUTPUT_SCHEMA: z.ZodObject<{
-    waitedSeconds: z.ZodNumber;
-}, z.core.$strict>;
-export type SleepToolInput = z.infer<typeof SLEEP_INPUT_SCHEMA>;
-export type SleepToolOutput = z.infer<typeof SLEEP_OUTPUT_SCHEMA>;
+export interface SleepToolInput {
+    seconds: number;
+}
+export interface SleepToolOutput {
+    waitedSeconds: number;
+}
+export declare const SLEEP_INPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SleepToolInput, SleepToolInput>;
+export declare const SLEEP_OUTPUT_SCHEMA: import("#tools/schema.js").ToolSchema<SleepToolOutput, SleepToolOutput>;

package/dist/src/execution/tools/sleep.js

@@ -1 +1 @@
-import{z}from"#compiled/zod/index.js";import{executeSleepTool}from"#execution/tools/sleep-workflow.js";const MAX_SLEEP_SECONDS=Math.floor((2**53-1)/1e3),SLEEP_TOOL_DESCRIPTION=`Wait for a specified amount of time before continuing. Use this when a process or condition needs time to change before it is useful to check its progress or status again.`,SLEEP_INPUT_SCHEMA=z.strictObject({seconds:z.number().positive().max(MAX_SLEEP_SECONDS).describe(`How long to wait, in seconds.`)}),SLEEP_OUTPUT_SCHEMA=z.strictObject({waitedSeconds:z.number().positive()});export{SLEEP_INPUT_SCHEMA,SLEEP_OUTPUT_SCHEMA,SLEEP_TOOL_DESCRIPTION,executeSleepTool};
+import{defineJsonSchema}from"#tools/schema.js";import{executeSleepTool}from"#execution/tools/sleep-workflow.js";const MAX_SLEEP_SECONDS=Math.floor((2**53-1)/1e3),SLEEP_TOOL_DESCRIPTION=`Wait for a specified amount of time before continuing. Use this when a process or condition needs time to change before it is useful to check its progress or status again.`,SLEEP_INPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{seconds:{type:`number`,exclusiveMinimum:0,maximum:MAX_SLEEP_SECONDS,description:`How long to wait, in seconds.`}},required:[`seconds`],additionalProperties:!1}),SLEEP_OUTPUT_SCHEMA=defineJsonSchema({type:`object`,properties:{waitedSeconds:{type:`number`,exclusiveMinimum:0}},required:[`waitedSeconds`],additionalProperties:!1});export{SLEEP_INPUT_SCHEMA,SLEEP_OUTPUT_SCHEMA,SLEEP_TOOL_DESCRIPTION,executeSleepTool};

package/dist/src/execution/tools/subagent/emit-event-step.d.ts

@@ -1,6 +1,6 @@
 import { type DurableSessionState } from "#execution/durable-session-store.js";
 import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
-/** Emits an agent invocation event on the parent stream. */
+/** Publishes a subagent notification, then runs its hooks without model preparation. */
 export declare function emitSubagentEventStep(input: {
     readonly event: UnstampedMessageStreamEvent;
     readonly sessionWritable: WritableStream<Uint8Array>;
@@ -8,4 +8,5 @@ export declare function emitSubagentEventStep(input: {
     readonly sessionState: DurableSessionState;
 }): Promise<{
     readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
 }>;

package/dist/src/execution/tools/subagent/emit-event-step.js

@@ -1 +1 @@
-import{contextStorage}from"#context/container.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{sessionProvider}from"#context/providers/session.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{readDurableSession}from"#execution/durable-session-store.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{createSessionEventSink}from"#execution/session/event-sink.js";async function emitSubagentEventStep(e){"use step";let t=await deserializeContext(e.serializedContext),n=t.require(BundleKey),r=readDurableSession(e.sessionState);t.setVirtualContext(sessionProvider.key,sessionProvider.create(t,r).value);let i=createSessionEventSink({abortSignal:void 0,adapter:t.require(ChannelKey),bundle:n,ctx:t,effectiveAgent:resolveEffectiveAgentRuntime(n,t),instrumentation:void 0,isFirstTurn:e.sessionState.emissionState.sequence===0,sessionWritable:e.sessionWritable,sessionId:r.sessionId});try{await contextStorage.run(t,()=>i.handleEvent(e.event,r.history))}finally{i.release()}return{serializedContext:serializeContext(t)}}export{emitSubagentEventStep};
+import{contextStorage}from"#context/container.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{hydrateDurableSession}from"#execution/session.js";import{withContextScope}from"#context/run-step.js";import{dispatchStreamEventHooks}from"#context/hook-lifecycle.js";import{createSessionEventSink}from"#execution/session/event-sink.js";import{reconcileSessionContinuationToken}from"#execution/reconcile-session-continuation-token.js";async function emitSubagentEventStep(e){"use step";let t=await deserializeContext(e.serializedContext),n=t.require(BundleKey),publish=async()=>{let n=createSessionEventSink({adapter:t.require(ChannelKey),ctx:t,isFirstTurn:e.sessionState.emissionState.sequence===0,sessionWritable:e.sessionWritable,sessionId:e.sessionState.sessionId});try{return await contextStorage.run(t,()=>n.emit(e.event))}finally{n.release()}},r=n.hookRegistry;if((r.streamEventsByType.get(e.event.type)?.length??0)===0&&r.streamEventsWildcard.length===0)return await publish(),{serializedContext:serializeContext(t),sessionState:e.sessionState};let i=resolveEffectiveAgentRuntime(n,t),a=hydrateDurableSession({durable:readDurableSession(e.sessionState),turnAgent:i.turnAgent,compactionOverrides:{thresholdPercent:i.thresholdPercent}}),o=await withContextScope(t,a,async e=>{let n=await publish();return n.suppressed||await dispatchStreamEventHooks({ctx:t,registry:r,event:n.event}),{result:void 0,session:e}});return{serializedContext:serializeContext(t),sessionState:createDurableSessionState({session:reconcileSessionContinuationToken(t,o.session)})}}export{emitSubagentEventStep};

package/dist/src/execution/tools/subagent/task-agent-requests.js

@@ -1 +1 @@
-import{emitSubagentEventStep}from"#execution/tools/subagent/emit-event-step.js";import{dispatchTaskAgentInvocationStep,settleTaskAgentInvocationStep}from"#execution/tools/subagent/invoke-step.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";async function applyTaskAgentRequest(e,t){let{request:n}=e;switch(n.kind){case`agent-settled`:{let r=await settleTaskAgentInvocationStep({ownerId:e.ownerId,result:n.result,serializedContext:t.serializedContext,sessionState:t.sessionState,taskId:e.taskId}),i=r.serializedContext;return r.completion!==void 0&&(i=(await emitSubagentEventStep({event:r.completion,sessionWritable:t.sessionWritable,serializedContext:i,sessionState:r.sessionState})).serializedContext),await resumeHookStep(e.replyTo,{kind:`agent-settled`,callId:n.result.callId},{ifPresent:!0}),{serializedContext:i,sessionState:r.sessionState}}case`agent-invoke`:{let r=await dispatchTaskAgentInvocationStep({ownerId:e.ownerId,replyTo:e.replyTo,request:n,serializedContext:t.serializedContext,sessionState:t.sessionState,taskId:e.taskId});switch(r.kind){case`dispatched`:return{serializedContext:(await emitSubagentEventStep({event:r.event,sessionWritable:t.sessionWritable,serializedContext:r.serializedContext??t.serializedContext,sessionState:r.sessionState})).serializedContext,sessionState:r.sessionState};case`failed`:return await resumeHookStep(e.replyTo,{kind:`runtime-action-result`,results:[r.result]}),{serializedContext:r.serializedContext??t.serializedContext,sessionState:r.sessionState};case`not-admitted`:return{serializedContext:t.serializedContext,sessionState:r.sessionState}}}}}export{applyTaskAgentRequest};
+import{emitSubagentEventStep}from"#execution/tools/subagent/emit-event-step.js";import{dispatchTaskAgentInvocationStep,settleTaskAgentInvocationStep}from"#execution/tools/subagent/invoke-step.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";async function applyTaskAgentRequest(e,t){let{request:n}=e;switch(n.kind){case`agent-settled`:{let r=await settleTaskAgentInvocationStep({ownerId:e.ownerId,result:n.result,serializedContext:t.serializedContext,sessionState:t.sessionState,taskId:e.taskId}),i=r.serializedContext,a=r.sessionState;if(r.completion!==void 0){let e=await emitSubagentEventStep({event:r.completion,sessionWritable:t.sessionWritable,serializedContext:i,sessionState:r.sessionState});i=e.serializedContext,a=e.sessionState}return await resumeHookStep(e.replyTo,{kind:`agent-settled`,callId:n.result.callId},{ifPresent:!0}),{serializedContext:i,sessionState:a}}case`agent-invoke`:{let r=await dispatchTaskAgentInvocationStep({ownerId:e.ownerId,replyTo:e.replyTo,request:n,serializedContext:t.serializedContext,sessionState:t.sessionState,taskId:e.taskId});switch(r.kind){case`dispatched`:return await emitSubagentEventStep({event:r.event,sessionWritable:t.sessionWritable,serializedContext:r.serializedContext??t.serializedContext,sessionState:r.sessionState});case`failed`:return await resumeHookStep(e.replyTo,{kind:`runtime-action-result`,results:[r.result]}),{serializedContext:r.serializedContext??t.serializedContext,sessionState:r.sessionState};case`not-admitted`:return{serializedContext:t.serializedContext,sessionState:r.sessionState}}}}}export{applyTaskAgentRequest};

package/dist/src/execution/tools/workflow/body.js

@@ -1 +1 @@
-import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{agent}from"#execution/tools/subagent/invoke-agent.js";import"#execution/tools/workflow/messages.js";import{readRegisteredWorkflow}from"#execution/workflow-registry.js";async function executeWorkflowBody(e,t){let n=createWorkflowBodyRef(e),r=createWorkflowBodyContext(e,t);attachWorkflowToolRunContext(r,{canRequestInput:e.canRequestInput,from:n,owner:e.owner});let i=0;try{let t=resolveWorkflowToolExecute(e)(e.executeInput??e.input,r),a;if(!isAsyncIterable(t))a=await t;else{let r=t[Symbol.asyncIterator](),o,s=await r.next();for(;s.done!==!0;){o=s.value;let t={from:n,update:s.value};await resumeHookStep(e.owner.inbox,{kind:`report`,...t}),i+=1,s=await r.next()}a=s.value??(e.execution===`blocking`?o:void 0)??null}return{outcome:{output:a,status:`completed`},reportCount:i}}catch(e){return t.aborted?{outcome:{reason:t.reason instanceof Error?t.reason.message:String(t.reason??``),status:`cancelled`},reportCount:i}:{outcome:{error:normalizeSerializableError(e),status:`failed`},reportCount:i}}}function createWorkflowBodyRef(e){return{callId:e.callId,execution:e.execution,input:e.input,runId:e.runId??getWorkflowMetadata().workflowRunId,sequence:e.session.turn.sequence,stepIndex:e.stepIndex,toolName:e.toolName,turnId:e.session.turn.id}}function resolveWorkflowToolExecute(e){let t=readRegisteredWorkflow(e.workflowId);if(typeof t!=`function`)throw Error(`Tool "${e.toolName}" is not registered as a workflow in this deployment (${e.workflowId}). The tool was renamed or removed after this run started.`);return t}function createWorkflowBodyContext(e,t){let unavailable=(t,n)=>{throw Error(`ctx.${t} is not available inside a workflow tool; ${n}. Tool "${e.toolName}" runs as a durable workflow body, which only replays deterministic code.`)},n={agent:((e,t)=>agent(n,e,t)),agents:Object.freeze(Object.fromEntries(Object.entries(e.agents??{}).map(([e,t])=>[e,Object.freeze({...t})]))),ask:e=>ask(n,e),abortSignal:t,callId:e.callId,getSandbox:()=>unavailable(`getSandbox()`,`the session sandbox belongs to the turn`),getSkill:()=>unavailable(`getSkill()`,`skills are read through the session sandbox`),getToken:()=>unavailable(`getToken()`,`pass ctx directly to a "use step" helper to resolve credentials`),requireAuth:()=>unavailable(`requireAuth()`,`pass ctx directly to a "use step" helper to request authorization`),session:e.session,toolName:e.toolName};return n}function isAsyncIterable(e){return typeof e==`object`&&!!e&&typeof e[Symbol.asyncIterator]==`function`}export{createWorkflowBodyRef,executeWorkflowBody};
+import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{normalizeSerializableError}from"#execution/workflow-errors.js";import{resumeHookStep}from"#execution/tools/workflow/resume-hook-step.js";import{ask,attachWorkflowToolRunContext}from"#execution/tools/workflow/ask.js";import{agent}from"#execution/tools/subagent/invoke-agent.js";import"#execution/tools/workflow/messages.js";import{readRegisteredWorkflow}from"#execution/workflow-registry.js";async function executeWorkflowBody(e,t){let n=createWorkflowBodyRef(e),r=createWorkflowBodyContext(e,t);attachWorkflowToolRunContext(r,{canRequestInput:e.canRequestInput,from:n,owner:e.owner});let i=0;try{let t=resolveWorkflowToolExecute(e)(e.executeInput??e.input,r),a;if(!isAsyncIterable(t))a=await t;else{let r=t[Symbol.asyncIterator](),o,s=await r.next();for(;s.done!==!0;){o=s.value;let t={from:n,update:s.value};await resumeHookStep(e.owner.inbox,{kind:`report`,...t}),i+=1,s=await r.next()}a=s.value??(e.execution===`blocking`?o:void 0)??null}return{outcome:{output:a,status:`completed`},reportCount:i}}catch(e){return t.aborted?{outcome:{reason:t.reason instanceof Error?t.reason.message:String(t.reason??``),status:`cancelled`},reportCount:i}:{outcome:{error:normalizeSerializableError(e),status:`failed`},reportCount:i}}}function createWorkflowBodyRef(e){return{callId:e.callId,execution:e.execution,input:e.input,runId:e.runId??getWorkflowMetadata().workflowRunId,sequence:e.session.turn.sequence,stepIndex:e.stepIndex,toolName:e.toolName,turnId:e.session.turn.id}}function resolveWorkflowToolExecute(e){let t=readRegisteredWorkflow(e.workflowId);if(typeof t!=`function`)throw Error(`Tool "${e.toolName}" is not registered as a workflow in this deployment (${e.workflowId}). The tool was renamed or removed after this run started.`);return t}function createWorkflowBodyContext(e,t){let unavailable=(t,n)=>{throw Error(`ctx.${t} is not available inside a workflow tool; ${n}. Tool "${e.toolName}" runs as a durable workflow body, which only replays deterministic code.`)},n={agent:((e,t)=>agent(n,e,t)),agents:Object.freeze(Object.fromEntries(Object.entries(e.agents??{}).map(([e,t])=>[e,Object.freeze({...t})]))),ask:e=>ask(n,e),abortSignal:t,callId:e.callId,getSandbox:()=>unavailable(`getSandbox()`,`the session sandbox belongs to the turn`),getToken:()=>unavailable(`getToken()`,`pass ctx directly to a "use step" helper to resolve credentials`),requireAuth:()=>unavailable(`requireAuth()`,`pass ctx directly to a "use step" helper to request authorization`),session:e.session,toolName:e.toolName};return n}function isAsyncIterable(e){return typeof e==`object`&&!!e&&typeof e[Symbol.asyncIterator]==`function`}export{createWorkflowBodyRef,executeWorkflowBody};

package/dist/src/extensions/code/extension/extension.d.ts

@@ -0,0 +1,57 @@
+import type { SandboxSession } from "eve/sandbox";
+import { z } from "zod";
+export type CredentialPolicyBroker = (sandbox: SandboxSession, rules: Record<string, Record<string, string>>) => Promise<void>;
+export interface GitHubLeaseRule {
+    readonly match?: {
+        readonly headers?: readonly {
+            readonly key?: {
+                readonly exact: string;
+            };
+            readonly value?: {
+                readonly exact?: string;
+                readonly regex?: string;
+            };
+        }[];
+    };
+    readonly transform: readonly {
+        readonly headers: Readonly<Record<string, string>>;
+    }[];
+}
+export type GitHubLeaseBroker = (sandbox: SandboxSession, rules: Readonly<Record<string, readonly GitHubLeaseRule[]>> | null) => Promise<void>;
+declare const _default: import("eve/extension").ExtensionHandle<z.ZodObject<{
+    github: z.ZodOptional<z.ZodObject<{
+        connector: z.ZodString;
+        org: z.ZodString;
+        broker: z.ZodCustom<GitHubLeaseBroker, GitHubLeaseBroker>;
+    }, z.core.$strip>>;
+    vercel: z.ZodOptional<z.ZodObject<{
+        connector: z.ZodString;
+        delivery: z.ZodDefault<z.ZodEnum<{
+            command: "command";
+            firewall: "firewall";
+        }>>;
+    }, z.core.$strip>>;
+    broker: z.ZodOptional<z.ZodCustom<CredentialPolicyBroker, CredentialPolicyBroker>>;
+    worker: z.ZodOptional<z.ZodObject<{
+        model: z.ZodString;
+        reasoning: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            "provider-default": "provider-default";
+            xhigh: "xhigh";
+        }>;
+        openaiReasoningEffort: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+            xhigh: "xhigh";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export default _default;

package/dist/src/extensions/code/extension/extension.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{defineExtension}from"eve/extension";const fn=()=>z.custom(e=>typeof e==`function`),delivery=z.enum([`firewall`,`command`]).default(`firewall`),reasoning=z.enum([`provider-default`,`none`,`minimal`,`low`,`medium`,`high`,`xhigh`]),openaiReasoningEffort=z.enum([`none`,`minimal`,`low`,`medium`,`high`,`xhigh`,`max`]);var extension_default=defineExtension({config:z.object({github:z.object({connector:z.string().min(1),org:z.string().min(1),broker:fn()}).optional(),vercel:z.object({connector:z.string().min(1),delivery}).optional(),broker:fn().optional(),worker:z.object({model:z.string().min(1),reasoning,openaiReasoningEffort:openaiReasoningEffort.optional()}).optional()})});export{extension_default as default};

package/dist/src/extensions/code/extension/hooks/authenticate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eve/hooks").HookDefinition<"turn.started">;
+export default _default;

package/dist/src/extensions/code/extension/hooks/authenticate.js

@@ -0,0 +1 @@
+import extension_default from"../extension.js";import{authenticateTurn}from"../lib/connect-authentication.js";import{defineHook}from"eve/hooks";var authenticate_default=defineHook({events:{async"turn.started"(e,t){await authenticateTurn(extension_default.config,()=>t.getSandbox())}}});export{authenticate_default as default};

package/dist/src/extensions/code/extension/instructions.md

@@ -0,0 +1,87 @@
+# Principles
+
+This is an eve extension that enables coding capabilities.
+
+You are extremely autonomous. Fully leverage your capabilities to get the job done.
+
+Simplicity prevails almost always. Simple language: clear, to the point, least amount of new concepts to the reader. Same for implementation. Noise-free.
+
+Prefer action over ceremony. A list, status ritual, or extra plan is only worth a turn when losing the thread would cost more than writing it.
+
+# Communication guidelines
+
+Communication happens on an instant messaging app. The reader did not see your tool calls. Lead with the answer. The final message stands alone. Be brief.
+
+If the next cut depends on an unstated constraint, ask one question. Otherwise decide and proceed.
+
+# Minds
+
+Hold the other people in the work. The requester named an outcome, not a procedure. The reader did not see your tools. A future maintainer pays for every new concept. A worker is another mind with one slice and a chosen lifetime: own that slice end to end, or answer once. You are the arbiter of writes, cross-slice decisions, and disagreement. Evidence does not care what you hoped.
+
+# Execution
+
+Match action to the request. An answer, explanation, review, status report, diagnosis, or plan authorizes relevant read-only inspection and a reply, not workspace edits, publication, cross-posts, or other external writes. Diagnose and explain causes without implementing a fix unless asked. Build or change the workspace only when the requester asks for implementation. Publish or perform another external write only when the requester explicitly asks for it or names a delivery outcome that requires it. Persistence never expands authority.
+
+Break the work down. When multiple read-only calls are independently useful, emit them in the same response. eve executes calls from one response concurrently. Do not wait for one result unless it determines whether the next call is valid. Serialize work that depends on earlier results.
+
+Work streams that can run apart should. Identify independent slices a worker can own and start independent calls together. Give each one a self-contained question with repositories, paths or refs, constraints, and expected output. The tree is already shared, so do not copy full source. Choose the lifetime: keep the collaborator and send follow-ups as deltas when it should own the slice end to end, or spawn ephemerally and ask once. Isolated context is the point; do not make delegation lossy. Writes stay here so workers never compete to mutate the shared workspace.
+
+Make extensive use of parallelism to speed things up.
+
+Cost-sensitive: do not spend tokens on unbounded work like tracking; ask permission first. For bounded tasks, do not call `todo`; begin the work directly instead of spending a model turn maintaining a plan. Use `todo` only for long-running or open-ended work where losing the thread would cost more than writing it.
+
+## Issues and bugs
+
+Required steps, in order:
+
+1. Clear, precise and concrete understanding of the issue.
+   - Ideal: each and every evidence of the issue possible.
+   - Why this is happening only now? What has changed?
+2. Precise and unambiguous reproduction of stated issue.
+3. Hypothesis derived from actual, detailed and sound reasoning chain.
+
+## Analysis and design
+
+1. What are the fundamental constraints?
+   - Any noteworthy data flows? Which entry points trigger relevant codepaths?
+   - What is the history of change of this area of the codebase?
+2. What is the simplest cut to be made to achieve desired state?
+
+# Repository work
+
+GitHub credentials are not available to ordinary `bash`. Use the `gh` tool for every authenticated GitHub operation. The full `gh` CLI surface is available. Declare exactly one repository in the configured organization with write-capable access. Authenticated commands run without an approval prompt; describe the intended GitHub-side result accurately in `description`. Connect mints the real token for only the declared repository. The sandbox process receives only a placeholder `GH_TOKEN`, and the firewall exchanges it on matching GitHub requests. GitHub rejects access outside the token's server-side repository scope. Never put credentials in URLs or commands. If access is denied, report it plainly and stop.
+
+Pass commands as simple argv with ordinary quoting. Do not use environment assignments, pipes, redirects, substitutions, or other shell syntax. Commands without an explicit repository may use normal `gh` context, but their token remains scoped to the declared repository. An explicit `-R`, `--repo`, `--repo=`, or repository argument to `gh repo clone`, `view`, or `fork` must match the declaration.
+
+Determine the repositories needed to complete the task through source discovery and investigation, even when the requester does not name them. Do not ask the requester to enumerate repositories that can be discovered, and never default to the current agent's repository. The agent may select additional repositories as the work reveals them. Each authenticated command declares exactly one target repository and mints a credential lease for that repository at the moment it is needed, so cross-repository work uses separate scoped commands and leases.
+
+Clone with `gh repo clone owner/name`. Use authenticated `git fetch`, `git pull`, `git push`, and `git ls-remote` through the `gh` tool too. Local `git status`, `diff`, `add`, `commit`, and `rebase` remain ordinary `bash` commands because they need no GitHub credential. Immediately after entering a checkout and before planning or editing, read its root `AGENTS.md`; use root `CLAUDE.md` only when `AGENTS.md` is absent. Before touching any path, read the nearest nested `AGENTS.md`, falling back to `CLAUDE.md` only when that directory has no `AGENTS.md`.
+
+Do not rebase before work by default. Rebase only when the requester explicitly asks for it or when an explicitly requested publication or delivery outcome requires a current base. Inspect the worktree first and preserve pre-existing changes.
+
+Use GitHub CLI commands through the `gh` tool for issues, pull requests, reviews, Actions, CI, authentication status, configuration, aliases, extensions, and API requests. Common commands include `gh pr create --draft`, `gh pr checks`, `gh run rerun --failed`, and `gh pr review`, but they are not restrictions.
+
+Repositories that require verified signatures reject ordinary sandbox commits. Stage the intended changes explicitly, run `gh-signed-commit --repo owner/name --branch <branch> -m <headline>` through the `gh` tool, then create the draft pull request through the same tool.
+
+Use apply_patch for authored edits. Formatters and generators may write their own output. Never rewrite files through shell or Python when a focused patch is sufficient. Write small hunks against current file contents. If a hunk misses, re-read that file and rewrite only the failed hunk.
+
+Use `grep` for sandbox content search. Start with `files_with_matches` and a narrow path or glob.
+
+Assume pre-existing modifications belong to the requester. Preserve unrelated changes and inspect overlap before editing. Never discard work with `git reset --hard`, `git checkout --`, or an equivalent destructive command unless explicitly authorized.
+
+Make the smallest coherent change. Run focused validation first, then broader checks in proportion to the blast radius. Treat failures as evidence.
+
+Be mindful of loading large files into your context window.
+
+Load the pr skill before publishing. Create one pull request per request unless the requester asks otherwise.
+
+## Destructive actions
+
+Before deleting, overwriting, or making data difficult to recover, confirm scope and resolve the exact target with read-only checks. Never use a home directory, repository root, workspace root, unresolved variable, broad glob, or command substitution as a recursive destructive target. Prefer recoverable operations and stop when target or authority is unclear.
+
+# Safety and writing
+
+- Never print credentials, tokens, or `.env` contents
+- Never expose company private references (Slack links, channel names, product or agent names, requester names or emails) in public environments (e.g. a public GitHub pull request)
+- Use no em dashes in human-facing text
+- Default to silence when the right action is no action

package/dist/src/extensions/code/extension/lib/command-failure.d.ts

@@ -0,0 +1,7 @@
+type CommandOutput = {
+    readonly stderr: string;
+    readonly stdout: string;
+};
+/** Preserve useful output from failed sandbox commands without flooding build logs. */
+export declare function commandFailureDetail(result: CommandOutput): string;
+export {};

package/dist/src/extensions/code/extension/lib/command-failure.js

@@ -0,0 +1,2 @@
+const MAX_STREAM_CHARS=8e3;function boundedStream(e,t){let n=t.trim();if(n)return n.length<=MAX_STREAM_CHARS?`${e}:\n${n}`:`${e} (last ${MAX_STREAM_CHARS} characters):\n${n.slice(-8e3)}`}function commandFailureDetail(e){return[boundedStream(`stdout`,e.stdout),boundedStream(`stderr`,e.stderr)].filter(e=>e!==void 0).join(`
+`)||`no command output`}export{commandFailureDetail};