@engineeros/connector 0.6.1 → 0.8.0

package/README.md

@@ -33,6 +33,8 @@ From **Project steering -> Workspace**, choose **Assess with Codex** to run a re
 
 After onboarding, every project prompt is routed to this connection. Copilot, shaping, planning, architecture, and experience generation use the Codex CLI subscription and connected workspace context. Prompt runs are read-only; only an explicitly registered Goal Run receives workspace-write access. If the connector is offline, EngineerOS asks the user to reconnect instead of silently switching models.
 
+Project prompts use resumable, purpose-specific coding-agent sessions. The connector keeps the external session identifiers in its local configuration, so Copilot and artifact conversations survive connector restarts. Changing the purpose, model, or reasoning effort starts a separate session. Goal implementation and verification remain isolated runs.
+
 An empty or document-only folder establishes a greenfield baseline. A code-bearing folder is assessed as brownfield. Use **Rescan** in Steering after the local workspace changes.
 
 ## Reconnect
@@ -49,6 +51,16 @@ Keep the connector online to receive Goals assigned from EngineerOS. Each Goal r
 
 Requirements: Node.js 22 or newer, Git, and an authenticated Codex CLI (`codex login`).
 
+## Execution profiles
+
+EngineerOS can set a workspace default model and reasoning effort, then override either value for an individual Goal. The same workspace default is used for assessments, Copilot, and generated artifacts. The connector passes the resolved values to Codex CLI and reports unsupported profiles instead of silently ignoring them.
+
+Codex connectors advertise `gpt-5.6-sol` and `gpt-5.6-terra` by default. Override the choices shown in EngineerOS before starting the connector:
+
+```sh
+ENGINEEROS_AGENT_MODELS="model-a,model-b" npx @engineeros/connector start --workspace .
+```
+
 ## Codex CLI compatibility
 
 The connector prints the exact Codex CLI version it will use before connecting. If the

package/bin/engineeros-connector.mjs

@@ -23,6 +23,7 @@ import {
   describeWebSocketError,
   startConnectionWatchdog,
 } from "../src/connection.mjs";
+import { advertisedCapabilities } from "../src/capabilities.mjs";
 
 const { command, positional, flags } = parseArgs(process.argv.slice(2));
 
@@ -63,13 +64,7 @@ if (command === "pair") {
     type: "pair",
     pairing_code: pairingCode,
     name: config.name,
-    capabilities: {
-      agent_protocols: flags["agent-command"] ? ["acp"] : ["codex"],
-      coding_agent: true,
-      codex_cli: !flags["agent-command"],
-      platform: process.platform,
-      workspace_name: path.basename(config.workspace),
-    },
+    capabilities: {},
   };
 } else if (command === "start") {
   config = await loadConfig(flags.workspace || process.cwd());
@@ -93,10 +88,8 @@ try {
   fail(error instanceof Error ? error.message : String(error));
 }
 console.log(`Using ${codingAgent.name} through ${codingAgent.protocol} (${codingAgent.version}).`);
-if (firstMessage.type === "pair") {
-  firstMessage.capabilities.agent_name = codingAgent.name;
-  firstMessage.capabilities.agent_version = codingAgent.version;
-}
+const capabilities = advertisedCapabilities(config, codingAgent);
+firstMessage.capabilities = capabilities;
 
 let stopped = false;
 let active = null;
@@ -153,6 +146,7 @@ async function connect() {
         type: "authenticate",
         connector_id: config.connector_id,
         token: config.token,
+        capabilities,
       };
       console.log(`Paired. Connector ${config.connector_id} is online.`);
       reconnectDelay = 1_000;
@@ -381,6 +375,11 @@ async function executePrompt(assignment) {
         if (active?.runId === promptId) active.child = child;
       },
     });
