workbite 0.1.11 → 0.1.13

package/lib/diagnostics.js

@@ -0,0 +1,234 @@
+'use strict';
+// Read-only snapshots, never lifecycle authority. Do not authenticate endpoints,
+// read token files, acquire locks, install binaries or replay pending intents here.
+const fs = require('node:fs/promises');
+const { constants } = require('node:fs');
+const path = require('node:path');
+const { locations, releaseSpec, installName } = require('./install');
+const { stateLayout } = require('./runtime');
+const { bootIdentity, validBoot, previousBoot } = require('./boot-provenance');
+const { UUID } = require('./common');
+
+const MAX_BYTES = 65536, MAX_OWNERS = 32, MAX_ENTRIES = 128;
+const LAUNCH = /^[0-9a-f]{16}$/;
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const pidValue = value => Number.isSafeInteger(value) && value > 0 && value <= 2147483647;
+const NO_DELETE = 'Do not auto-delete, move or replace locks, owner/backend records, native intent or flock files. '
+  + 'Unverified ownership requires manual inspection on the recorded host; keep the original evidence.';
+
+// Reject links in ancestors as well as the leaf; never follow record-provided paths.
+// This is a snapshot, not a pinned filesystem authority: concurrent replacement
+// and NFS visibility can still make evidence incomplete.
+async function checkedStat(file) {
+  const parents = [];
+  for (let parent = path.dirname(file); ; parent = path.dirname(parent)) {
+    if (parents.length >= 128) throw new Error('unsafe');
+    parents.push(parent);
+    if (parent === path.dirname(parent)) break;
+  }
+  for (const parent of parents.reverse()) {
+    const info = await fs.lstat(parent);
+    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('unsafe');
+  }
+  const info = await fs.lstat(file);
+  if (info.isSymbolicLink()) throw new Error('unsafe');
+  return info;
+}
+async function bytes(file, maximum = MAX_BYTES) {
+  const info = await checkedStat(file);
+  if (!info.isFile() || info.size > maximum) throw new Error('unsafe');
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW || 0) | (constants.O_NONBLOCK || 0));
+  try {
+    const opened = await handle.stat();
+    if (!opened.isFile() || opened.size > maximum || opened.ino !== info.ino || opened.dev !== info.dev) throw new Error('unsafe');
+    const buffer = Buffer.alloc(maximum + 1);
+    let size = 0;
+    while (size < buffer.length) {
+      const result = await handle.read(buffer, size, buffer.length - size, null);
+      if (!result.bytesRead) break;
+      size += result.bytesRead;
+    }
+    if (size > maximum) throw new Error('unsafe');
+    return buffer.subarray(0, size);
+  } finally { await handle.close(); }
+}
+async function metadata(file, directory = false) {
+  try {
+    const info = await checkedStat(file);
+    return { path: file, status: (directory ? info.isDirectory() : info.isFile()) ? 'present' : 'unsafe' };
+  } catch (error) { return { path: file, status: error.code === 'ENOENT' ? 'absent' : 'unreadable-or-unsafe' }; }
+}
+async function readRecord(file, legacy = false) {
+  try {
+    const text = new TextDecoder('utf-8', { fatal: true }).decode(await bytes(file));
+    if (legacy && /^[1-9][0-9]{0,9}\s*$/.test(text) && pidValue(Number(text))) {
+      return { path: file, status: 'legacy-pid', value: { pid: Number(text) } };
+    }
+    const value = JSON.parse(text);
+    if (!object(value)) return { path: file, status: 'malformed' };
+    return { path: file, status: 'parsed', value };
+  } catch (error) {
+    return { path: file, status: error.code === 'ENOENT' ? 'absent'
+      : error instanceof SyntaxError || error instanceof TypeError ? 'malformed' : 'unreadable-or-unsafe' };
+  }
+}
+function provenance(saved, current) {
+  if (!validBoot(saved) || !validBoot(current)) return { host: 'unknown', boot: 'unknown' };
+  if (saved.host !== current.host) return { host: 'foreign', boot: 'not-comparable' };
+  if (saved.source !== current.source) return { host: 'local', boot: 'unknown' };
+  return { host: 'local', boot: saved.id === current.id ? 'current' : previousBoot(saved, current) ? 'previous' : 'unknown' };
+}
+function nativeBoot(value) {
+  if (!object(value) || Object.keys(value).length !== 3 || !Object.hasOwn(value, 'boot')) return null;
+  if (value.source === 'linux-boot-id') return { source: value.source, host: value.host, id: value.boot };
+  if (value.source === 'windows-cim-boot-time' && typeof value.host === 'string'
+      && /^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(value.host)) {
+    return { source: 'windows-wmi-boot-time', host: value.host.replace(/-/g, ''), id: value.boot };
+  }
+  return null;
+}
+function probePid(pid) {
+  try { process.kill(pid, 0); return 'exists'; } catch (error) {
+    return error.code === 'ESRCH' ? 'missing' : error.code === 'EPERM' ? 'exists-permission-denied' : 'unknown';
+  }
+}
+function summarize(record, kind, current, pidProbe) {
+  const { value, ...result } = record;
+  result.kind = kind;
+  if (!value) return result;
+  // Only closed enums and validated integers leave the record. Never emit free
+  // text errors, endpoints, descriptors, tokens, bindings or intent payloads.
+  const knownSchema = kind === 'owner' ? value.schema === 'workbite.owner.v2'
+    : kind === 'backend' ? value.schema === 'workbite.stackbite-backend.v2'
+      : kind === 'native-daemon' ? value.schema === 'stackbite-rust-daemon-startup-v1'
+        : kind === 'native-ui' ? value.schema === 'workstack.tui-intent.v1'
+          : kind === 'selection' ? value.schema === 'workbite.workspace-selection.v1'
+            : kind === 'backend-identity' ? value.schema === 'stackbite.workstack-backend.v1' : false;
+  result.format = record.status === 'legacy-pid' ? 'legacy-pid' : knownSchema ? 'recognized-schema' : 'unknown-schema';
+  const stage = kind === 'native-daemon' ? value.phase : value.state;
+  result.stage = ['starting', 'ready', 'attempted', 'descriptor', 'selected', 'unknown'].includes(stage) ? stage : 'unknown';
+  result.provenance = provenance(kind === 'native-daemon' ? nativeBoot(value.owner_boot) : value.boot, current);
+  result.pid = pidValue(value.pid) ? value.pid : null;
+  result.pidEvidence = 'not-probed';
+  if (result.pid && result.provenance.host === 'local' && result.provenance.boot === 'current') {
+    try {
+      const evidence = pidProbe(result.pid);
+      result.pidEvidence = ['exists', 'missing', 'exists-permission-denied'].includes(evidence) ? evidence : 'unknown';
+    } catch { result.pidEvidence = 'unknown'; }
+  }
+  result.identity = 'unverified';
+  result.cleanupSafe = false;
+  if (['owner', 'backend'].includes(kind) && typeof value.launch === 'string' && LAUNCH.test(value.launch)) {
+    result.logHint = path.join(path.dirname(kind === 'owner' ? path.dirname(record.path) : record.path),
+      'logs', `${kind === 'owner' ? 'workstack-engine-' + path.basename(record.path, '.json') : 'stackbite-backend'}-${value.launch}.log`);
+  }
+  if (kind === 'native-daemon') result.savedLogHints = typeof value.log_file === 'string' || typeof value.stderr_log_file === 'string';
+  if (kind === 'native-ui') result.pendingIntent = knownSchema && UUID.test(value.intent || '') ? 'retained-do-not-replay' : 'unknown-do-not-replay';
+  return result;
+}
+async function ownerRecords(directory) {
+  const records = [];
+  let handle, entries = 0, limited = false, status = 'present';
+  try {
+    if (!(await checkedStat(directory)).isDirectory()) throw new Error('unsafe');
+    handle = await fs.opendir(directory, { bufferSize: 16 });
+    while (entries < MAX_ENTRIES && records.length < MAX_OWNERS) {
+      const entry = await handle.read();
+      if (!entry) break;
+      entries++;
+      if (/^[0-9a-f]{24}\.json$/.test(entry.name)) records.push(await readRecord(path.join(directory, entry.name)));
+    }
+    limited = entries === MAX_ENTRIES || records.length === MAX_OWNERS;
+  } catch (error) { status = error.code === 'ENOENT' ? 'absent' : 'unreadable-or-unsafe'; }
+  finally { if (handle) await handle.close(); }
+  return { path: directory, status, entriesExamined: entries, limited, records };
+}
+
+async function inspectStartup(options = {}) {
+  const environment = options.environment || process.env, platform = options.platform || process.platform;
+  const where = locations(environment, platform);
+  const state = path.resolve(options.stateRoot || where.state), apps = path.resolve(options.apps || where.apps);
+  const layout = stateLayout(state);
+  const paths = { workbiteHome: path.dirname(where.apps), apps, state, logs: layout.logs,
+    lock: layout.lock, owners: layout.owners, backend: layout.stackbiteRecord, selection: layout.selection,
+    nativeIntent: path.join(layout.stackbite, '.stackbite-rust-daemon', 'intent.json'), uiIntent: layout.tuiIntent };
+  // Linux bootIdentity is file-only. Windows' implementation invokes WMI through
+  // PowerShell, so leave boot provenance unknown here to keep diagnostics process-free.
+  let boot = null;
+  try {
+    if (options.bootImpl) boot = await options.bootImpl();
+    else if (platform === 'linux') boot = await bootIdentity({ platform, environment,
+      readImpl: async file => (await bytes(file, 4096)).toString('utf8') });
+  } catch { /* unavailable provenance stays unknown */ }
+  const pidProbe = options.pidProbe || probePid;
+  const owners = await ownerRecords(layout.owners);
+  const records = [
+    summarize(await readRecord(layout.lock, true), 'open-lock', boot, pidProbe),
+    ...owners.records.map(record => summarize(record, 'owner', boot, pidProbe)),
+    summarize(await readRecord(layout.stackbiteRecord), 'backend', boot, pidProbe),
+    summarize(await readRecord(path.join(layout.stackbite, 'workstack-backend.json')), 'backend-identity', boot, pidProbe),
+    summarize(await readRecord(layout.selection), 'selection', boot, pidProbe),
+    summarize(await readRecord(paths.nativeIntent), 'native-daemon', boot, pidProbe),
+    summarize(await readRecord(layout.tuiIntent), 'native-ui', boot, pidProbe),
+  ];
+  let installation = { status: 'pinned-target-unavailable', integrity: 'not-checked' };
+  try {
+    const spec = releaseSpec(options.manifest || require('../release.json'), platform, options.arch || process.arch, options);
+    paths.installation = path.join(apps, installName(spec));
+    installation = { ...await metadata(paths.installation, true), integrity: 'not-checked',
+      bundle: await metadata(path.join(paths.installation, 'bundle.json')) };
+  } catch { /* Diagnostics must still work when release pins/platform are unavailable. */ }
+  const stateInfo = await metadata(state, true);
+  const present = records.filter(record => record.status !== 'absent');
+  const uncertain = present.some(record => record.status !== 'parsed' || record.format !== 'recognized-schema'
+    || (!['selection', 'backend-identity', 'native-ui'].includes(record.kind)
+      && (record.stage === 'unknown' || record.provenance?.host !== 'local')));
+  const stage = stateInfo.status === 'absent' ? 'state-absent'
+    : stateInfo.status !== 'present' || uncertain || owners.limited || owners.status === 'unreadable-or-unsafe' ? 'inspection-required'
+      : !present.length ? 'no-startup-records' : 'records-present-unverified';
+  return { schema: 'workbite.startup-diagnostics.v1', readOnly: true, stage, paths,
+    workbiteHomeSource: environment.WORKBITE_HOME ? 'WORKBITE_HOME' : 'platform-default', state: stateInfo,
+    installation, bootIdentity: validBoot(boot) ? 'available' : 'unavailable',
+    owners: { path: owners.path, status: owners.status, entriesExamined: owners.entriesExamined, limited: owners.limited }, records,
+    limits: { bytesPerRecord: MAX_BYTES, ownerRecords: MAX_OWNERS, directoryEntries: MAX_ENTRIES },
+    limitations: [
+      'Snapshot only: records may change concurrently and NFS visibility may lag. Schema recognition is not authentication or full validation.',
+      'No endpoints are probed. No credential files or log contents are read. Saved ready/selected stages do not prove current health.',
+      'Foreign or unknown host PIDs are never tested locally or declared dead. A local missing PID is an observation, not cleanup authority.',
+      'Local PID existence alone never proves process identity, ownership or safe cleanup. Prior-boot evidence does not authorize deletion.',
+      'Windows boot provenance remains unknown because diagnostics never launches the WMI helper process.',
+      'Install presence is not integrity verification; use workbite check for the existing integrity check.',
+    ],
+    guidance: [NO_DELETE, 'workbite open --no-ui starts or reuses backends only; it does not prove that a terminal UI can open.',
+      'Inspect the selected record paths and private logs locally with credentials redacted; do not publish raw files.',
+      'For native daemon logs, consult log_file and stderr_log_file in the retained native intent locally; untrusted saved paths are not followed here.',
+      'For foreign-host records, inspect the recorded host. If ownership remains unknown, retain the state and seek operator review.',
+      'A pending native intent may have applied already. Reauthenticate the original owner and resolve its operation status; do not replay it.'],
+  };
+}
+async function runDiagnostics(parsed, options = {}) {
+  const report = await inspectStartup(options);
+  report.command = parsed.command;
+  if (parsed.command === 'recover') report.recovery = { dryRun: true, mutated: false, repaired: false,
+    plan: ['Retain the original state and logs; review the diagnostic evidence and limitations.',
+      'Establish the recorded host, boot and authenticated process ownership through operator review before considering any repair.',
+      'Resolve retained native intent with the original owner; do not replay unknown outcomes.',
+      'No automatic recovery action is supported by this command.'], guidance: NO_DELETE };
+  const stdout = options.stdout || process.stdout;
+  if (parsed.json) stdout.write(JSON.stringify(report) + '\n');
+  else {
+    const lines = [`WorkBite ${parsed.command}: ${report.stage} (read-only)`,
+      `WORKBITE_HOME: ${report.paths.workbiteHome} (${report.workbiteHomeSource})`,
+      ...Object.entries(report.paths).filter(([name]) => name !== 'workbiteHome').map(([name, file]) => `${name}: ${file}`),
+      `installation: ${report.installation.status}; integrity not checked (workbite check)`,
+      `owners: ${report.owners.status}; ${report.owners.entriesExamined} entries examined; limited=${report.owners.limited}`,
+      ...report.records.map(record => `${record.kind}: ${record.status}; stage=${record.stage || 'unknown'}; `
+        + `host=${record.provenance?.host || 'unknown'}; boot=${record.provenance?.boot || 'unknown'}; `
+        + `pid=${record.pid ?? 'unknown'} (${record.pidEvidence || 'not-probed'}); ${record.path}`
+        + (record.logHint ? `; log hint=${record.logHint}` : '')),
+      ...report.limitations, ...report.guidance, ...(report.recovery?.plan || [])];
+    stdout.write(lines.join('\n') + '\n');
+  }
+  return { code: 0, signal: null };
+}
+module.exports = { inspectStartup, runDiagnostics };

