infernoflow 0.33.0 → 0.34.0

package/dist/lib/commands/teamSync.mjs

@@ -1,2 +1,388 @@
-import*as g from"node:fs";import*as N from"node:path";import{execSync as A}from"node:child_process";import{header as L,ok as j,warn as S,info as F,done as B,bold as m,cyan as b,gray as C,red as _,yellow as P}from"../ui/output.mjs";function x(t,n){try{return A(t,{cwd:n,encoding:"utf8",stdio:["ignore","pipe","pipe"]}).trim()}catch{return null}}function p(t,n){A(t,{cwd:n,encoding:"utf8",stdio:["ignore","pipe","pipe"]})}function R(t){return x("git rev-parse --abbrev-ref HEAD",t)||"HEAD"}function E(t){return x("git config user.name",t)||x("git config user.email",t)||"unknown"}function H(t,n){return!!x(`git remote get-url ${t}`,n)}function I(t,n,e){return!!x(`git ls-remote --heads ${t} refs/heads/${n}`,e)}function v(t){if(!t)return[];try{return(JSON.parse(t).capabilities||[]).map(s=>typeof s=="string"?{id:s,title:s}:s)}catch{return[]}}function w(t){return new Map(t.map(n=>[n.id,n]))}function D(t,n,e){const s=w(t),c=w(n),d=w(e),i=[],o=[],l=[],f=new Set([...s.keys(),...c.keys(),...d.keys()]);for(const u of f){const h=s.get(u),y=c.get(u),r=d.get(u),$=JSON.stringify(h)!==JSON.stringify(r),O=JSON.stringify(y)!==JSON.stringify(r);$&&O&&JSON.stringify(h)!==JSON.stringify(y)?i.push({id:u,local:h,shared:y,base:r}):h&&!y&&!r?o.push(h):!h&&y&&!r&&l.push(y)}return{conflicts:i,localOnly:o,sharedOnly:l}}function M(t,n,e){try{p(`git fetch ${t} ${n} --quiet`,e)}catch{}const s=x(`git show ${t}/${n}:inferno/contract.json`,e);if(!s)return null;try{return JSON.parse(s)}catch{return null}}function T(t){const n=N.join(t,".team-sync-base.json");if(!g.existsSync(n))return null;try{return JSON.parse(g.readFileSync(n,"utf8"))}catch{return null}}function q(t,n){const e=N.join(t,".team-sync-base.json");g.writeFileSync(e,JSON.stringify(n,null,2),"utf8")}function U(t,n,e,s,c){if(!H(n,t)){const o=`Remote "${n}" not found. Add it first: git remote add ${n} <url>`;c&&(console.log(JSON.stringify({ok:!1,error:o})),process.exit(1)),S(o),process.exit(1)}if(I(n,e,t)){c?console.log(JSON.stringify({ok:!0,action:"already_exists",branch:e})):j(`Shared branch ${m(e)} already exists on ${n}`);return}const d=N.join(s,"contract.json");if(!g.existsSync(d)){const o="inferno/contract.json not found \u2014 run: infernoflow init";c&&(console.log(JSON.stringify({ok:!1,error:o})),process.exit(1)),S(o),process.exit(1)}const i=N.join(s,".team-sync-tmp");try{g.mkdirSync(i,{recursive:!0});const o=g.readFileSync(d,"utf8");g.writeFileSync(N.join(i,"contract.json"),o),p(`git checkout --orphan ${e}`,t),p("git rm -rf . --quiet 2>/dev/null || true",t),p(`git checkout ${R(t)} -- inferno/contract.json`,t),p("git add inferno/contract.json",t),p('git commit -m "infernoflow: initialize shared contract branch"',t),p(`git push ${n} ${e}`,t),p("git checkout -",t)}catch(o){try{p("git checkout -",t)}catch{}const l=`Failed to create shared branch: ${o.message}`;c&&(console.log(JSON.stringify({ok:!1,error:l})),process.exit(1)),S(l),process.exit(1)}finally{try{g.rmSync(i,{recursive:!0})}catch{}}c?console.log(JSON.stringify({ok:!0,action:"created",branch:e,remote:n})):B(`Shared branch ${m(e)} created on ${m(n)}`)}function z(t,n,e,s,c,d){const i=N.join(s,"contract.json");if(!g.existsSync(i)){const f="inferno/contract.json not found";c&&(console.log(JSON.stringify({ok:!1,error:f})),process.exit(1)),S(f),process.exit(1)}const o=JSON.parse(g.readFileSync(i,"utf8")),l=E(t);o._teamSync={pushedBy:l,pushedAt:new Date().toISOString(),fromBranch:R(t)},g.writeFileSync(i,JSON.stringify(o,null,2),"utf8");try{p(`git fetch ${n} ${e} --quiet`,t),x("git stash --quiet",t);try{p(`git checkout ${n}/${e} -- inferno/contract.json 2>/dev/null || git checkout ${n}/${e} inferno/contract.json`,t)}catch{}x("git stash pop --quiet",t),g.writeFileSync(i,JSON.stringify(o,null,2),"utf8"),p("git add inferno/contract.json",t),p(`git commit -m "infernoflow team-sync: push by ${l}"`,t),p(`git push ${n} HEAD:${e}`,t),q(s,o),c?console.log(JSON.stringify({ok:!0,action:"pushed",remote:n,branch:e,user:l})):B(`Contract pushed to ${m(n+"/"+e)} by ${m(l)}`)}catch(f){const u=`Push failed: ${f.message}`;c&&(console.log(JSON.stringify({ok:!1,error:u})),process.exit(1)),S(u),F(`Try: git push ${n} HEAD:${e} --force  (use --force flag)`),process.exit(1)}}function W(t,n,e,s,c,d){const i=N.join(s,"contract.json"),o=M(n,e,t);if(!o){const k=`Could not read contract from ${n}/${e}. Run: infernoflow team-sync init`;c&&(console.log(JSON.stringify({ok:!1,error:k})),process.exit(1)),S(k),process.exit(1)}const l=g.existsSync(i)?JSON.parse(g.readFileSync(i,"utf8")):{capabilities:[]},f=T(s)||{capabilities:[]},u=v(JSON.stringify(l)),h=v(JSON.stringify(o)),y=v(JSON.stringify(f)),{conflicts:r,localOnly:$,sharedOnly:O}=D(u,h,y);if(r.length>0&&!d){c&&(console.log(JSON.stringify({ok:!1,error:"conflicts_detected",conflicts:r,hint:"Use --force to overwrite with remote version"})),process.exit(1)),S(`${r.length} capability conflict${r.length!==1?"s":""} detected:
-`);for(const k of r)console.log(`  ${_("\u2717")} ${m(k.id)}`),console.log(`      local:  ${C(k.local?.title||"(removed)")}`),console.log(`      shared: ${C(k.shared?.title||"(removed)")}`);console.log(),S("Resolve conflicts manually or use --force to take the shared version"),process.exit(1)}const J={...o},a=[...h];for(const k of $)a.push(k);J.capabilities=a,delete J._teamSync,g.writeFileSync(i,JSON.stringify(J,null,2),"utf8"),q(s,J),c?console.log(JSON.stringify({ok:!0,action:"pulled",remote:n,branch:e,conflicts:r.length,localOnly:$.length,sharedOnly:O.length})):(console.log(),j("Contract updated from shared branch"),r.length>0&&S(`${r.length} conflict(s) resolved with --force (shared version wins)`),$.length>0&&j(`${$.length} local capability(-ies) preserved`),O.length>0&&j(`${O.length} new capability(-ies) pulled from shared`),r.length===0&&$.length===0&&O.length===0&&F("Already in sync \u2014 no changes"),console.log())}function G(t,n,e,s,c){const d=N.join(s,"contract.json");try{p(`git fetch ${n} ${e} --quiet`,t)}catch{}const i=M(n,e,t);if(!i){const a=`Shared branch ${n}/${e} not found. Run: infernoflow team-sync init`;c&&(console.log(JSON.stringify({ok:!1,error:a})),process.exit(1)),S(a),process.exit(1)}const o=g.existsSync(d)?JSON.parse(g.readFileSync(d,"utf8")):{capabilities:[]},l=v(JSON.stringify(o)),f=v(JSON.stringify(i)),u=w(l),h=w(f),y=l.filter(a=>!h.has(a.id)),r=f.filter(a=>!u.has(a.id)),$=y.length===0&&r.length===0,O=i._teamSync?.pushedBy||"unknown",J=i._teamSync?.pushedAt||"unknown";if(c){console.log(JSON.stringify({ok:!0,inSync:$,local:l.length,shared:f.length,onlyLocal:y.map(a=>a.id),onlyShared:r.map(a=>a.id),lastPush:{by:O,at:J}}));return}if(console.log(),console.log(`  Shared branch  ${m(b(n+"/"+e))}`),console.log(`  Last push      ${m(O)}  ${C(J.slice(0,19).replace("T"," "))}`),console.log(),$)j("Local and shared contracts are in sync");else{if(y.length){console.log(`  ${P("\u2192")} ${m(y.length)} local capability(-ies) not yet pushed:`);for(const a of y)console.log(`    ${P("+")} ${a.id}  ${C(a.title)}`)}if(r.length){console.log(`  ${b("\u2190")} ${m(r.length)} shared capability(-ies) not yet pulled:`);for(const a of r)console.log(`    ${b("+")} ${a.id}  ${C(a.title)}`)}console.log(),y.length&&F(`Run ${b("infernoflow team-sync push")} to share your changes`),r.length&&F(`Run ${b("infernoflow team-sync pull")} to get team changes`)}console.log()}async function X(t){const n=t.slice(1),e=n.includes("--json"),s=n.includes("--force"),c=n.indexOf("--branch"),d=n.indexOf("--remote"),i=c!==-1?n[c+1]:"inferno-contracts",o=d!==-1?n[d+1]:"origin",l=n.find(h=>!h.startsWith("-"))||"status",f=process.cwd(),u=N.join(f,"inferno");if(e||L("infernoflow team-sync"),!g.existsSync(u)){const h="inferno/ not found \u2014 run: infernoflow init";e&&(console.log(JSON.stringify({ok:!1,error:h})),process.exit(1)),S(h),process.exit(1)}switch(l){case"init":U(f,o,i,u,e);break;case"push":z(f,o,i,u,e,s);break;case"pull":W(f,o,i,u,e,s);break;default:G(f,o,i,u,e);break}}export{X as teamSyncCommand};
+/**
+ * infernoflow team-sync
+ *
+ * Shared capability contract sync across a team.
+ * Uses a dedicated git branch (`inferno-contracts`) as the source of truth.
+ *
+ * Sub-commands:
+ *   infernoflow team-sync push      — push local contract to shared branch
+ *   infernoflow team-sync pull      — pull shared contract, detect conflicts
+ *   infernoflow team-sync status    — show diff between local and shared
+ *   infernoflow team-sync init      — create the shared branch if it doesn't exist
+ *
+ * Flags:
+ *   --branch <name>   Shared branch name (default: inferno-contracts)
+ *   --remote <name>   Git remote (default: origin)
+ *   --json            Machine-readable output
+ *   --force           Overwrite conflicts without prompting
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { header, ok, warn, info, done, bold, cyan, gray, green, red, yellow } from "../ui/output.mjs";
+
+// ── git helpers ───────────────────────────────────────────────────────────────
+
+function capture(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch { return null; }
+}
+
+function run(cmd, cwd) {
+  execSync(cmd, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+
+function currentBranch(cwd) {
+  return capture("git rev-parse --abbrev-ref HEAD", cwd) || "HEAD";
+}
+
+function currentUser(cwd) {
+  return capture("git config user.name", cwd) || capture("git config user.email", cwd) || "unknown";
+}
+
+function hasRemote(remote, cwd) {
+  return !!capture(`git remote get-url ${remote}`, cwd);
+}
+
+function branchExistsRemote(remote, branch, cwd) {
+  return !!capture(`git ls-remote --heads ${remote} refs/heads/${branch}`, cwd);
+}
+
+// ── capability helpers ────────────────────────────────────────────────────────
+
+function parseCaps(jsonText) {
+  if (!jsonText) return [];
+  try {
+    const obj = JSON.parse(jsonText);
+    const raw = obj.capabilities || [];
+    return raw.map(c => typeof c === "string" ? { id: c, title: c } : c);
+  } catch { return []; }
+}
+
+function capsToMap(caps) {
+  return new Map(caps.map(c => [c.id, c]));
+}
+
+function detectConflicts(local, shared, base) {
+  // A conflict occurs when BOTH local and shared changed the same capability
+  // since the last sync (base).
+  const localMap  = capsToMap(local);
+  const sharedMap = capsToMap(shared);
+  const baseMap   = capsToMap(base);
+
+  const conflicts = [];
+  const localOnly = [];
+  const sharedOnly = [];
+
+  const allIds = new Set([...localMap.keys(), ...sharedMap.keys(), ...baseMap.keys()]);
+
+  for (const id of allIds) {
+    const localCap  = localMap.get(id);
+    const sharedCap = sharedMap.get(id);
+    const baseCap   = baseMap.get(id);
+
+    const localChanged  = JSON.stringify(localCap)  !== JSON.stringify(baseCap);
+    const sharedChanged = JSON.stringify(sharedCap) !== JSON.stringify(baseCap);
+
+    if (localChanged && sharedChanged && JSON.stringify(localCap) !== JSON.stringify(sharedCap)) {
+      conflicts.push({ id, local: localCap, shared: sharedCap, base: baseCap });
+    } else if (localCap && !sharedCap && !baseCap) {
+      localOnly.push(localCap);    // added locally, not in shared yet
+    } else if (!localCap && sharedCap && !baseCap) {
+      sharedOnly.push(sharedCap); // added in shared, not locally yet
+    }
+  }
+
+  return { conflicts, localOnly, sharedOnly };
+}
+
+// ── shared branch operations ──────────────────────────────────────────────────
+
+function readContractFromBranch(remote, branch, cwd) {
+  // Fetch the branch first
+  try { run(`git fetch ${remote} ${branch} --quiet`, cwd); } catch {}
+
+  const content = capture(`git show ${remote}/${branch}:inferno/contract.json`, cwd);
+  if (!content) return null;
+  try { return JSON.parse(content); } catch { return null; }
+}
+
+function readLastSyncBase(infernoDir) {
+  const basePath = path.join(infernoDir, ".team-sync-base.json");
+  if (!fs.existsSync(basePath)) return null;
+  try { return JSON.parse(fs.readFileSync(basePath, "utf8")); } catch { return null; }
+}
+
+function writeLastSyncBase(infernoDir, contract) {
+  const basePath = path.join(infernoDir, ".team-sync-base.json");
+  fs.writeFileSync(basePath, JSON.stringify(contract, null, 2), "utf8");
+}
+
+// ── sub-commands ──────────────────────────────────────────────────────────────
+
+function initSharedBranch(cwd, remote, branch, infernoDir, asJson) {
+  if (!hasRemote(remote, cwd)) {
+    const msg = `Remote "${remote}" not found. Add it first: git remote add ${remote} <url>`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  if (branchExistsRemote(remote, branch, cwd)) {
+    if (asJson) { console.log(JSON.stringify({ ok: true, action: "already_exists", branch })); }
+    else { ok(`Shared branch ${bold(branch)} already exists on ${remote}`); }
+    return;
+  }
+
+  // Create orphan branch with just the contract
+  const contractPath = path.join(infernoDir, "contract.json");
+  if (!fs.existsSync(contractPath)) {
+    const msg = "inferno/contract.json not found — run: infernoflow init";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  // Use a temp worktree approach: push contract.json to the branch
+  const tmpDir = path.join(infernoDir, ".team-sync-tmp");
+  try {
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const contractContent = fs.readFileSync(contractPath, "utf8");
+    fs.writeFileSync(path.join(tmpDir, "contract.json"), contractContent);
+
+    // Create an empty tree commit on the shared branch
+    run(`git checkout --orphan ${branch}`, cwd);
+    run(`git rm -rf . --quiet 2>/dev/null || true`, cwd);
+    run(`git checkout ${currentBranch(cwd)} -- inferno/contract.json`, cwd);
+    run(`git add inferno/contract.json`, cwd);
+    run(`git commit -m "infernoflow: initialize shared contract branch"`, cwd);
+    run(`git push ${remote} ${branch}`, cwd);
+    run(`git checkout -`, cwd); // back to previous branch
+  } catch (err) {
+    // Restore original branch on failure
+    try { run(`git checkout -`, cwd); } catch {}
+    const msg = `Failed to create shared branch: ${err.message}`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true }); } catch {}
+  }
+
+  if (asJson) { console.log(JSON.stringify({ ok: true, action: "created", branch, remote })); }
+  else { done(`Shared branch ${bold(branch)} created on ${bold(remote)}`); }
+}
+
+function pushToShared(cwd, remote, branch, infernoDir, asJson, force) {
+  const contractPath = path.join(infernoDir, "contract.json");
+  if (!fs.existsSync(contractPath)) {
+    const msg = "inferno/contract.json not found";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const localContract = JSON.parse(fs.readFileSync(contractPath, "utf8"));
+  const user          = currentUser(cwd);
+
+  // Stamp the push metadata
+  localContract._teamSync = {
+    pushedBy:  user,
+    pushedAt:  new Date().toISOString(),
+    fromBranch: currentBranch(cwd),
+  };
+
+  // Write updated contract
+  fs.writeFileSync(contractPath, JSON.stringify(localContract, null, 2), "utf8");
+
+  // Commit + push to shared branch
+  try {
+    run(`git fetch ${remote} ${branch} --quiet`, cwd);
+    // Use a temporary stash-push approach: push just the contract file
+    capture(`git stash --quiet`, cwd);
+    try {
+      run(`git checkout ${remote}/${branch} -- inferno/contract.json 2>/dev/null || git checkout ${remote}/${branch} inferno/contract.json`, cwd);
+    } catch {}
+    capture(`git stash pop --quiet`, cwd);
+
+    // Write the updated content
+    fs.writeFileSync(contractPath, JSON.stringify(localContract, null, 2), "utf8");
+    run(`git add inferno/contract.json`, cwd);
+    run(`git commit -m "infernoflow team-sync: push by ${user}"`, cwd);
+    run(`git push ${remote} HEAD:${branch}`, cwd);
+
+    // Save base snapshot
+    writeLastSyncBase(infernoDir, localContract);
+
+    if (asJson) { console.log(JSON.stringify({ ok: true, action: "pushed", remote, branch, user })); }
+    else { done(`Contract pushed to ${bold(remote + "/" + branch)} by ${bold(user)}`); }
+  } catch (err) {
+    const msg = `Push failed: ${err.message}`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg);
+    info(`Try: git push ${remote} HEAD:${branch} --force  (use --force flag)`);
+    process.exit(1);
+  }
+}
+
+function pullFromShared(cwd, remote, branch, infernoDir, asJson, force) {
+  const contractPath = path.join(infernoDir, "contract.json");
+
+  // Fetch remote contract
+  const sharedContract = readContractFromBranch(remote, branch, cwd);
+  if (!sharedContract) {
+    const msg = `Could not read contract from ${remote}/${branch}. Run: infernoflow team-sync init`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const localContract = fs.existsSync(contractPath)
+    ? JSON.parse(fs.readFileSync(contractPath, "utf8")) : { capabilities: [] };
+
+  const baseContract = readLastSyncBase(infernoDir) || { capabilities: [] };
+
+  const localCaps  = parseCaps(JSON.stringify(localContract));
+  const sharedCaps = parseCaps(JSON.stringify(sharedContract));
+  const baseCaps   = parseCaps(JSON.stringify(baseContract));
+
+  const { conflicts, localOnly, sharedOnly } = detectConflicts(localCaps, sharedCaps, baseCaps);
+
+  if (conflicts.length > 0 && !force) {
+    if (asJson) {
+      console.log(JSON.stringify({ ok: false, error: "conflicts_detected", conflicts, hint: "Use --force to overwrite with remote version" }));
+      process.exit(1);
+    }
+    warn(`${conflicts.length} capability conflict${conflicts.length !== 1 ? "s" : ""} detected:\n`);
+    for (const c of conflicts) {
+      console.log(`  ${red("✗")} ${bold(c.id)}`);
+      console.log(`      local:  ${gray(c.local?.title || "(removed)")}`);
+      console.log(`      shared: ${gray(c.shared?.title || "(removed)")}`);
+    }
+    console.log();
+    warn("Resolve conflicts manually or use --force to take the shared version");
+    process.exit(1);
+  }
+
+  // Merge: take shared as base, apply localOnly additions
+  const merged = { ...sharedContract };
+  const mergedCaps = [...sharedCaps];
+  for (const cap of localOnly) mergedCaps.push(cap);
+  merged.capabilities = mergedCaps;
+  delete merged._teamSync;
+
+  fs.writeFileSync(contractPath, JSON.stringify(merged, null, 2), "utf8");
+  writeLastSyncBase(infernoDir, merged);
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true, action: "pulled", remote, branch,
+      conflicts: conflicts.length,
+      localOnly: localOnly.length,
+      sharedOnly: sharedOnly.length,
+    }));
+  } else {
+    console.log();
+    ok("Contract updated from shared branch");
+    if (conflicts.length > 0) warn(`${conflicts.length} conflict(s) resolved with --force (shared version wins)`);
+    if (localOnly.length  > 0) ok(`${localOnly.length} local capability(-ies) preserved`);
+    if (sharedOnly.length > 0) ok(`${sharedOnly.length} new capability(-ies) pulled from shared`);
+    if (conflicts.length === 0 && localOnly.length === 0 && sharedOnly.length === 0) {
+      info("Already in sync — no changes");
+    }
+    console.log();
+  }
+}
+
+function showStatus(cwd, remote, branch, infernoDir, asJson) {
+  const contractPath = path.join(infernoDir, "contract.json");
+
+  try { run(`git fetch ${remote} ${branch} --quiet`, cwd); } catch {}
+
+  const sharedContract = readContractFromBranch(remote, branch, cwd);
+  if (!sharedContract) {
+    const msg = `Shared branch ${remote}/${branch} not found. Run: infernoflow team-sync init`;
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  const localContract = fs.existsSync(contractPath)
+    ? JSON.parse(fs.readFileSync(contractPath, "utf8")) : { capabilities: [] };
+
+  const localCaps  = parseCaps(JSON.stringify(localContract));
+  const sharedCaps = parseCaps(JSON.stringify(sharedContract));
+
+  const localMap  = capsToMap(localCaps);
+  const sharedMap = capsToMap(sharedCaps);
+
+  const onlyLocal  = localCaps.filter(c => !sharedMap.has(c.id));
+  const onlyShared = sharedCaps.filter(c => !localMap.has(c.id));
+  const inSync     = onlyLocal.length === 0 && onlyShared.length === 0;
+  const pushedBy   = sharedContract._teamSync?.pushedBy || "unknown";
+  const pushedAt   = sharedContract._teamSync?.pushedAt || "unknown";
+
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true, inSync,
+      local: localCaps.length, shared: sharedCaps.length,
+      onlyLocal: onlyLocal.map(c => c.id),
+      onlyShared: onlyShared.map(c => c.id),
+      lastPush: { by: pushedBy, at: pushedAt },
+    }));
+    return;
+  }
+
+  console.log();
+  console.log(`  Shared branch  ${bold(cyan(remote + "/" + branch))}`);
+  console.log(`  Last push      ${bold(pushedBy)}  ${gray(pushedAt.slice(0, 19).replace("T", " "))}`);
+  console.log();
+
+  if (inSync) {
+    ok("Local and shared contracts are in sync");
+  } else {
+    if (onlyLocal.length) {
+      console.log(`  ${yellow("→")} ${bold(onlyLocal.length)} local capability(-ies) not yet pushed:`);
+      for (const c of onlyLocal) console.log(`    ${yellow("+")} ${c.id}  ${gray(c.title)}`);
+    }
+    if (onlyShared.length) {
+      console.log(`  ${cyan("←")} ${bold(onlyShared.length)} shared capability(-ies) not yet pulled:`);
+      for (const c of onlyShared) console.log(`    ${cyan("+")} ${c.id}  ${gray(c.title)}`);
+    }
+    console.log();
+    if (onlyLocal.length)  info(`Run ${cyan("infernoflow team-sync push")} to share your changes`);
+    if (onlyShared.length) info(`Run ${cyan("infernoflow team-sync pull")} to get team changes`);
+  }
+
+  console.log();
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+export async function teamSyncCommand(rawArgs) {
+  const args   = rawArgs.slice(1);
+  const asJson = args.includes("--json");
+  const force  = args.includes("--force");
+
+  const branchIdx = args.indexOf("--branch");
+  const remoteIdx = args.indexOf("--remote");
+  const branch = branchIdx !== -1 ? args[branchIdx + 1] : "inferno-contracts";
+  const remote = remoteIdx !== -1 ? args[remoteIdx + 1] : "origin";
+
+  const sub = args.find(a => !a.startsWith("-")) || "status";
+
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!asJson) header("infernoflow team-sync");
+
+  if (!fs.existsSync(infernoDir)) {
+    const msg = "inferno/ not found — run: infernoflow init";
+    if (asJson) { console.log(JSON.stringify({ ok: false, error: msg })); process.exit(1); }
+    warn(msg); process.exit(1);
+  }
+
+  switch (sub) {
+    case "init":   initSharedBranch(cwd, remote, branch, infernoDir, asJson); break;
+    case "push":   pushToShared(cwd, remote, branch, infernoDir, asJson, force); break;
+    case "pull":   pullFromShared(cwd, remote, branch, infernoDir, asJson, force); break;
+    case "status":
+    default:       showStatus(cwd, remote, branch, infernoDir, asJson); break;
+  }
+}