harnery 0.23.0 → 0.25.0

package/src/core/workflow/spawn-cursor.ts

@@ -10,6 +10,9 @@
  *   session_id, …}`).
  * - `--trust` is required: headless runs refuse untrusted workspaces (exit 1,
  *   "Workspace Trust Required") — see the argv comment below.
+ * - `--force` is required: print mode has no channel for an operator to approve
+ *   shell commands, so Smart Auto can leave a child able to patch files but
+ *   unable to test or commit them.
  * - Envelope drift guard: when stdout doesn't parse as JSON but the process
  *   exited 0, the raw stdout is returned as the reply text.
  * - No per-run cost surface → undefined. No max-turns equivalent → `maxTurns`
@@ -51,10 +54,11 @@ export function parseCursorOutput(stdout: string): {
 export function buildCursorInvocation(req: SpawnRequest): HarnessInvocation {
   validateHarnessEffort("cursor", req.effort);
   // --trust: headless cursor-agent refuses untrusted workspaces (exit 1,
-  // "Workspace Trust Required"). Workflow children run in the engine's cwd
-  // deliberately and may edit files — the same posture as the codex adapter's
-  // `--sandbox workspace-write` — so trusting that directory is implied.
-  const argv = ["cursor-agent", "-p", req.prompt, "--output-format", "json", "--trust"];
+  // "Workspace Trust Required"). --force: a print-mode child has no interactive
+  // approval channel, so host-authorized workflow dispatch must let it run
+  // commands. Neither flag maps host policy into child tools; that capability
+  // remains explicitly unsupported.
+  const argv = ["cursor-agent", "-p", req.prompt, "--output-format", "json", "--trust", "--force"];
   if (req.model) argv.push("--model", req.model);
   return { argv };
 }

package/src/core/workflow/types.ts

@@ -126,6 +126,14 @@ export interface WorkflowRepoEvidence {
   };
 }
 
+/** Bounded pointer to the live attestation backing a harness's claims
+ * (ADR 0038). Structural facts only: no prompt text, no host paths. */
+export interface HarnessAttestationCitation {
+  binary_version: string;
+  observed_at: string;
+  record_digest: string;
+}
+
 export interface HarnessEvidenceCoverage {
   harness: HarnessName;
   tool_evidence: {
@@ -137,6 +145,10 @@ export interface HarnessEvidenceCoverage {
     session_ids: number;
     costs: number;
   };
+  /** What backs this harness's capability claims (ADR 0038). Absent when the
+   * host recorded no live attestation, which is the common case and is not by
+   * itself a proof unknown. */
+  attestation?: HarnessAttestationCitation;
 }
 
 export interface WorkflowProofUnknown {
@@ -429,6 +441,9 @@ export interface EngineOpts {
   /** Capability claims used to state whether adapter-native tool evidence was
    * available. Missing claims remain unknown. */
   harnessEvidence?: Readonly<Record<HarnessName, HarnessEvidenceCapability | undefined>>;
+  /** Live attestations backing each harness's claims (ADR 0038). Read once by
+   * the host and injected, so the engine performs no capability lookups. */
+  harnessAttestations?: Readonly<Record<HarnessName, HarnessAttestationCitation | undefined>>;
   /** Immutable host policy. Workflow scripts and model prompts cannot replace it. */
   policy?: PolicySpec | NormalizedPolicy;
   /** Host callback for ASK. Missing, invalid, throwing, or timed-out resolution denies. */

package/src/core/workflow/workspaces/index.ts

@@ -15,7 +15,11 @@ export {
   renderWorkflowWorkspaceStatus,
 } from "./inspect.ts";
 export type { ApplyIntegrationInput, PrepareIntegrationInput } from "./integration.ts";
-export { applyIntegration, prepareIntegration } from "./integration.ts";
+export {
+  applyIntegration,
+  IntegrationPrepareParkedError,
+  prepareIntegration,
+} from "./integration.ts";
 export type {
   WorkspaceLifecycleProjection,
   WorkspaceLifecycleProjectionInput,

package/src/core/workflow/workspaces/integration.ts

@@ -64,6 +64,22 @@ export interface ApplyIntegrationInput {
   plan?: IntegrationPlan;
 }
 
+/** Host-policy ASK still pending during integration prepare. Carries the exact
+ * durable IDs an operator needs to approve and resume the same plan. */
+export class IntegrationPrepareParkedError extends Error {
+  readonly runId: string;
+  readonly planId: string;
+  readonly approvalId: string;
+
+  constructor(runId: string, planId: string, approvalId: string) {
+    super(`integration preparation parked: run ${runId}, plan ${planId}, approval ${approvalId}`);
+    this.name = "IntegrationPrepareParkedError";
+    this.runId = runId;
+    this.planId = planId;
+    this.approvalId = approvalId;
+  }
+}
+
 export async function prepareIntegration(input: PrepareIntegrationInput): Promise<IntegrationPlan> {
   const evidence = await readAndValidateEvidence(input.coordRoot, input.runId, input.provider);
   const targetRoot = resolve(input.targetRoot ?? requiredIntegrationRoot(evidence.binding));
@@ -662,7 +678,7 @@ function authorizePlan(input: PrepareIntegrationInput, plan: IntegrationPlan): v
     });
     approvalId = created.approval.request.id;
     if (created.approval.status === "pending") {
-      throw new Error(`integration approval ${approvalId} is pending`);
+      throw new IntegrationPrepareParkedError(input.runId, plan.plan_id, approvalId);
     }
     if (created.approval.status !== "approved" || !created.approval.decision) {
       throw new Error(`integration approval ${approvalId} was denied`);

package/src/core/workflow/workspaces/leases.ts

@@ -134,8 +134,14 @@ export function acquireNoClobberLease(input: AcquireNoClobberLeaseInput): NoClob
     input.onRecoveryStep?.("claim_created");
 
     const pinPath = join(recoveryPath, "stale-pin");
-    linkSync(currentPath, pinPath);
-    assertSameInodeAndBytes(currentPath, pinPath, observed.bytes);
+    try {
+      linkSync(currentPath, pinPath);
+      assertSameInodeAndBytes(currentPath, pinPath, observed.bytes);
+    } catch {
+      abortUnchangedRecoveryClaim(leaseDir, recoveryPath, pinPath, owner);
+      recoveryClaimed = false;
+      throw new Error(`lease ${input.scope} recovery raced with another contender`);
+    }
     fsyncDirectory(recoveryPath);
     input.onRecoveryStep?.("stale_pinned");
 
@@ -292,6 +298,22 @@ function reclaimAbandonedRecovery(
   fsyncDirectory(leaseDir);
 }
 
+function abortUnchangedRecoveryClaim(
+  leaseDir: string,
+  recoveryPath: string,
+  pinPath: string,
+  claimant: NoClobberLeaseOwner,
+): void {
+  const claim = readRecoveryClaim(recoveryPath);
+  if (claim.claimant.owner_id !== claimant.owner_id) {
+    throw new Error(`lease ${claimant.scope} recovery ownership changed`);
+  }
+  safeUnlink(pinPath);
+  unlinkSync(join(recoveryPath, "claim.json"));
+  rmdirSync(recoveryPath);
+  fsyncDirectory(leaseDir);
+}
+
 function readRecoveryClaim(recoveryPath: string): RecoveryClaim {
   const path = join(recoveryPath, "claim.json");
   const size = lstatSync(path).size;