amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/workspace/content.js

@@ -1,32 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-
-const CHUNK_BYTES = 512 * 1024;
-
-function sha256(bytes) {
-  return crypto.createHash('sha256').update(bytes).digest('hex');
-}
-
-function describeBytes(bytesInput) {
-  const bytes = Buffer.isBuffer(bytesInput) ? bytesInput : Buffer.from(bytesInput);
-  const chunks = [];
-  for (let offset = 0; offset < bytes.length; offset += CHUNK_BYTES) {
-    const part = bytes.subarray(offset, Math.min(offset + CHUNK_BYTES, bytes.length));
-    chunks.push({ sha256: sha256(part), bytes: part.length });
-  }
-  return chunks;
-}
-
-function manifestChecksum(chunks) {
-  return sha256(Buffer.from(JSON.stringify(
-    chunks.map((chunk) => ({ sha256: chunk.sha256, bytes: chunk.bytes })),
-  )));
-}
-
-module.exports = {
-  CHUNK_BYTES,
-  describeBytes,
-  manifestChecksum,
-  sha256,
-};

package/runtime/scripts/amalgm-mcp/workspace/durable.js

@@ -1,45 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-
-function syncDirectory(directory) {
-  const descriptor = fs.openSync(directory, 'r');
-  try {
-    fs.fsyncSync(descriptor);
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-
-/**
- * Durable sync state is replaced, never edited in place. After a process
- * death, readers therefore see either the complete old value or the complete
- * new value.
- */
-function writeFile(file, content, mode = 0o600) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const temporary = path.join(
-    path.dirname(file),
-    `.${path.basename(file)}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`,
-  );
-  let descriptor = fs.openSync(temporary, 'wx', mode);
-  try {
-    fs.writeFileSync(descriptor, content);
-    fs.fsyncSync(descriptor);
-    fs.closeSync(descriptor);
-    descriptor = null;
-    fs.renameSync(temporary, file);
-    syncDirectory(path.dirname(file));
-  } finally {
-    if (descriptor !== null) fs.closeSync(descriptor);
-    if (fs.existsSync(temporary)) fs.rmSync(temporary, { force: true });
-  }
-}
-
-function writeJson(file, value, { pretty = false } = {}) {
-  writeFile(file, `${JSON.stringify(value, null, pretty ? 2 : 0)}\n`);
-}
-
-module.exports = { writeFile, writeJson };

package/runtime/scripts/amalgm-mcp/workspace/intent.js

@@ -1,535 +0,0 @@
-'use strict';
-
-/**
- * Durable local authorship for one registered code folder.
- *
- * The official stream still has only two values: card and checkpoint. This
- * file is not shared state. It records the exact local state a real file/Git
- * observation saw, relative to the last verified official state on this
- * machine. The reducer may preserve only this record; a physical mismatch by
- * itself never creates authorship.
- *
- * Axiom 4: a reserved predecessor is immutable and later work occupies one
- * successor pinned to its exact content. Proven by workspace-local-intent.test.js.
- */
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const { AMALGM_DIR } = require('../config');
-const durable = require('./durable');
-const provenance = require('./provenance');
-
-const INTENT_CONTRACT = 'repo-local-intent@4';
-const LEGACY_INTENT_CONTRACTS = new Set([
-  'repo-local-intent@2',
-  'repo-local-intent@3',
-]);
-const SUCCESSOR_CONTRACT = 'repo-local-intent-successor@2';
-const LEGACY_SUCCESSOR_CONTRACT = 'repo-local-intent-successor@1';
-const INTENT_DIR = path.join(AMALGM_DIR, 'state', 'repo-local-intent');
-const SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
-const MUTATION_ID = /^[A-Za-z0-9_-]{16,160}$/;
-
-function newMutationId() {
-  return `mut_${crypto.randomBytes(18).toString('base64url')}`;
-}
-
-function intentFile(resourceId) {
-  const digest = crypto.createHash('sha256').update(resourceId).digest('hex').slice(0, 24);
-  return path.join(INTENT_DIR, `${digest}.json`);
-}
-
-function canonicalPath(localPath) {
-  const resolved = path.resolve(localPath);
-  const tail = [];
-  let existing = resolved;
-  while (!fs.existsSync(existing)) {
-    const parent = path.dirname(existing);
-    if (parent === existing) return resolved;
-    tail.unshift(path.basename(existing));
-    existing = parent;
-  }
-  return path.join(fs.realpathSync.native(existing), ...tail);
-}
-
-function branchState(branches) {
-  return (branches || [])
-    .map((branch) => ({ name: branch.name, oid: branch.oid ?? null }))
-    .sort((left, right) => left.name.localeCompare(right.name));
-}
-
-function cardState(card) {
-  return {
-    head: {
-      branch: card?.head?.branch ?? null,
-      oid: card?.head?.oid ?? null,
-      detached: Boolean(card?.head?.detached),
-    },
-    branches: branchState(card?.branches || card?.refs),
-  };
-}
-
-function semanticState(value) {
-  return {
-    card: cardState(value?.local?.card),
-    checkpoint: {
-      baseOid: value?.local?.checkpoint?.baseOid ?? null,
-      branch: value?.local?.checkpoint?.branch ?? null,
-      revision: value?.local?.checkpoint?.value?.revision ?? null,
-    },
-  };
-}
-
-function semanticDigest(value) {
-  return crypto.createHash('sha256')
-    .update(JSON.stringify(semanticState(value)))
-    .digest('hex');
-}
-
-function validTree(value) {
-  return SHA.test(String(value || ''));
-}
-
-function validInitialBase(base) {
-  return Boolean(
-    base?.through === 0
-    && base.card === null
-    && validTree(base.indexTree)
-    && base.indexTree === base.worktreeTree
-  );
-}
-
-function validLocal(local) {
-  return Boolean(
-    validTree(local?.card?.head?.oid)
-    && Array.isArray(local?.card?.branches)
-    && validTree(local?.indexTree)
-    && validTree(local?.worktreeTree)
-    && local?.checkpoint?.baseOid === local.card.head.oid
-    && typeof local?.physicalDigest === 'string'
-  );
-}
-
-function sameCard(left, right) {
-  return JSON.stringify(cardState(left)) === JSON.stringify(cardState(right));
-}
-
-function validSuccessor(value, predecessor) {
-  const currentContract = value?.contract === SUCCESSOR_CONTRACT;
-  const legacyContract = value?.contract === LEGACY_SUCCESSOR_CONTRACT;
-  return Boolean(
-    value
-    && (currentContract || legacyContract)
-    && (!currentContract || MUTATION_ID.test(value.birthMutationId))
-    && value.predecessorSemanticDigest === predecessor.semanticDigest
-    && value.base?.semanticDigest === predecessor.semanticDigest
-    && sameCard(value.base?.card, predecessor.local.card)
-    && value.base?.indexTree === predecessor.local.indexTree
-    && value.base?.worktreeTree === predecessor.local.worktreeTree
-    && value.base?.physicalDigest === predecessor.local.physicalDigest
-    && validLocal(value.local)
-    && value.semanticDigest === semanticDigest(value)
-    && typeof value.capturedAt === 'string'
-  );
-}
-
-function validIntent(value, project) {
-  const initial = validInitialBase(value?.base);
-  const currentContract = value?.contract === INTENT_CONTRACT;
-  const legacyContract = LEGACY_INTENT_CONTRACTS.has(value?.contract)
-    && (
-      value.contract !== 'repo-local-intent@2'
-      || value.successor === undefined
-      || value.successor === null
-    );
-  return Boolean(
-    value
-    && (currentContract || legacyContract)
-    && (!currentContract || MUTATION_ID.test(value.birthMutationId))
-    && value.resourceId === project.resourceId
-    && value.ownerUserId === project.ownerUserId
-    && canonicalPath(value.path) === canonicalPath(project.path)
-    && Number.isInteger(value.base?.through)
-    && value.base.through >= 0
-    && (
-      initial
-      || (
-        validTree(value.base?.card?.head?.oid)
-        && Array.isArray(value.base?.card?.branches)
-        && validTree(value.base?.indexTree)
-        && validTree(value.base?.worktreeTree)
-      )
-    )
-    && validLocal(value.local)
-    && value.semanticDigest === semanticDigest(value)
-    && (
-      value.successor === undefined
-      || value.successor === null
-      || validSuccessor(value.successor, value)
-    )
-    && (
-      value.publication === null
-      || (
-        typeof value.publication?.mutationId === 'string'
-        && (
-          !currentContract
-          || value.publication.mutationId === value.birthMutationId
-        )
-        && value.publication.semanticDigest === value.semanticDigest
-        && value.publication.baseThrough === value.base.through
-        && (
-          (
-            value.publication.numberedVersion === null
-            && value.publication.numberedAt === null
-            && value.publication.foldedAt === null
-          )
-          || (
-            Number.isInteger(value.publication.numberedVersion)
-            && value.publication.numberedVersion > 0
-            && typeof value.publication.numberedAt === 'string'
-            && (
-              value.publication.foldedAt === null
-              || typeof value.publication.foldedAt === 'string'
-            )
-          )
-        )
-      )
-    )
-  );
-}
-
-function persistIntent(project, value) {
-  if (!validIntent(value, project)) throw new Error('local code intent is invalid');
-  durable.writeJson(intentFile(project.resourceId), value, { pretty: true });
-  return value;
-}
-
-function readIntent(project) {
-  if (!project?.resourceId || !project?.path || !project?.ownerUserId) return null;
-  const file = intentFile(project.resourceId);
-  let raw;
-  try {
-    raw = fs.readFileSync(file, 'utf8');
-  } catch (error) {
-    if (error?.code === 'ENOENT') return null;
-    throw new Error(`cannot read local code intent ${file}`, { cause: error });
-  }
-  let value;
-  try {
-    value = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`local code intent ${file} is not valid JSON`, { cause: error });
-  }
-  if (!validIntent(value, project)) {
-    throw new Error(`local code intent ${file} has an invalid or unsupported contract`);
-  }
-  return value;
-}
-
-function writeIntent(project, input) {
-  const held = readIntent(project);
-  const nextSemanticDigest = semanticDigest({ local: input.local });
-  const samePredecessor = held
-    && held.semanticDigest === nextSemanticDigest
-    && JSON.stringify(held.base) === JSON.stringify(input.base);
-  let birthMutationId = MUTATION_ID.test(String(input.birthMutationId || ''))
-    ? input.birthMutationId
-    : null;
-  if (
-    !birthMutationId
-    && (
-      input.preserveBirthMutationId === true
-      || samePredecessor
-    )
-    && MUTATION_ID.test(String(held?.birthMutationId || ''))
-  ) birthMutationId = held.birthMutationId;
-  if (
-    !birthMutationId
-    && MUTATION_ID.test(String(input.publication?.mutationId || ''))
-  ) birthMutationId = input.publication.mutationId;
-  if (!birthMutationId) birthMutationId = newMutationId();
-  const next = {
-    contract: INTENT_CONTRACT,
-    birthMutationId,
-    resourceId: project.resourceId,
-    ownerUserId: project.ownerUserId,
-    path: canonicalPath(project.path),
-    base: input.base,
-    local: input.local,
-    publication: input.publication || null,
-    terminal: input.terminal || null,
-    capturedAt: new Date().toISOString(),
-  };
-  next.semanticDigest = nextSemanticDigest;
-  next.successor = input.successor === undefined && samePredecessor
-    ? held.successor || null
-    : input.successor || null;
-  return persistIntent(project, next);
-}
-
-/**
- * Freeze the published intent and atomically replace only its open successor.
- *
- * A successor is a final desk state, not an edit log. Its base is the exact
- * content identity of the frozen predecessor, so repeated saves coalesce
- * without ever changing the bytes or publication identity already in flight.
- */
-function writeSuccessor(project, predecessor, input) {
-  let held = readIntent(project);
-  if (!held || held.semanticDigest !== predecessor?.semanticDigest) return null;
-  if (
-    held.contract !== INTENT_CONTRACT
-    || !MUTATION_ID.test(String(held.birthMutationId || ''))
-  ) {
-    held = writeIntent(project, {
-      base: held.base,
-      local: held.local,
-      terminal: held.terminal,
-      successor: held.successor,
-      publication: held.publication,
-    });
-  }
-  const prior = held.successor || null;
-  const successor = {
-    contract: SUCCESSOR_CONTRACT,
-    birthMutationId: null,
-    predecessorSemanticDigest: held.semanticDigest,
-    base: {
-      semanticDigest: held.semanticDigest,
-      card: held.local.card,
-      indexTree: held.local.indexTree,
-      worktreeTree: held.local.worktreeTree,
-      physicalDigest: held.local.physicalDigest,
-    },
-    local: input.local,
-    terminal: input.terminal || null,
-    capturedAt: new Date().toISOString(),
-  };
-  successor.semanticDigest = semanticDigest(successor);
-  successor.birthMutationId = (
-    prior?.semanticDigest === successor.semanticDigest
-    && MUTATION_ID.test(String(prior.birthMutationId || ''))
-  ) ? prior.birthMutationId : newMutationId();
-  persistIntent(project, { ...held, contract: INTENT_CONTRACT, successor });
-  return successor;
-}
-
-function readSuccessor(project) {
-  return readIntent(project)?.successor || null;
-}
-
-function clearSuccessor(project, predecessor = null) {
-  let held = readIntent(project);
-  if (
-    !held?.successor
-    || (
-      predecessor
-      && held.semanticDigest !== predecessor.semanticDigest
-    )
-  ) return false;
-  if (
-    held.contract !== INTENT_CONTRACT
-    || !MUTATION_ID.test(String(held.birthMutationId || ''))
-  ) {
-    held = writeIntent(project, {
-      base: held.base,
-      local: held.local,
-      terminal: held.terminal,
-      successor: held.successor,
-      publication: held.publication,
-    });
-  }
-  persistIntent(project, { ...held, contract: INTENT_CONTRACT, successor: null });
-  return true;
-}
-
-function clearIntent(project) {
-  if (!project?.resourceId) return false;
-  const file = intentFile(project.resourceId);
-  if (!fs.existsSync(file)) return false;
-  fs.rmSync(file, { force: true });
-  return true;
-}
-
-function stampPublication(project, intent, mutationId) {
-  const held = readIntent(project);
-  if (
-    !held
-    || held.semanticDigest !== intent?.semanticDigest
-    || mutationId !== held.birthMutationId
-  ) return null;
-  return writeIntent(project, {
-    birthMutationId: held.birthMutationId,
-    base: held.base,
-    local: held.local,
-    terminal: held.terminal,
-    publication: {
-      mutationId,
-      semanticDigest: held.semanticDigest,
-      baseThrough: held.base.through,
-      numberedVersion: null,
-      numberedAt: null,
-      foldedAt: null,
-    },
-  });
-}
-
-function reservePublication(project, intent) {
-  let held = readIntent(project);
-  if (!held || held.semanticDigest !== intent?.semanticDigest) return null;
-  if (!MUTATION_ID.test(String(held.birthMutationId || ''))) {
-    held = writeIntent(project, {
-      base: held.base,
-      local: held.local,
-      terminal: held.terminal,
-      successor: held.successor,
-      publication: held.publication,
-    });
-  }
-  if (
-    held.publication
-    && held.publication.semanticDigest === held.semanticDigest
-    && held.publication.baseThrough === held.base.through
-    && held.publication.numberedVersion === null
-  ) return held;
-  provenance.requireTransition(
-    provenance.publicationState(held.publication),
-    provenance.ACTION.RESERVE,
-    provenance.STATE.RESERVED,
-    ['intent-record', 'publication-id'],
-  );
-  return stampPublication(
-    project,
-    held,
-    held.birthMutationId,
-  );
-}
-
-function markPublicationNumbered(project, mutationId, version, numberedAt = null) {
-  const held = readIntent(project);
-  if (!held || held.publication?.mutationId !== mutationId) return null;
-  if (!Number.isInteger(version) || version < 1) {
-    throw new Error('numbered publication version is invalid');
-  }
-  if (
-    held.publication.numberedVersion !== null
-    && held.publication.numberedVersion !== version
-  ) throw new Error('publication received a different official number');
-  if (held.publication.numberedVersion === version) return held;
-  provenance.requireTransition(
-    provenance.publicationState(held.publication),
-    provenance.ACTION.NUMBER,
-    provenance.STATE.NUMBERED,
-    ['publication-id', 'official-version', 'server-receipt'],
-  );
-  return writeIntent(project, {
-    base: held.base,
-    local: held.local,
-    terminal: held.terminal,
-    publication: {
-      ...held.publication,
-      numberedVersion: version,
-      numberedAt: numberedAt || new Date().toISOString(),
-    },
-  });
-}
-
-function markPublicationFolded(project, mutationId, version, numberedAt = null) {
-  const numbered = markPublicationNumbered(project, mutationId, version, numberedAt);
-  if (!numbered || numbered.publication.foldedAt !== null) return numbered;
-  provenance.requireTransition(
-    provenance.publicationState(numbered.publication),
-    provenance.ACTION.FOLD,
-    provenance.STATE.FOLDED,
-    ['predecessor-folded', 'official-event', 'official-snapshot'],
-  );
-  return writeIntent(project, {
-    base: numbered.base,
-    local: numbered.local,
-    terminal: numbered.terminal,
-    publication: {
-      ...numbered.publication,
-      foldedAt: new Date().toISOString(),
-    },
-  });
-}
-
-function officialAcknowledgement(project, intent) {
-  if (!intent?.publication?.mutationId) return null;
-  if (
-    Number.isInteger(intent.publication.numberedVersion)
-    && intent.publication.numberedVersion > 0
-    && typeof intent.publication.numberedAt === 'string'
-  ) {
-    return {
-      mutationId: intent.publication.mutationId,
-      version: intent.publication.numberedVersion,
-    };
-  }
-  const row = require('../state/mutations').getMutation(
-    `resource:${project.resourceId}`,
-    intent.publication.mutationId,
-    { revealOperation: true },
-  );
-  return (
-    row
-    && row.state === 'synced'
-    && Number.isInteger(row.officialCloudVersion)
-    && row.officialCloudVersion > 0
-    && intent.publication.semanticDigest === intent.semanticDigest
-  ) ? {
-    mutationId: row.mutationId,
-    version: row.officialCloudVersion,
-  } : null;
-}
-
-function publicationMayRebase(project, intent, through) {
-  if (
-    !intent?.publication?.mutationId
-    || intent.publication.numberedVersion !== null
-    || !Number.isInteger(through)
-    || through <= intent.base.through
-  ) return false;
-  const row = require('../state/mutations').getMutation(
-    `resource:${project.resourceId}`,
-    intent.publication.mutationId,
-  );
-  return !row || (
-    row.state === 'rejected'
-    && row.failureCode === 'code_project_stale_base'
-  );
-}
-
-function readOwnedIntent(project) {
-  const intent = readIntent(project);
-  if (!intent) return null;
-  return officialAcknowledgement(project, intent) ? null : intent;
-}
-
-module.exports = {
-  INTENT_CONTRACT,
-  SUCCESSOR_CONTRACT,
-  _test: {
-    canonicalPath,
-    cardState,
-    semanticDigest,
-    validInitialBase,
-    validIntent,
-    validSuccessor,
-  },
-  clearIntent,
-  clearSuccessor,
-  intentFile,
-  markPublicationFolded,
-  markPublicationNumbered,
-  officialAcknowledgement,
-  publicationMayRebase,
-  readIntent,
-  readOwnedIntent,
-  readSuccessor,
-  reservePublication,
-  stampPublication,
-  writeIntent,
-  writeSuccessor,
-};

