openplanr 3.3.0 → 3.4.0

package/lib/host-packages/claude/openplanr/skills/delegate/scripts/integrate.mjs

@@ -1,30 +1,20 @@
-import { createHash, randomUUID } from 'node:crypto';
+import { randomUUID } from 'node:crypto';
 import { existsSync, realpathSync } from 'node:fs';
 import { lstat, readFile, rename, writeFile } from 'node:fs/promises';
 import { join, resolve, sep } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { captureFileState } from './custody.mjs';
+import { integrateBranchDelta, recoverBranchApply, reviewBranchDelta } from './handoff.mjs';
 import { verifiedHelper } from './helper-snapshot.mjs';
 import { resolveSelectedChecks } from './integration-checks.mjs';
-import {
-  covers,
-  IntegrationError,
-  rollbackWritten,
-  sameState,
-  treeIdentity,
-} from './integration-files.mjs';
-import {
-  checkoutLock,
-  integrateDelegateDelta,
-  patchDigest,
-  reviewDelegateDelta,
-} from './integration-transaction.mjs';
+import { covers, git, IntegrationError } from './integration-files.mjs';
 import { implementationReport, reviewPresentation } from './presentation.mjs';
 import { cleanupAcceptedWorktree, recoverOwnedProcesses } from './run-lifecycle.mjs';
 import { readDelegateCustody, validateDelegateCapsule } from './run-preflight.mjs';
 import {
   assertRunRecordFits,
   closeRunRecord,
+  compactIntegrationState,
   processIdentity,
   readRunRecord,
   updateRunRecord,
@@ -33,13 +23,13 @@ import {
 
 export { discoverDelegateChecks, runDelegateChecks } from './integration-checks.mjs';
 export { IntegrationError } from './integration-files.mjs';
-export { integrateDelegateDelta, reviewDelegateDelta } from './integration-transaction.mjs';
 
 function publicReview(review) {
   return {
     ready: review.ready,
     changedPaths: review.changedPaths,
     violations: review.violations,
+    warnings: review.warnings ?? [],
     patch: review.patch.map(({ path, before, after }) => ({
       path,
       origin: review.changes?.find((change) => change.path === path)?.origin ?? 'delegate',
@@ -88,130 +78,79 @@ export async function delegateIntegrationCommand(action, input = {}) {
   });
 }
 
-async function writeJournal(path, value) {
-  const bytes = Buffer.from(JSON.stringify(value));
-  if (bytes.length > 32 * 1024 * 1024)
-    throw new IntegrationError(
-      'E_INTEGRATION_JOURNAL_LIMIT',
-      'Integration recovery states exceed the private limit.',
-    );
-  const temporary = `${path}.${randomUUID()}.tmp`;
-  await writeFile(temporary, bytes, { mode: 0o600, flag: 'wx' });
-  await rename(temporary, path);
-  return createHash('sha256').update(bytes).digest('hex');
+async function closeIntegrated(record, runDirectory) {
+  const closed = await closeRunRecord(record.runId, {
+    disposition: 'integrated',
+    directory: runDirectory,
+  });
+  if (!closed.nativeSelection || closed.retainWorktree) return undefined;
+  try {
+    return await cleanupAcceptedWorktree(closed, runDirectory);
+  } catch (error) {
+    const cleanup = { status: 'failed', code: error.code ?? 'E_DELEGATE_CLEANUP' };
+    await updateRunRecord(record.runId, { cleanup }, { directory: runDirectory });
+    return cleanup;
+  }
 }
 
-async function recoverIntegration(input, record) {
+async function recoverBranchIntegration(input, record) {
   const integration = record.integration;
   if (!['applying', 'interrupted'].includes(integration?.status))
     throw new IntegrationError('E_INTEGRATION_RECOVERY', 'This run has no unresolved integration.');
-  if (integration.journalPath !== join(record.runPath, 'integration-journal.json'))
-    throw new IntegrationError(
-      'E_INTEGRATION_JOURNAL',
-      'Integration recovery journal pointer is invalid.',
-    );
-  const details = await lstat(integration.journalPath);
-  if (!details.isFile() || details.mode & 0o077 || details.size > 32 * 1024 * 1024)
-    throw new IntegrationError('E_INTEGRATION_JOURNAL', 'Integration recovery journal is unsafe.');
-  const bytes = await readFile(integration.journalPath);
-  if (createHash('sha256').update(bytes).digest('hex') !== integration.journalDigest)
-    throw new IntegrationError('E_INTEGRATION_JOURNAL', 'Integration recovery journal changed.');
-  const journal = JSON.parse(bytes.toString('utf8'));
-  if (journal.runId !== record.runId || journal.repositoryRoot !== record.repositoryRoot)
-    throw new IntegrationError(
-      'E_INTEGRATION_JOURNAL',
-      'Integration recovery journal identity differs.',
-    );
-  const release = await checkoutLock(record.repositoryRoot);
-  try {
-    if (input.resolution === 'accept') {
-      if (integration.cursor !== journal.changes.length || integration.pendingPath)
-        throw new IntegrationError(
-          'E_INTEGRATION_RECOVERY_INCOMPLETE',
-          'Source writes did not complete; recover with rollback.',
-        );
-      for (const change of journal.changes) {
-        if (!sameState(await captureFileState(record.repositoryRoot, change.path), change.after))
-          throw new IntegrationError(
-            'E_INTEGRATION_RECOVERY_CONFLICT',
-            'Accepted source changed after interruption.',
-            { path: change.path },
-          );
-      }
-      if (
-        record.nativeSelection &&
-        (!journal.accepted?.candidateIdentity ||
-          (await treeIdentity(record.repositoryRoot)) !== journal.accepted.candidateIdentity)
-      )
-        throw new IntegrationError(
-          'E_INTEGRATION_RECOVERY_CONFLICT',
-          'The resulting checkout differs from the verified candidate; recover with rollback and review again.',
-        );
-      await updateRunRecord(
-        record.runId,
-        { integration: { status: 'applied', at: new Date().toISOString(), ...journal.accepted } },
-        { directory: input.runDirectory },
-      );
-      const closed = await closeRunRecord(record.runId, {
-        disposition: 'integrated',
-        directory: input.runDirectory,
-      });
-      let cleanup;
-      if (closed.nativeSelection && !closed.retainWorktree) {
-        try {
-          cleanup = await cleanupAcceptedWorktree(closed, input.runDirectory);
-        } catch (error) {
-          cleanup = { status: 'failed', code: error.code ?? 'E_DELEGATE_CLEANUP' };
-          await updateRunRecord(record.runId, { cleanup }, { directory: input.runDirectory });
-        }
-      }
-      return {
-        cleanup,
-        runId: record.runId,
-        status: 'completed',
-        report: implementationReport({ status: 'completed', ...journal.accepted }, record.selector),
-        recovered: 'accepted',
-      };
-    }
-    if (input.resolution && input.resolution !== 'rollback')
-      throw new IntegrationError(
-        'E_INTEGRATION_RECOVERY',
-        'Recovery resolution must be rollback or accept.',
-      );
-    const count = integration.cursor + (integration.pendingPath ? 1 : 0);
-    const rollbackErrors = await rollbackWritten(
-      record.repositoryRoot,
-      journal.changes.slice(0, count),
-      randomUUID(),
-    );
+  const result = await recoverBranchApply(record, input.resolution);
+  const directory = { directory: input.runDirectory };
+  if (result.state === 'applied') {
+    const { status: _status, ...accepted } = integration;
+    const states = {};
+    for (const path of accepted.changedPaths)
+      states[path] = compactIntegrationState(await captureFileState(record.repositoryRoot, path));
     await updateRunRecord(
       record.runId,
-      {
-        integration: {
-          ...integration,
-          status: rollbackErrors.length ? 'interrupted' : 'rolled-back',
-          rollbackErrors,
-        },
-      },
-      { directory: input.runDirectory },
+      { integration: { ...accepted, status: 'applied', at: new Date().toISOString(), states } },
+      directory,
     );
+    await removeRestoreRef(record);
     return {
+      cleanup: await closeIntegrated(record, input.runDirectory),
       runId: record.runId,
-      status: rollbackErrors.length ? 'blocked' : 'completed',
-      recovered: rollbackErrors.length ? 'conflicts' : 'rolled-back',
-      rollbackErrors,
-      nextAction: rollbackErrors.length
-        ? 'Preserve conflicting host edits and resolve the listed paths explicitly.'
-        : 'Review the retained patch again before retrying apply.',
+      status: 'completed',
+      report: implementationReport({ status: 'completed', ...accepted }, record.selector),
+      recovered: 'accepted',
     };
-  } finally {
-    await release();
   }
+  await updateRunRecord(
+    record.runId,
+    {
+      integration: {
+        ...integration,
+        status: result.state,
+        restoredPaths: result.restored,
+        rollbackErrors: result.conflicts,
+      },
+    },
+    directory,
+  );
+  if (result.state === 'rolled-back') await removeRestoreRef(record);
+  return {
+    runId: record.runId,
+    status: result.conflicts.length ? 'blocked' : 'completed',
+    recovered: result.conflicts.length ? 'conflicts' : 'rolled-back',
+    rollbackErrors: result.conflicts,
+    nextAction: result.conflicts.length
+      ? 'Preserve conflicting host edits and resolve the listed paths explicitly.'
+      : 'Review the retained patch again before retrying apply.',
+  };
+}
+
+async function removeRestoreRef(record) {
+  const ref = record.integration.restoreRef;
+  if (ref && (await git(record.repositoryRoot, 'for-each-ref', ref)).length)
+    await git(record.repositoryRoot, 'update-ref', '-d', ref);
 }
 
 async function integrationCommandLocked(action, input, record) {
   record = await recoverOwnedProcesses(record, input.runDirectory);
-  if (action === 'recover') return recoverIntegration(input, record);
+  if (action === 'recover') return recoverBranchIntegration(input, record);
   if (['applying', 'interrupted'].includes(record.integration?.status))
     throw new IntegrationError(
       'E_RUN_INTEGRATION_RECOVERY',
@@ -274,7 +213,7 @@ async function integrationCommandLocked(action, input, record) {
     preservePaths: input.preservePaths,
   };
   if (action === 'review') {
-    const observed = await reviewDelegateDelta(common);
+    const observed = await reviewBranchDelta(common);
     if (observed.ready)
       await updateRunRecord(
         input.runId,
@@ -282,7 +221,7 @@ async function integrationCommandLocked(action, input, record) {
           verificationMutations:
             record.verification?.mutatedPaths ?? record.verificationMutations ?? [],
           reviewedPatch: {
-            digest: patchDigest(observed),
+            digest: observed.tip,
             at: new Date().toISOString(),
             scopePaths,
           },
@@ -332,9 +271,29 @@ async function integrationCommandLocked(action, input, record) {
   const verificationProcess = await processIdentity();
   const evidencePath = join(record.runPath, `verification-${randomUUID()}.json`);
   let verification;
-  const result = await integrateDelegateDelta({
+  const result = await integrateBranchDelta({
     ...common,
-    capsule,
+    patchPath: join(record.runPath, 'patch.diff'),
+    onApplying: async (accepted) => {
+      const placeholder = { kind: 'file', mode: 0o644, digest: '0'.repeat(64) };
+      const current = await readRunRecord(record.runId, { directory: input.runDirectory });
+      assertRunRecordFits({
+        ...current,
+        integration: {
+          status: 'applied',
+          ...accepted,
+          states: Object.fromEntries(accepted.changedPaths.map((path) => [path, placeholder])),
+        },
+        status: 'closed',
+        disposition: 'integrated',
+        closedAt: new Date().toISOString(),
+      });
+      await updateRunRecord(
+        record.runId,
+        { integration: { status: 'applying', phase: 'source-write', ...accepted } },
+        { directory: input.runDirectory },
+      );
+    },
     checks: input.checks,
     preparation: input.preparation,
     baselineComparison: input.baselineComparison === true,
@@ -362,53 +321,6 @@ async function integrationCommandLocked(action, input, record) {
     generators: input.generators,
     timeoutMs: input.timeoutMs,
     reviewedDigest: record.reviewedPatch.digest,
-    beforeApply: async ({ changes, ...accepted }) => {
-      const current = await readRunRecord(record.runId, { directory: input.runDirectory });
-      assertRunRecordFits({
-        ...current,
-        integration: { status: 'applied', ...accepted },
-        status: 'closed',
-        disposition: 'integrated',
-        closedAt: new Date().toISOString(),
-      });
-      const journalPath = join(record.runPath, 'integration-journal.json');
-      const journalDigest = await writeJournal(journalPath, {
-        schemaVersion: '1.0.0',
-        runId: record.runId,
-        repositoryRoot: record.repositoryRoot,
-        changes,
-        accepted,
-      });
-      await updateRunRecord(
-        record.runId,
-        {
-          integration: {
-            status: 'applying',
-            phase: 'source-write',
-            journalPath,
-            journalDigest,
-            changedPaths: accepted.changedPaths,
-            cursor: 0,
-            pendingPath: null,
-          },
-        },
-        { directory: input.runDirectory },
-      );
-    },
-    onProgress: async (path, phase) => {
-      const current = await readRunRecord(record.runId, { directory: input.runDirectory });
-      await updateRunRecord(
-        record.runId,
-        {
-          integration: {
-            ...current.integration,
-            cursor: current.integration.cursor + (phase === 'after' ? 1 : 0),
-            pendingPath: phase === 'before' ? path : null,
-          },
-        },
-        { directory: input.runDirectory },
-      );
-    },
     onAccepted: async (integration) =>
       updateRunRecord(
         input.runId,
@@ -417,18 +329,13 @@ async function integrationCommandLocked(action, input, record) {
         },
         { directory: input.runDirectory },
       ),
-    onRolledBack: async ({ rollbackErrors, code }) => {
+    onRolledBack: async ({ code }) => {
       const current = await readRunRecord(record.runId, { directory: input.runDirectory });
       if (current.integration?.status !== 'applying') return;
       await updateRunRecord(
         record.runId,
         {
-          integration: {
-            ...current.integration,
-            status: rollbackErrors.length ? 'interrupted' : 'rolled-back',
-            rollbackErrors,
-            code,
-          },
+          integration: { ...current.integration, status: 'rolled-back', rollbackErrors: [], code },
         },
         { directory: input.runDirectory },
       );
@@ -442,32 +349,20 @@ async function integrationCommandLocked(action, input, record) {
     checks: result.checks ?? [],
     verification: verification ?? null,
     generatedPaths: result.generatedPaths ?? [],
+    unselectedDirtyPaths: result.unselectedDirtyPaths ?? [],
+    unselectedDirtyCount: result.unselectedDirtyCount ?? 0,
     generators: result.generators ?? [],
     code: result.code ?? null,
     rollbackErrors: result.rollbackErrors ?? [],
     nextAction: result.nextAction,
   };
   if (result.status === 'completed') {
-    const closed = await closeRunRecord(input.runId, {
-      disposition: 'integrated',
-      directory: input.runDirectory,
-    });
-    if (closed.nativeSelection && !closed.retainWorktree) {
-      try {
-        output.cleanup = await cleanupAcceptedWorktree(closed, input.runDirectory);
-      } catch (error) {
-        output.cleanup = { status: 'failed', code: error.code ?? 'E_DELEGATE_CLEANUP' };
-        output.violations.push({
-          code: output.cleanup.code,
-          message: 'Integration succeeded; owned worktree cleanup needs attention.',
-        });
-        await updateRunRecord(
-          input.runId,
-          { cleanup: output.cleanup },
-          { directory: input.runDirectory },
-        );
-      }
-    }
+    output.cleanup = await closeIntegrated(record, input.runDirectory);
+    if (output.cleanup?.status === 'failed')
+      output.violations.push({
+        code: output.cleanup.code,
+        message: 'Integration succeeded; owned worktree cleanup needs attention.',
+      });
   }
   return {
     ...output,