+    config = {
+      ...config,
+      sessions: { ...(config.sessions || {}), [result.sessionKey]: result.sessionId },
+    };
+    await saveConfig(config);
     if (active?.cancelled || socket.readyState !== WebSocket.OPEN) return;
     socket.send(
       JSON.stringify({
@@ -388,6 +387,7 @@ async function executePrompt(assignment) {
         prompt_id: promptId,
         content: result.content,
         model: result.model,
+        session_id: result.sessionId,
       }),
     );
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@engineeros/connector",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Connect a local coding agent to EngineerOS, using ACP when supported.",
   "private": false,
   "type": "module",
@@ -16,7 +16,7 @@
   "scripts": {
     "start": "node ./bin/engineeros-connector.mjs",
     "test": "node --test --test-concurrency=1",
-    "type-check": "node --check ./bin/engineeros-connector.mjs && node --check ./src/connection.mjs && node --check ./src/runner.mjs"
+    "type-check": "node --check ./bin/engineeros-connector.mjs && node --check ./src/capabilities.mjs && node --check ./src/connection.mjs && node --check ./src/runner.mjs"
   },
   "engines": {
     "node": ">=22"

package/src/acp-client.mjs

@@ -68,7 +68,11 @@ export function launchAcpAgent(workspace, prompt, config, callbacks = {}) {
             if (message.stopReason === "error") {
               throw new Error("The ACP agent ended the task with an error.");
             }
-            return { finalMessage, model: "acp-agent" };
+            return {
+              finalMessage,
+              model: "acp-agent",
+              sessionId: session.sessionId,
+            };
           }
           const update = message.update;
           if (

package/src/capabilities.mjs

@@ -0,0 +1,27 @@
+import path from "node:path";
+
+export function advertisedCapabilities(config, codingAgent) {
+  const configuredModels = String(
+    process.env.ENGINEEROS_AGENT_MODELS || "gpt-5.6-sol,gpt-5.6-terra",
+  )
+    .split(",")
+    .map((model) => model.trim())
+    .filter(Boolean);
+  return {
+    agent_protocols: [codingAgent.protocol],
+    coding_agent: true,
+    codex_cli: codingAgent.protocol === "codex",
+    platform: process.platform,
+    workspace_name: path.basename(config.workspace),
+    agent_name: codingAgent.name,
+    agent_version: codingAgent.version,
+    execution_profiles: {
+      model_selection: codingAgent.protocol === "codex",
+      models: codingAgent.protocol === "codex" ? configuredModels : [],
+      reasoning_efforts:
+        codingAgent.protocol === "codex"
+          ? ["low", "medium", "high", "xhigh"]
+          : [],
+    },
+  };
+}

package/src/runner.mjs

@@ -101,6 +101,7 @@ export async function executeAssignment(assignment, config, callbacks) {
     execution.sandboxMode,
     config,
     callbacks,
+    execution.profile,
   );
   callbacks.onProcess?.(controller.child);
   await controller.completed;
@@ -118,6 +119,7 @@ export async function executeAssignment(assignment, config, callbacks) {
     "read-only",
     config,
     callbacks,
+    execution.profile,
   );
   callbacks.onProcess?.(verifier.child);
   const verification = await verifier.completed;
@@ -138,12 +140,19 @@ export async function executeAssignment(assignment, config, callbacks) {
   };
 }
 
-export async function applyAcceptedChange(workspace, baseRevision, headRevision) {
+export async function applyAcceptedChange(
+  workspace,
+  baseRevision,
+  headRevision,
+) {
   const current = await run("git", ["rev-parse", "HEAD"], workspace, {
     allowFailure: true,
   });
   if (current.code !== 0) {
-    return { applied: false, reason: "The connected workspace is not a Git repository." };
+    return {
+      applied: false,
+      reason: "The connected workspace is not a Git repository.",
+    };
   }
   const currentHead = current.stdout.trim();
   const alreadyApplied = await run(
@@ -152,7 +161,8 @@ export async function applyAcceptedChange(workspace, baseRevision, headRevision)
     workspace,
     { allowFailure: true },
   );
-  if (alreadyApplied.code === 0) return { applied: true, revision: currentHead };
+  if (alreadyApplied.code === 0)
+    return { applied: true, revision: currentHead };
   const status = await run("git", ["status", "--porcelain"], workspace);
   if (status.stdout.trim()) {
     return {
@@ -242,14 +252,22 @@ Return structured Markdown only, with exactly one section per Proof:
 Do not claim a Proof passed unless you observed it directly.`;
 }
 
-export function parseVerificationReport(report, proofChecks, connectorId, runId) {
-  if (!report?.trim()) throw new Error("Codex returned no connected verification report.");
+export function parseVerificationReport(
+  report,
+  proofChecks,
+  connectorId,
+  runId,
+) {
+  if (!report?.trim())
+    throw new Error("Codex returned no connected verification report.");
   return (proofChecks ?? []).map((_, index) => {
     const start = new RegExp(`^## Proof ${index + 1}\\s*$`, "im").exec(report);
     const tail = start ? report.slice(start.index + start[0].length) : "";
     const section = tail.split(/^## Proof \d+\s*$/im)[0] ?? "";
-    const status = /^- Status:\s*(passed|failed)\s*$/im.exec(section)?.[1] ?? "failed";
-    const exitValue = /^- Exit code:\s*(\d+|none)\s*$/im.exec(section)?.[1] ?? "none";
+    const status =
+      /^- Status:\s*(passed|failed)\s*$/im.exec(section)?.[1] ?? "failed";
+    const exitValue =
+      /^- Exit code:\s*(\d+|none)\s*$/im.exec(section)?.[1] ?? "none";
     const evidence = /^- Evidence:\s*(.+)$/im.exec(section)?.[1]?.trim();
     return {
       proof_index: index,
@@ -257,7 +275,9 @@ export function parseVerificationReport(report, proofChecks, connectorId, runId)
       verifier_type: "agent_reported",
       verifier_identity: "Connected Codex CLI verifier",
       locator: `connector:${connectorId}/run:${runId}#proof-${index + 1}`,
-      output_excerpt: evidence || "The connected verifier did not provide evidence for this Proof.",
+      output_excerpt:
+        evidence ||
+        "The connected verifier did not provide evidence for this Proof.",
       exit_code: exitValue === "none" ? null : Number(exitValue),
     };
   });
@@ -307,6 +327,7 @@ export async function executeWorkspaceAssessment(
     execution.sandboxMode,
     config,
     callbacks,
+    execution.profile,
   );
   callbacks.onProcess?.(controller.child);
   const completed = await controller.completed;
@@ -335,7 +356,11 @@ export async function executeWorkspaceAssessment(
   };
 }
 
-export async function workspaceChangeImpact(workspace, baseRevision, targetRevision) {
+export async function workspaceChangeImpact(
+  workspace,
+  baseRevision,
+  targetRevision,
+) {
   if (!baseRevision || !targetRevision) {
     throw new Error(
       "Incremental assessment requires both the previously assessed and current Git commits. Run a full assessment instead.",
@@ -361,7 +386,15 @@ export async function workspaceChangeImpact(workspace, baseRevision, targetRevis
   );
   const workingFiles = await run(
     "git",
-    ["-c", "core.quotepath=false", "ls-files", "--others", "--modified", "--deleted", "--exclude-standard"],
+    [
+      "-c",
+      "core.quotepath=false",
+      "ls-files",
+      "--others",
+      "--modified",
+      "--deleted",
+      "--exclude-standard",
+    ],
     workspace,
     { allowFailure: true },
   );
@@ -374,10 +407,12 @@ export async function workspaceChangeImpact(workspace, baseRevision, targetRevis
     workspace,
     { allowFailure: true },
   );
-  const allChangedFiles = [...new Set([
-    ...pathLines(committedFiles.stdout),
-    ...pathLines(workingFiles.stdout),
-  ])];
+  const allChangedFiles = [
+    ...new Set([
+      ...pathLines(committedFiles.stdout),
+      ...pathLines(workingFiles.stdout),
+    ]),
+  ];
   if (allChangedFiles.length > 500) {
     throw new Error(
       `This change affects ${allChangedFiles.length} paths, above the 500-path incremental limit. Run a full reassessment instead.`,
@@ -400,10 +435,24 @@ export async function workspaceChangeImpact(workspace, baseRevision, targetRevis
     "```",
   ];
   if (status.stdout.trim()) {
-    lines.push("", "### Working tree", "", "```text", boundedText(status.stdout, 6_000), "```");
+    lines.push(
+      "",
+      "### Working tree",
+      "",
+      "```text",
+      boundedText(status.stdout, 6_000),
+      "```",
+    );
   }
   if (stat.stdout.trim()) {
-    lines.push("", "### Diff summary", "", "```text", boundedText(stat.stdout, 6_000), "```");
+    lines.push(
+      "",
+      "### Diff summary",
+      "",
+      "```text",
+      boundedText(stat.stdout, 6_000),
+      "```",
+    );
   }
   return { changedFiles, markdown: lines.join("\n") };
 }
@@ -418,17 +467,22 @@ function pathLines(output) {
 
 function boundedText(value, maximum) {
   const text = String(value || "").trim();
-  return text.length <= maximum ? text : `${text.slice(0, maximum)}\n... truncated by EngineerOS`;
+  return text.length <= maximum
+    ? text
+    : `${text.slice(0, maximum)}\n... truncated by EngineerOS`;
 }
 
 export async function executeConnectedPrompt(assignment, config, callbacks) {
   const execution = connectorExecution(assignment);
+  const previousSessionId = config.sessions?.[execution.sessionKey];
   const controller = launchAgentProcess(
     config.workspace,
     execution.prompt,
     execution.sandboxMode,
     config,
     callbacks,
+    execution.profile,
+    previousSessionId,
   );
   callbacks.onProcess?.(controller.child);
   const completed = await controller.completed;
@@ -436,13 +490,20 @@ export async function executeConnectedPrompt(assignment, config, callbacks) {
   if (!content) {
     throw new Error("Codex completed without returning a response.");
   }
-  return { content, model: completed.model ?? config.agent_protocol ?? "coding-agent" };
+  return {
+    content,
+    model: completed.model ?? config.agent_protocol ?? "coding-agent",
+    sessionId: completed.sessionId,
+    sessionKey: execution.sessionKey,
+  };
 }
 
 export async function inspectCodingAgent(config, workspace = process.cwd()) {
   if (config.agent_protocol === "acp") {
     if (!config.agent_command) {
-      throw new Error("ACP requires --agent-command when pairing the connector.");
+      throw new Error(
+        "ACP requires --agent-command when pairing the connector.",
+      );
     }
     return {
       protocol: "acp",
@@ -540,7 +601,30 @@ export function connectorExecution(assignment) {
   if (!new Set(["read-only", "workspace-write"]).has(sandboxMode)) {
     throw new Error("EngineerOS assignment has an unsupported sandbox_mode.");
   }
-  return { prompt, sandboxMode };
+  const rawProfile = assignment?.execution_profile ?? {};
+  const model =
+    typeof rawProfile.model === "string" ? rawProfile.model.trim() : "";
+  const reasoningEffort = rawProfile.reasoning_effort;
+  if (
+    reasoningEffort &&
+    !new Set(["low", "medium", "high", "xhigh"]).has(reasoningEffort)
+  ) {
+    throw new Error(
+      "EngineerOS assignment has an unsupported reasoning effort.",
+    );
+  }
+  return {
+    prompt,
+    sandboxMode,
+    sessionKey:
+      typeof assignment.session_key === "string" && assignment.session_key.trim()
+        ? assignment.session_key.trim()
+        : `project-${String(assignment.purpose || "general").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 80)}`,
+    profile: {
+      ...(model ? { model } : {}),
+      ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
+    },
+  };
 }
 
 export async function stopProcess(child) {
@@ -664,11 +748,28 @@ async function prepareRunWorkspace(workspace, runId, baseRevision) {
   return target;
 }
 
-function launchCodexProcess(workspace, prompt, sandbox, callbacks) {
+function launchCodexProcess(
+  workspace,
+  prompt,
+  sandbox,
+  callbacks,
+  profile = {},
+  previousSessionId,
+) {
   const command =
     process.env.CODEX_BIN ||
     (process.platform === "win32" ? "codex.cmd" : "codex");
-  const args = ["exec", "--json", "--sandbox", sandbox, "-C", workspace, "-"];
+  const profileArgs = [];
+  if (profile.model) profileArgs.push("--model", profile.model);
+  if (profile.reasoning_effort) {
+    profileArgs.push(
+      "--config",
+      `model_reasoning_effort=${JSON.stringify(profile.reasoning_effort)}`,
+    );
+  }
+  const args = previousSessionId
+    ? ["exec", "resume", "--json", ...profileArgs, previousSessionId, "-"]
+    : ["exec", "--json", "--sandbox", sandbox, "-C", workspace, ...profileArgs, "-"];
   const child = spawn(command, args, {
     cwd: workspace,
     env: process.env,
@@ -679,6 +780,7 @@ function launchCodexProcess(workspace, prompt, sandbox, callbacks) {
   let output = "";
   let buffer = "";
   let finalMessage = "";
+  let sessionId = previousSessionId || "";
   child.stdout.setEncoding("utf8");
   child.stdout.on("data", (chunk) => {
     output += chunk;
@@ -689,6 +791,9 @@ function launchCodexProcess(workspace, prompt, sandbox, callbacks) {
       if (!line.trim()) continue;
       try {
         const event = JSON.parse(line);
+        if (event.type === "thread.started" && typeof event.thread_id === "string") {
+          sessionId = event.thread_id;
+        }
         if (
           event.type === "item.completed" &&
           event.item?.type === "agent_message" &&
@@ -716,18 +821,32 @@ function launchCodexProcess(workspace, prompt, sandbox, callbacks) {
   const completed = new Promise((resolve, reject) => {
     child.once("error", reject);
     child.once("close", (code) => {
-      if (code === 0) resolve({ output: output.slice(-20_000), finalMessage });
+      if (code === 0 && sessionId) resolve({ output: output.slice(-20_000), finalMessage, sessionId });
+      else if (code === 0) reject(new Error("Codex completed without announcing a resumable session id."));
       else reject(new Error(codexFailureMessage(output, code)));
     });
   });
   return { child, completed };
 }
 
-function launchAgentProcess(workspace, prompt, sandbox, config, callbacks) {
+function launchAgentProcess(
+  workspace,
+  prompt,
+  sandbox,
+  config,
+  callbacks,
+  profile = {},
+  previousSessionId,
+) {
   if (config.agent_protocol === "acp") {
+    if (profile.model || profile.reasoning_effort) {
+      throw new Error(
+        "This ACP coding agent does not advertise execution-profile support.",
+      );
+    }
     return launchAcpAgent(workspace, prompt, config, callbacks);
   }
-  return launchCodexProcess(workspace, prompt, sandbox, callbacks);
+  return launchCodexProcess(workspace, prompt, sandbox, callbacks, profile, previousSessionId);
 }
 
 function runCodexCommand(command, args, cwd) {
@@ -761,9 +880,10 @@ async function changedFilePaths(workspace) {
     workspace,
   );
   return [
-    ...new Set(
-      [...gitPathList(tracked.stdout), ...gitPathList(untracked.stdout)],
-    ),
+    ...new Set([
+      ...gitPathList(tracked.stdout),
+      ...gitPathList(untracked.stdout),
+    ]),
   ].sort();
 }