package/runtime/scripts/amalgm-mcp/workspace/native-file-transaction/BUILD.md

@@ -1,31 +0,0 @@
-# Native workspace file transaction
-
-This helper is the only code allowed to observe or cross an ordered file or
-Git-metadata mutation. JavaScript cannot express
-`openat`/`renameat`/`linkat`, so path confinement at that layer has an
-unavoidable check/use race. The helper opens each parent directory with
-`O_NOFOLLOW` and performs every observation and mutation relative to those
-held descriptors.
-
-`main.go` owns the transaction and crash ordering. `move_*.go` consumes a
-prepared target without replacing a concurrent destination; its disappearance
-is the crossing receipt. `writers_*.go` proves that an extracted source inode
-has no pre-existing writer before it can be retired. The checked-in binaries
-are required because managed runtimes do not include a Go compiler.
-`manifest.json` binds them to the exact source bytes.
-
-The `git-lock` backend prepares index or HEAD bytes inside the linked
-worktree's private Git directory, hard-links them to Git's canonical lock, and
-renames that lock over the destination. The retained hard link identifies the
-crossing even after later Git activity changes the destination or creates a
-new lock.
-
-Rebuild and verify both release platforms:
-
-```sh
-node build.mjs
-node verify.mjs
-```
-
-The ordinary JavaScript transition tests execute the host binary against real
-Git repositories, crashes, open descriptors, and directory-swap races.