package/lib/install.js

@@ -2,9 +2,10 @@
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
+const { performance } = require('node:perf_hooks');
 const { LIMITS, fail, memberPath, inside, hashFile, readSmall, exists, safeDirectory, sha256 } = require('./common');
 const { download } = require('./download');
-const { extractArchive, TOP_DIRECTORIES, BUNDLE } = require('./archive');
+const { extractArchive, diagnosticText, TOP_DIRECTORIES, BUNDLE } = require('./archive');
 const packageVersion = require('../package.json').version;
 
 const REPOSITORY = 'Shinick-Han/WorkBite-releases';
@@ -175,7 +176,7 @@ function checkPathBudget(target, bundle, spec) {
 }
 
 // A version directory is published once by rename and never rewritten; reuse revalidates it fully.
-async function ensureInstalled(spec, { apps, downloadImpl = download, extractImpl = extractArchive,
+async function installVersion(spec, { apps, downloadImpl = download, extractImpl = extractArchive,
   checkOnly = false, progress = () => {} } = {}) {
   apps = path.resolve(apps);
   const target = path.join(apps, installName(spec));
@@ -189,6 +190,7 @@ async function ensureInstalled(spec, { apps, downloadImpl = download, extractImp
   if (checkOnly) fail('WorkBite is not installed for this package version; run workbite install.');
   await safeDirectory(apps);
   const staging = await fs.mkdtemp(path.join(apps, '.staging-'));
+  let cleanup = true;
   try {
     const archive = path.join(staging, spec.asset), extraction = path.join(staging, 'payload');
     await fs.mkdir(extraction, { mode: 0o700 });
@@ -210,10 +212,39 @@ async function ensureInstalled(spec, { apps, downloadImpl = download, extractImp
     const installed = await validateBundle(target, spec);
     progress('ready');
     return installed;
+  } catch (error) {
+    if (error.extractionMayBeRunning) cleanup = false;
+    throw error;
   } finally {
     // Only this invocation's mkdtemp staging directory is ever removed.
     if (!inside(apps, staging) || path.dirname(staging) !== apps) fail('Unsafe staging cleanup path');
-    await fs.rm(staging, { recursive: true, force: true });
+    if (cleanup) await fs.rm(staging, { recursive: true, force: true });
+  }
+}
+
+// Keep progress on stderr through the existing reporter; stdout remains the
+// workbite.install.v1 document. Every reuse still performs full hash validation.
+async function ensureInstalled(spec, options = {}) {
+  const apps = path.resolve(options.apps);
+  const target = path.join(apps, installName(spec));
+  const started = performance.now();
+  let verifying, verificationMs = 0;
+  const progress = stage => {
+    const now = performance.now();
+    if (verifying !== undefined) { verificationMs += now - verifying; verifying = undefined; }
+    if (stage === 'validate' || stage === 'validate-published') verifying = now;
+    (options.progress || (() => {}))(stage, { elapsedMs: Math.round(now - started),
+      verificationMs: Math.round(verificationMs), home: target, apps });
+  };
+  try {
+    return await installVersion(spec, { ...options, apps, progress });
+  } catch (error) {
+    const failure = new Error(`${diagnosticText(error.message, 8192)} Installation path: ${diagnosticText(target)} (apps: ${diagnosticText(apps)}); elapsed: ${Math.round(performance.now() - started)} ms.`);
+    for (const key of ['code', 'exitCode', 'signal']) {
+      if (typeof error[key] === 'string') failure[key] = diagnosticText(error[key], 64);
+      else if (error[key] === null || typeof error[key] === 'number') failure[key] = error[key];
+    }
+    throw failure;
   }
 }
 
@@ -227,7 +258,11 @@ function stageReporter(stderr) {
     'validate-published': 'Validating published version...',
     ready: 'Verified WorkBite release is ready.',
   };
-  return stage => stderr.write(`WorkBite: ${messages[stage]}\n`);
+  return (stage, details) => {
+    const timing = stage === 'ready' && details
+      ? ` Elapsed: ${details.elapsedMs} ms; file verification: ${details.verificationMs} ms; home: ${diagnosticText(details.home)}.` : '';
+    stderr.write(`WorkBite: ${messages[stage]}${timing}\n`);
+  };
 }
 
 module.exports = { REPOSITORY, TARGETS, EXECUTABLES, BUNDLE_V1, BUNDLE_V2, ROSTERS, locations, platformTarget, releaseSpec, expectedExecutables,

package/lib/mcp.js

@@ -8,6 +8,7 @@
 // behind the one message in flight, plus one partial line (LIMITS.message) and at most one
 // undelivered input chunk. When that is full stdin is paused (backpressure), never dropped;
 // the next response is not produced until stdout has drained.
+const { archive: validateArchive } = require('./transfer');
 
 const SUPPORTED_VERSIONS = Object.freeze(['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05']);
 const LATEST_VERSION = SUPPORTED_VERSIONS[0];
@@ -16,12 +17,12 @@ const STRUCTURED_SINCE = '2025-06-18', ANNOTATIONS_SINCE = '2025-03-26';
 // Only the 2025-03-26 schema defines JSONRPCBatchRequest ("MUST support receiving JSON-RPC batches").
 // 2024-11-05 defines no batch message and 2025-06-18 removed them, so batches are refused there.
 const BATCH_VERSION = '2025-03-26';
-const LIMITS = Object.freeze({ message: 1024 * 1024, packet: 32768, stdout: 256 * 1024, stderr: 8 * 1024,
+const LIMITS = Object.freeze({ message: 4 * 1024 * 1024, transfer: 1024 * 1024, packet: 32768, stdout: 256 * 1024, stderr: 8 * 1024,
   batch: 16, queue: 16, queueBytes: 4 * 1024 * 1024 });
 const MCP_CONTRACT = 'workbite.mcp.v1', CLI_CONTRACT = 'workstack.cli.v1';
-const WRITES = new Set(['agent.tasks.create', 'agent.tasks.update', 'agent.checkpoint']);
+const WRITES = new Set(['agent.tasks.create', 'agent.tasks.update', 'agent.checkpoint', 'agent.import', 'agent.import-rollback']);
 // Owner error codes the native agent contract publishes; anything else is reported as internal_error.
-const KNOWN_ERRORS = new Set(['action_conflict', 'action_pending', 'backend_mismatch', 'capability_not_enabled',
+const KNOWN_ERRORS = new Set(['action_conflict', 'action_pending', 'backend_mismatch', 'body_too_large', 'transfer_conflict', 'capability_not_enabled',
   'commit_unknown', 'context_too_large', 'generation_changed', 'idempotency_conflict', 'input_unreadable',
   'internal_error', 'invalid_authority', 'invalid_body', 'invalid_receipt', 'invalid_response', 'journal_invalid',
   'journal_unavailable', 'launcher_unavailable', 'not_configured', 'not_found', 'not_sent', 'offline',
@@ -54,7 +55,9 @@ const INSTRUCTIONS = 'WorkBite tools act on the one WorkBite workspace bound whe
   + 'need expected_revision from a fresh read. Calls run one at a time and are never retried automatically. After '
   + 'commit_unknown, first look the SAME intent_id up with workbite_operation_status: continue from a committed '
   + 'receipt; only unknown with reason no_receipt permits one resend with the SAME intent_id and byte-identical '
-  + 'arguments; on any other answer stop and report it.';
+  + 'arguments; on any other answer stop and report it. Task transfer uses workbite_export and workbite_import '
+  + '(dry_run=true previews without writing). Apply needs its preview proofs. For any unknown import or rollback '
+  + 'outcome retain the SAME intent_id and inspect workbite_import_status; never resend a transfer mutation automatically.';
 
 const TASK_ID = { type: 'string', pattern: '^T-[0-9]{4,}$', maxLength: 64, description: 'Explicitly selected Task ID, for example T-0001' };
 const INTENT_ID = { type: 'string', pattern: '^[A-Za-z0-9._:-]{8,128}$',
@@ -63,6 +66,39 @@ const WORKSPACE_UID = { type: 'string', pattern: '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a
   description: 'The bound workspace UID reported by workbite_status' };
 const ITEMS = { type: 'array', maxItems: 20, items: { type: 'string', maxLength: 1000 } };
 const object = (properties, required = []) => ({ type: 'object', additionalProperties: false, properties, required });
+const nullable = schema => ({ anyOf: [schema, { type: 'null' }] });
+const TEXT = { type: 'string', maxLength: 32768 };
+const NONBLANK = { ...TEXT, minLength: 1, pattern: '^[\\s\\S]*\\S[\\s\\S]*$' };
+const NESTED_TEXT = { ...NONBLANK, pattern: '^[^\\u0000]*[^\\u0000\\s][^\\u0000]*$' };
+const DATE = { type: 'string', format: 'date', pattern: '^[0-9]{4}-[0-9]{2}-[0-9]{2}$' };
+const STRINGS = { type: 'array', items: TEXT };
+const TASK_STATUS = { type: 'string', enum: ['open', 'started', 'done', 'dropped'] };
+const PRIORITY = { type: 'string', enum: ['P0', 'P1', 'P2', 'P3'] };
+const SUBTASK_ID = { type: 'string', pattern: '^S-([1-9][0-9]{0,14}|[1-8][0-9]{15}|900[0-6][0-9]{12}|90070[0-9]{11}|90071[0-8][0-9]{10}|900719[0-8][0-9]{9}|9007199[0-1][0-9]{8}|90071992[0-4][0-9]{7}|900719925[0-3][0-9]{6}|9007199254[0-6][0-9]{5}|90071992547[0-3][0-9]{4}|9007199254740[0-8][0-9]{2}|90071992547409[0-8][0-9]{1}|9007199254740990|9007199254740991)$', maxLength: 18,
+  description: 'Parent-scoped display ID with an integer suffix at most 9007199254740991; unique when supplied' };
+const NOTES = { type: 'array', maxItems: 128, items: object({ text: NESTED_TEXT, date: DATE }, ['text']),
+  description: 'Whole-array replacement; [] clears. Missing dates default to the owner current day; supplied dates are note data.' };
+const SUBTASKS = { type: 'array', maxItems: 128, items: object({ title: NESTED_TEXT, id: SUBTASK_ID,
+  priority: { ...PRIORITY, default: 'P2' }, status: { ...TASK_STATUS, default: 'open' } }, ['title']),
+  description: 'Whole-array replacement; [] clears. The owner allocates omitted IDs above existing and supplied IDs. '
+    + 'Subtask status never changes parent Task status.' };
+// Relationship existence, normalization and cycles are checked by the native owner.
+const TASK_FIELDS = {
+  title: NONBLANK, detail: TEXT,
+  status: TASK_STATUS, priority: PRIORITY,
+  due: nullable(DATE), scheduled: nullable(DATE),
+  estimate_minutes: nullable({ type: 'integer', minimum: 1, maximum: 1440 }),
+  tags: STRINGS, parent_id: nullable(TASK_ID), dependencies: STRINGS,
+  objective_ids: STRINGS, notes: NOTES, subtasks: SUBTASKS,
+  key_result_refs: { type: 'array', items: object({ objective_id: { type: 'string', minLength: 1, maxLength: 64 },
+    key_result_id: { type: 'string', minLength: 1, maxLength: 64 } }, ['objective_id', 'key_result_id']) },
+};
+const DIGEST = { type: 'string', pattern: '^sha256:[0-9a-f]{64}$' };
+const ARCHIVE = { type: 'object', additionalProperties: true, properties: {
+  format: { type: 'string', enum: ['workbite.task-transfer.v1'] }, source_workspace_uid: WORKSPACE_UID,
+  source_digest: DIGEST, tasks: { type: 'array', items: { type: 'object', additionalProperties: true, properties: {} } },
+  objectives: { type: 'array', items: { type: 'object', additionalProperties: true, properties: {} } },
+}, required: ['format', 'source_workspace_uid', 'source_digest', 'tasks', 'objectives'] };
 const OUTPUT_SCHEMA = { type: 'object', required: ['contract', 'meta'], properties: {
   contract: { type: 'string', enum: [CLI_CONTRACT, MCP_CONTRACT] }, data: { type: 'object' },
   error: { type: 'object' }, meta: { type: 'object' }, workbite: { type: 'object' } } };
@@ -86,16 +122,14 @@ const TOOLS = [
   { name: 'workbite_tasks_create', command: 'agent.tasks.create', title: 'Create one WorkBite Task', readOnly: false,
     description: 'Create one Task. Durable per intent_id: the SAME intent_id with identical arguments replays the one created Task.',
     inputSchema: object({ workspace_uid: WORKSPACE_UID, intent_id: INTENT_ID,
-      title: { type: 'string', minLength: 1, maxLength: 32768 }, detail: { type: 'string', maxLength: 32768 },
-      follows_task_id: TASK_ID }, ['workspace_uid', 'intent_id', 'title']) },
+      ...TASK_FIELDS,
+      follows_task_id: nullable(TASK_ID) }, ['workspace_uid', 'intent_id', 'title']) },
   { name: 'workbite_tasks_update', command: 'agent.tasks.update', title: 'Update one WorkBite Task', readOnly: false,
-    description: 'Change the detail and/or status of one Task read at expected_revision (compare-and-set). '
+    description: 'Change supported fields of one Task read at expected_revision (compare-and-set). '
       + 'A stale revision is revision_conflict and nothing is written.',
     inputSchema: object({ workspace_uid: WORKSPACE_UID, intent_id: INTENT_ID, task_id: TASK_ID,
-      expected_revision: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
-      changes: { type: 'object', additionalProperties: false, minProperties: 1, properties: {
-        detail: { type: 'string', maxLength: 32768 },
-        status: { type: 'string', enum: ['open', 'started', 'done', 'dropped'] } } } },
+      expected_revision: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER - 1 },
+      changes: { ...object(TASK_FIELDS), minProperties: 1 } },
     ['workspace_uid', 'intent_id', 'task_id', 'expected_revision', 'changes']) },
   { name: 'workbite_checkpoint', command: 'agent.checkpoint', title: 'Append a WorkBite checkpoint', readOnly: false,
     description: 'Append one Daily Review checkpoint to an explicitly selected Task. Idempotent per intent_id.',
@@ -106,22 +140,61 @@ const TOOLS = [
   { name: 'workbite_operation_status', command: 'agent.operation-status', title: 'Look up a WorkBite write receipt',
     readOnly: true, description: 'Read-only lookup of the committed receipt of one intent_id. unknown never means "did not commit".',
     inputSchema: object({ workspace_uid: WORKSPACE_UID, intent_id: INTENT_ID }, ['intent_id']) },
+  { name: 'workbite_export', command: 'agent.export', title: 'Export WorkBite Tasks', readOnly: true,
+    description: 'Read a bounded Task transfer archive from the bound running owner. Full workspace relocation uses official backup/restore.',
+    inputSchema: object({ workspace_uid: WORKSPACE_UID, include_history: { type: 'boolean' }, redact: { type: 'boolean' } }) },
+  { name: 'workbite_import', command: 'agent.import', title: 'Preview or apply a Task transfer', readOnly: false,
+    description: 'Preview with dry_run=true (read-only). Apply with the SAME archive and preview proofs, explicit workspace_uid and stable intent_id. '
+      + 'Unknown outcomes require workbite_import_status; never replay automatically. The owner validates the whole graph atomically.',
+    inputSchema: { ...object({ workspace_uid: WORKSPACE_UID, archive: ARCHIVE,
+      mode: { type: 'string', enum: ['new', 'merge'] }, dry_run: { type: 'boolean' }, preserve_ids: { type: 'boolean' },
+      intent_id: INTENT_ID, plan_digest: DIGEST, expected_snapshot_digest: DIGEST }, ['archive', 'mode', 'dry_run']),
+      allOf: [{ if: { properties: { dry_run: { const: false } } },
+        then: { required: ['workspace_uid', 'intent_id', 'plan_digest', 'expected_snapshot_digest'] },
+        else: { not: { anyOf: [{ required: ['intent_id'] }, { required: ['plan_digest'] }, { required: ['expected_snapshot_digest'] }] } } }] } },
+  { name: 'workbite_import_status', command: 'agent.import-status', title: 'Look up a Task import', readOnly: true,
+    description: 'Read the receipt for the SAME import intent_id. unknown never means not committed.',
+    inputSchema: object({ workspace_uid: WORKSPACE_UID, intent_id: INTENT_ID }, ['intent_id']) },
+  { name: 'workbite_import_rollback', command: 'agent.import-rollback', title: 'Roll back one owned Task import', readOnly: false,
+    description: 'Request rollback of one exact owned import under a fresh snapshot CAS. The owner refuses intervening changes.',
+    inputSchema: object({ workspace_uid: WORKSPACE_UID, intent_id: INTENT_ID, import_id: NONBLANK, expected_snapshot_digest: DIGEST },
+      ['workspace_uid', 'intent_id', 'import_id', 'expected_snapshot_digest']) },
 ];
 const BY_NAME = new Map(TOOLS.map(tool => [tool.name, tool]));
-const PACKET_KEYS = { 'agent.tasks.create': ['title', 'detail', 'follows_task_id'],
+const PACKET_KEYS = { 'agent.tasks.create': [...Object.keys(TASK_FIELDS), 'follows_task_id'],
   'agent.tasks.update': ['task_id', 'expected_revision', 'changes'],
   'agent.checkpoint': ['task_id', 'date', 'done', 'next', 'blockers'] };
 
 const isPlain = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 // The schema subset above, enforced server side; the first violation is reported.
 function violation(value, schema, where) {
-  switch (schema.type) {
+  if (Object.hasOwn(schema, 'const') && value !== schema.const) return `${where} has an invalid constant`;
+  if (schema.anyOf) return schema.anyOf.some(option => !violation(value, option, where)) ? null : `${where} has an invalid value`;
+  if (schema.not && !violation(value, schema.not, where)) return `${where} has forbidden properties`;
+  if (schema.allOf) {
+    for (const rule of schema.allOf) {
+      const problem = violation(value, rule, where);
+      if (problem) return problem;
+    }
+  }
+  if (schema.if) {
+    const branch = violation(value, schema.if, where) ? schema.else : schema.then;
+    if (branch) {
+      const problem = violation(value, branch, where);
+      if (problem) return problem;
+    }
+  }
+  switch (schema.type || (schema.properties || schema.required ? 'object' : undefined)) {
+    case 'null': return value === null ? null : `${where} must be null`;
     case 'object': {
       if (!isPlain(value)) return `${where} must be an object`;
       for (const key of schema.required || []) if (!Object.hasOwn(value, key)) return `${where}.${key} is required`;
       if (Object.keys(value).length < (schema.minProperties || 0)) return `${where} has too few properties`;
       for (const [key, item] of Object.entries(value)) {
-        if (!Object.hasOwn(schema.properties, key)) return `${where} has unknown property ${JSON.stringify(key.slice(0, 64))}`;
+        if (!Object.hasOwn(schema.properties || {}, key)) {
+          if (schema.additionalProperties !== false) continue;
+          return `${where} has unknown property ${JSON.stringify(key.slice(0, 64))}`;
+        }
         const problem = violation(item, schema.properties[key], `${where}.${key}`);
         if (problem) return problem;
       }
@@ -134,6 +207,12 @@ function violation(value, schema, where) {
         const problem = violation(value[index], schema.items, `${where}[${index}]`);
         if (problem) return problem;
       }
+      // JSON Schema uniqueItems compares entire objects; supplied display IDs must be unique even
+      // when the other fields differ. Omitted IDs and defaults remain exclusively owner-assigned.
+      if (schema === SUBTASKS) {
+        const ids = value.filter(item => Object.hasOwn(item, 'id')).map(item => item.id);
+        if (new Set(ids).size !== ids.length) return `${where} has duplicate subtask IDs`;
+      }
       return null;
     }
     case 'integer':
@@ -148,9 +227,15 @@ function violation(value, schema, where) {
       if (length < (schema.minLength || 0) || length > (schema.maxLength ?? Infinity)) return `${where} has an invalid length`;
       if (schema.enum && !schema.enum.includes(value)) return `${where} is not an allowed value`;
       if (schema.pattern && !new RegExp(schema.pattern).test(value)) return `${where} has an invalid format`;
+      if (schema === SUBTASK_ID && (!Number.isSafeInteger(Number(value.slice(2)))
+          || String(Number(value.slice(2))) !== value.slice(2))) return `${where} must be a canonical safe subtask ID`;
+      if (schema.format === 'date') {
+        const date = new Date(`${value}T00:00:00.000Z`);
+        if (!Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== value || value.startsWith('0000-')) return `${where} must be a real ISO calendar date`;
+      }
       return null;
     }
-    default: return `${where} has an unsupported schema`;
+    default: return schema.type === undefined ? null : `${where} has an unsupported schema`;
   }
 }
 
@@ -171,6 +256,21 @@ function nativeRequest(tool, args, uid) {
       if (args.if_fingerprint !== undefined) argv.push(`--if-fingerprint=${args.if_fingerprint}`);
       break;
     case 'agent.operation-status': argv.push(`--intent-id=${args.intent_id}`); break;
+    case 'agent.export':
+      if (args.include_history === true) argv.push('--include-history');
+      if (args.redact === true) argv.push('--redact');
+      break;
+    case 'agent.import':
+      argv.push('--stdin', `--mode=${args.mode}`);
+      if (args.dry_run === true) argv.push('--dry-run');
+      else argv.push(`--intent-id=${args.intent_id}`, `--plan-digest=${args.plan_digest}`, `--expected-snapshot-digest=${args.expected_snapshot_digest}`);
+      if (args.preserve_ids === true) argv.push('--preserve-ids');
+      stdin = JSON.stringify(args.archive);
+      break;
+    case 'agent.import-status': argv.push(`--intent-id=${args.intent_id}`); break;
+    case 'agent.import-rollback':
+      argv.push(`--intent-id=${args.intent_id}`, `--import-id=${args.import_id}`, `--expected-snapshot-digest=${args.expected_snapshot_digest}`);
+      break;
     default: {
       argv.push(`--intent-id=${args.intent_id}`, '--stdin');
       const packet = {};
@@ -194,11 +294,13 @@ function adapterError(command, code, args, extra = {}) {
   if (args && typeof args.task_id === 'string') meta.task_id = args.task_id;
   if (code === 'commit_unknown') meta.commit_state = 'unknown';
   const error = { code, message: MESSAGES[code], retryable: false };
+  if (code === 'commit_unknown' && command.startsWith('agent.import')) error.message =
+    'Transfer outcome is unknown; retain the SAME intent_id and inspect workbite_import_status. Never automatically resend an import or rollback.';
   if (extra.reason) error.details = { reason: extra.reason };
   return { contract: MCP_CONTRACT, error, meta };
 }
-function parseEnvelope(text) {
-  if (typeof text !== 'string' || Buffer.byteLength(text) > LIMITS.stdout || !text.endsWith('\n')
+function parseEnvelope(text, maximum = LIMITS.stdout) {
+  if (typeof text !== 'string' || Buffer.byteLength(text) > maximum || !text.endsWith('\n')
       || text.indexOf('\n') !== text.length - 1) return null;
   try { const value = JSON.parse(text); return isPlain(value) ? value : null; } catch { return null; }
 }
@@ -207,6 +309,7 @@ function bound(envelope, tool, args, uid, success) {
   const meta = envelope.meta;
   if (envelope.contract !== CLI_CONTRACT || !isPlain(meta) || meta.command !== tool.command) return false;
   if (meta.intent_id !== undefined && args.intent_id !== undefined && meta.intent_id !== args.intent_id) return false;
+  if (tool.command.startsWith('agent.import') && args.intent_id !== undefined && success && meta.intent_id !== args.intent_id) return false;
   if (success) return isPlain(envelope.data) && envelope.error === undefined && meta.workspace_uid === uid;
   return isPlain(envelope.error) && typeof envelope.error.code === 'string' && envelope.data === undefined
     && (meta.workspace_uid === undefined || meta.workspace_uid === null || meta.workspace_uid === uid);
@@ -254,11 +357,12 @@ function createServer({ agent, bindOptions, stderr }) {
       return toolResult(adapterError(tool.command, 'workspace_mismatch', args), true);
     }
     const request = nativeRequest(tool, args, target.workspaceUid);
-    if (request.stdin !== undefined && Buffer.byteLength(request.stdin) > LIMITS.packet) {
+    const maximum = tool.command === 'agent.import' ? LIMITS.transfer : LIMITS.packet;
+    if (request.stdin !== undefined && Buffer.byteLength(request.stdin) > maximum) {
       return toolResult(adapterError(tool.command, 'invalid_arguments', null,
-        { reason: `packet exceeds ${LIMITS.packet} bytes` }), true);
+        { reason: `packet exceeds ${maximum} bytes` }), true);
     }
-    const write = WRITES.has(tool.command);
+    const write = WRITES.has(tool.command) && !(tool.command === 'agent.import' && args.dry_run === true);
     let native;
     try {
       native = await agent().executeAgent(target, request.argv, request.stdin === undefined ? {} : { stdin: request.stdin });
@@ -276,7 +380,8 @@ function createServer({ agent, bindOptions, stderr }) {
     const invalid = () => toolResult(adapterError(tool.command, write ? 'commit_unknown' : 'cli_output_invalid', args), true);
     if (!isPlain(native) || ![0, 1, 2].includes(native.code)) return invalid();
     if (typeof native.stderr === 'string' && native.stderr && Buffer.byteLength(native.stderr) > LIMITS.stderr) return invalid();
-    const envelope = parseEnvelope(native.stdout);
+    const envelope = parseEnvelope(native.stdout, tool.command.startsWith('agent.import') || tool.command === 'agent.export'
+      ? LIMITS.transfer + 8192 : LIMITS.stdout);
     if (!envelope) {
       // Exit 2 without an envelope is a usage refusal before any request was admitted.
       if (native.code === 2 && !native.stdout) return toolResult(adapterError(tool.command, 'cli_usage_refused', args), true);
@@ -284,6 +389,12 @@ function createServer({ agent, bindOptions, stderr }) {
     }
     if (!bound(envelope, tool, args, target.workspaceUid, native.code === 0)) return invalid();
     if (native.code === 0) {
+      // Redacting an archive here would invalidate its canonical digest. Refuse an unsafe native archive;
+      // export redaction belongs to the owner, which computes the digest after redacting.
+      if (tool.command === 'agent.export') {
+        try { validateArchive(envelope.data, target.workspaceUid); } catch { return invalid(); }
+        if (JSON.stringify(redact(envelope.data)) !== JSON.stringify(envelope.data)) return invalid();
+      }
       if (tool.command === 'agent.status') {
         envelope.workbite = { workspace: target.workspace, workspace_uid: target.workspaceUid,
           ...(typeof target.endpoint === 'string' ? { endpoint: target.endpoint } : {}) };
@@ -498,4 +609,4 @@ async function runMcp(options = {}) {
   return { code: 0, signal: null };
 }
 
-module.exports = { runMcp, TOOLS, SUPPORTED_VERSIONS, LIMITS, nativeRequest, violation };
+module.exports = { runMcp, TOOLS, SUPPORTED_VERSIONS, LIMITS, nativeRequest, violation, PACKET_KEYS };