@looop-games/cli 0.1.20 → 0.1.22

package/CHANGELOG.md

@@ -14,6 +14,39 @@ Versions: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.22] - 2026-08-01
+
+### Added
+- `looop feedback` now brings the conversation back: after sending your unsent
+  reports, it pulls each report's outcome from the Looop team and stamps it into
+  the report file itself — `status:` / `resolved-in:` in the frontmatter, team
+  messages appended under `## Updates`. The file under `notes/feedback/` is the
+  whole thread, readable offline.
+- You can reply on a report: add a `## Reply (unsent)` section to a sent report
+  file and run `looop feedback` — the reply joins the same thread, and a closed
+  report you reply to is automatically reopened on the Looop side. Reply when
+  something still needs doing; a new problem is a new report.
+- `looop update` now tells you when a report you filed was resolved in one of
+  the versions you just crossed ("Feedback you filed landed in this update"),
+  next to the changelog it already prints.
+
+## [0.1.21] - 2026-07-30
+
+### Added
+
+- **`looop model bake` resolves a pivot for the model.** `<model>.bake.json`
+  may declare `"pivot": "origin"` (default) | `"center"` | `"feet"` |
+  `[x, y, z]` — the model-space point that lands on your entity's
+  `body.(x,y,z)`. The bake resolves it against the bind-pose bounding box,
+  writes it into the skeleton artifact, and measures the broadphase radius
+  about it (a sphere centred on the pivot but measured from the origin could
+  silently reject true edge hits). Every model re-bakes once on your next
+  `looop dev`/`test`/`publish` to pick up the new artifact format; without a
+  `pivot` entry nothing changes in how it plays. Opting into a non-origin
+  pivot needs an engine that reads it (0.1.35+) — run `npx looop update`
+  first, or the room will place the model by its origin while the broadphase
+  is measured about the pivot.
+
 ## [0.1.20] - 2026-07-29
 
 ### Added

package/bin/looop.mjs

@@ -13,6 +13,7 @@ import { lintCmd } from '../lib/lint.mjs';
 import { update } from '../lib/update.mjs';
 import { changelog } from '../lib/changelog.mjs';
 import { sendFeedback } from '../lib/feedback.mjs';
+import { syncFeedback } from '../lib/feedback-sync.mjs';
 import { clearToken } from '../lib/config.mjs';
 
 const [, , cmd, ...rest] = process.argv;
@@ -34,7 +35,7 @@ Usage:
   looop update               Move this game to the latest engine release (re-pins looop.engine)
   looop model bake <glb>     Re-bake a 3D model's server-side hit data now (normally automatic)
   looop publish [--slug <s>]  Publish this game to play.looop.games (--slug for an A/B copy)
-  looop feedback             Send the unsent reports under notes/feedback/ to the Looop team
+  looop feedback             Send reports + replies under notes/feedback/; pull outcomes back in
   looop login                Authenticate this machine as your Looop player account
   looop logout               Forget the stored token
   looop whoami               Show who this machine publishes as
@@ -103,7 +104,10 @@ try {
       await publish({ slug: flag('slug') });
       break;
     case 'feedback':
+      // Send first, then sync: a report filed this run is already stamped with
+      // its id, so the same invocation can pull any outcome waiting for it.
       await sendFeedback();
+      await syncFeedback();
       break;
     case 'login':
       await login();

package/lib/changelog.mjs

@@ -1,4 +1,4 @@
-// `looop changelog` — what changed in the engine (project note azlqm2).
+// `looop changelog` — what changed in the engine.
 //
 // The gap this closes: `looop update` used to say "Engine updated: 0.1.10 →
 // 0.1.12" and then list the SKILL FILES it rewrote. It said nothing about what

package/lib/feedback-sync.mjs

@@ -0,0 +1,232 @@
+// `looop feedback` — the back-channel half. The send half
+// (feedback.mjs) ships reports OUT; this module brings the conversation BACK:
+//
+//   1. Push replies. A report file can carry a `## Reply (unsent)` section —
+//      the agent writes one when something about the outcome still needs
+//      doing. It ships to /api/creator/feedback/reply and the heading is
+//      stamped with the returned fu_ id, so it never ships twice.
+//   2. Fetch outcomes. /api/creator/feedback/status returns, for every report
+//      this account filed: its status (read / done / discarded), the engine
+//      version a fix landed in, and the update thread. Everything is stamped
+//      back INTO the report file — `status:` / `resolved-in:` in frontmatter,
+//      unseen updates appended under `## Updates` — so the file under
+//      notes/feedback/ IS the thread, readable offline by any agent.
+//
+// Idempotency is by fu_ id: every update written into the file carries its
+// `fu_<16 hex>` marker (in an HTML comment, or on a sent-reply heading), and
+// anything whose id already appears in the file is never appended again.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { findProject } from './project.mjs';
+import { getToken, getApiBase } from './config.mjs';
+import { DEFAULT_API_BASE } from './llm-shim.mjs';
+import { discoverSent } from './feedback.mjs';
+import { compareVersions } from './changelog.mjs';
+
+const UPDATE_ID = /fu_[0-9a-f]{16}/g;
+const UNSENT_REPLY = /^## Reply \(unsent\)\s*$/m;
+
+// Every unsent reply section: the text between a `## Reply (unsent)` heading
+// and the next `## ` heading (or EOF). A `## ` line inside a ``` / ~~~ fence
+// is CONTENT, not a boundary — replies quote markdown evidence, and stopping
+// at a fenced heading would ship half the reply and strand the rest under an
+// already-stamped heading where it can never be sent.
+export function extractUnsentReplies(text) {
+  const out = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^## Reply \(unsent\)\s*$/.test(lines[i])) continue;
+    const body = [];
+    let fenced = false;
+    for (let j = i + 1; j < lines.length; j++) {
+      if (/^(```|~~~)/.test(lines[j])) fenced = !fenced;
+      else if (!fenced && /^## /.test(lines[j])) break;
+      body.push(lines[j]);
+    }
+    out.push({ body: body.join('\n').trim() });
+  }
+  return out;
+}
+
+export function knownUpdateIds(text) {
+  return new Set(text.match(UPDATE_ID) ?? []);
+}
+
+// Upsert `status:` / `resolved-in:` into the frontmatter block. The report was
+// stamped `sent:` + `id:` when it shipped, so a synced file always has
+// frontmatter; a file without one is left alone. CRLF files (a Windows clone
+// with autocrlf) get their line endings preserved.
+export function applyStatus(text, { status, resolved_in }) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+  if (!fm) return text;
+  const eol = text.includes('\r\n') ? '\r\n' : '\n';
+  let block = fm[1];
+  const upsert = (key, value) => {
+    if (value == null) return;
+    const line = `${key}: ${value}`;
+    if (new RegExp(`^${key}:.*$`, 'm').test(block)) block = block.replace(new RegExp(`^${key}:[^\\r\\n]*`, 'm'), line);
+    else block = `${block}${eol}${line}`;
+  };
+  upsert('status', status);
+  upsert('resolved-in', resolved_in);
+  return text.slice(0, fm.index) + `---${eol}${block}${eol}---` + text.slice(fm.index + fm[0].length);
+}
+
+// Append unseen thread updates under `## Updates` (created at EOF if missing).
+// Each entry carries its fu_ marker; `knownIds` is what makes re-runs no-ops.
+//
+// The body is written as a BLOCKQUOTE, not raw markdown. That is a protocol
+// necessity, not styling: this file is re-parsed by the reply/section regexes
+// on every sync, so a message that merely QUOTES a heading like "## Reply
+// (unsent)" must not become one — raw injection would ship the team's own
+// words back as a creator reply (reopening the report it arrived on).
+export function appendUpdates(text, updates, knownIds) {
+  const fresh = updates.filter((u) => !knownIds.has(u.id));
+  if (fresh.length === 0) return { text, appended: 0 };
+
+  let entries = '';
+  for (const u of fresh) {
+    const who = u.author === 'creator' ? 'You' : 'Looop';
+    const when = new Date(u.created_at * 1000).toISOString().slice(0, 10);
+    const quoted = u.body.split('\n').map((l) => (l.trim() ? `> ${l}` : '>')).join('\n');
+    entries += `\n### ${who} — ${when} <!-- ${u.id} -->\n\n${quoted}\n`;
+  }
+
+  // New entries go at the END OF THE SECTION, not the end of the file: once a
+  // reply section exists below `## Updates`, appending at EOF would interleave
+  // platform messages under the creator's reply and the thread stops reading
+  // in order.
+  const lines = text.split('\n');
+  const head = lines.findIndex((l) => /^## Updates\s*$/.test(l));
+  if (head === -1) {
+    return { text: `${text.trimEnd()}\n\n## Updates\n${entries}`, appended: fresh.length };
+  }
+  let end = lines.length;
+  for (let j = head + 1; j < lines.length; j++) {
+    if (/^## /.test(lines[j])) { end = j; break; }
+  }
+  const section = lines.slice(0, end).join('\n').trimEnd();
+  const rest = lines.slice(end).join('\n');
+  return {
+    text: `${section}\n${entries}${rest ? `\n${rest}` : ''}`,
+    appended: fresh.length,
+  };
+}
+
+// Which reports landed in the versions an engine update just crossed:
+// (from, to], or everything at/below `to` when no previous pin exists.
+// `status` must still be done — a report reopened after its fix shipped keeps
+// the resolved_in stamp as history, but announcing it as "landed" would claim
+// a fix the reply just said didn't hold.
+export function landedIn(reports, { from, to }) {
+  return reports.filter(
+    (r) =>
+      r.status === 'done' &&
+      r.resolved_in &&
+      compareVersions(r.resolved_in, to) <= 0 &&
+      (!from || compareVersions(r.resolved_in, from) > 0),
+  );
+}
+
+export async function fetchStatus({ apiBase, fetchImpl = fetch }) {
+  const token = getToken();
+  if (!token) throw new Error('reading feedback status requires login — run `looop login` first.');
+  const res = await fetchImpl(`${apiBase}/api/creator/feedback/status`, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (!res.ok) throw new Error(`feedback status fetch failed (HTTP ${res.status})`);
+  const { reports } = await res.json();
+  return Array.isArray(reports) ? reports : [];
+}
+
+async function pushReplies({ path, id, apiBase, fetchImpl, log }) {
+  let text = readFileSync(path, 'utf8');
+  let sent = 0;
+  // One at a time: each stamp rewrites the first unsent heading, so the next
+  // loop iteration sees the next reply (if any) as the new first.
+  while (UNSENT_REPLY.test(text)) {
+    const [reply] = extractUnsentReplies(text);
+    if (!reply?.body) {
+      log(`⚠️  ${basename(path)} has an empty "## Reply (unsent)" section — write the reply, then rerun.`);
+      break;
+    }
+    const token = getToken();
+    const res = await fetchImpl(`${apiBase}/api/creator/feedback/reply`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+      body: JSON.stringify({ id, body: reply.body }),
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => '');
+      throw new Error(`reply send failed for ${basename(path)} (HTTP ${res.status}): ${detail.slice(0, 300)}`);
+    }
+    const { id: updateId } = await res.json();
+    text = text.replace(UNSENT_REPLY, `## Reply (sent ${new Date().toISOString()}, ${updateId})`);
+    writeFileSync(path, text);
+    sent += 1;
+    log(`↩️  Sent your reply on ${basename(path)} → ${updateId}`);
+  }
+  return sent;
+}
+
+// The whole sync: replies out, outcomes in. Fails soft on nothing-to-do (no
+// sent reports → silent no-op, no login needed); fails LOUD on a send error,
+// leaving the reply unsent so the next run retries it.
+export async function syncFeedback({
+  cwd = process.cwd(),
+  apiBase = getApiBase(DEFAULT_API_BASE),
+  log = console.log,
+  fetchImpl = fetch,
+} = {}) {
+  const project = findProject(cwd);
+  const sentFiles = discoverSent(project.dir);
+  if (sentFiles.length === 0) return { replies: 0, updated: [] };
+
+  if (!getToken()) throw new Error('syncing feedback requires login — run `looop login` first.');
+
+  // A failing reply must not rob the OTHER reports of their outcomes: push
+  // everything, stamp everything, and only THEN re-throw the first failure —
+  // loud (so the run is visibly not clean) but after the useful work. The
+  // failed reply's heading is still `(unsent)`, so the next run retries it.
+  let replies = 0;
+  let replyError = null;
+  for (const f of sentFiles) {
+    try {
+      replies += await pushReplies({ ...f, apiBase, fetchImpl, log });
+    } catch (err) {
+      replyError ??= err;
+    }
+  }
+
+  // Fetch-and-stamp is best-effort: the send half already succeeded, and a
+  // platform without the endpoint (or a transient failure) must not turn a
+  // delivered report into an apparent failure. The replies stay loud.
+  let reports;
+  try {
+    reports = await fetchStatus({ apiBase, fetchImpl });
+  } catch (err) {
+    log(`(could not check your reports' outcomes right now — ${err.message} They'll sync on the next run.)`);
+    if (replyError) throw replyError;
+    return { replies, updated: [] };
+  }
+  const byId = new Map(reports.map((r) => [r.id, r]));
+
+  const updated = [];
+  for (const { path, id } of sentFiles) {
+    const report = byId.get(id);
+    if (!report) continue;
+    const before = readFileSync(path, 'utf8');
+    let text = applyStatus(before, report);
+    const { text: withUpdates, appended } = appendUpdates(text, report.updates ?? [], knownUpdateIds(text));
+    text = withUpdates;
+    if (text === before) continue;
+    writeFileSync(path, text);
+    updated.push({ file: path, id, status: report.status, resolved_in: report.resolved_in, newUpdates: appended });
+
+    const landed = report.resolved_in ? ` — landed in ${report.resolved_in}` : '';
+    const news = appended ? ` (+${appended} update${appended === 1 ? '' : 's'})` : '';
+    log(`📬 ${basename(path)}: ${report.status}${landed}${news}`);
+  }
+  if (replyError) throw replyError;
+  return { replies, updated };
+}

package/lib/feedback.mjs

@@ -25,7 +25,10 @@ export const MAX_ATTACHMENTS = 20;
 export const MAX_ATTACHMENT_BYTES = 256 * 1024; // per file
 export const MAX_ATTACHMENTS_BYTES = 1024 * 1024; // all of them together
 
-const frontmatter = (text) => /^---\n([\s\S]*?)\n---/.exec(text)?.[1] ?? '';
+// CRLF-tolerant: a Windows clone with autocrlf rewrites these files, and a
+// frontmatter that stops matching means a sent report reads as unsent and is
+// re-filed on every run.
+const frontmatter = (text) => /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1] ?? '';
 
 // A report is "sent" when its frontmatter carries a `sent:` stamp.
 function isSent(text) {
@@ -128,7 +131,7 @@ function titleOf(text, path) {
 
 function stamp(text, id) {
   const lines = `sent: ${new Date().toISOString()}\nid: ${id}`;
-  if (/^---\n/.test(text)) return text.replace(/^---\n/, `---\n${lines}\n`);
+  if (/^---\r?\n/.test(text)) return text.replace(/^---\r?\n/, (m) => `${m}${lines}\n`);
   return `---\n${lines}\n---\n${text}`;
 }
 
@@ -142,6 +145,21 @@ export function discoverUnsent(projectDir) {
     .sort();
 }
 
+// Delivered reports, with the id the platform stamped into each — what the
+// back-channel (feedback-sync.mjs) replies on and fetches outcomes for.
+export function discoverSent(projectDir) {
+  const dir = join(projectDir, 'notes', 'feedback');
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((name) => name.endsWith('.md'))
+    .map((name) => join(dir, name))
+    .sort()
+    .flatMap((path) => {
+      const id = /^id:\s*(fb_[0-9a-f]{16})\s*$/m.exec(frontmatter(readFileSync(path, 'utf8')))?.[1];
+      return id ? [{ path, id }] : [];
+    });
+}
+
 export async function sendFeedback({
   cwd = process.cwd(),
   apiBase = getApiBase(DEFAULT_API_BASE),

package/lib/model-bake.mjs

@@ -29,8 +29,9 @@
 //   {
 //     "zones": { "head": ["Head", "Neck*"], "arm": ["*_Arm*"] },
 //     "clips": ["fly", "idle"],       // subset to bake; default = all
-//     "generate": "drifter-gen.mjs"   // generator script, relative to the GLB
-//   }
+//     "generate": "drifter-gen.mjs",  // generator script, relative to the GLB
+//     "pivot": "center"               // where body.(x,y,z) sits in the model:
+//   }                                 // "origin" (default) | "center" | "feet" | [x,y,z]
 // Zones use the dominant-bone rule (a triangle belongs to whichever bone most
 // influences its vertices — the same rule the big engines use to size their
 // bone-attached proxy shapes, pointed at triangles). Patterns match bone
@@ -64,7 +65,9 @@ import { pathToFileURL } from 'node:url';
 // meaning — it participates in the staleness hash, so old artifacts re-bake.
 // v2: the staleness hash gained the generator-script component, and skeletons
 // may carry generated additive clips.
-export const BAKE_VERSION = 2;
+// v3: skeletons carry a resolved `pivot`, and the broadphase radius is
+// measured about it instead of the model origin.
+export const BAKE_VERSION = 3;
 
 // ── pure helpers (unit-tested without a browser) ─────────────────────────────
 
@@ -106,6 +109,24 @@ export function boneZonesFromConfig(boneNames, zonesConfig) {
   return { names, byBone };
 }
 
+// Resolve the config's `pivot` — the model-space point that lands ON the
+// entity's body.(x,y,z) — against the bind-pose bounding box. There is no
+// universal right anchor (a flyer wants its centre, a walker its feet, a turret
+// its base), so it's a per-model choice; "origin" reproduces the GLB's own
+// origin and is the default. The resolved vector is written into the skeleton
+// artifact; the runtime composes it into PLACEMENT only, never the inverse
+// bind, so skinning is unaffected.
+export function resolvePivot(pivotCfg, bbox) {
+  if (pivotCfg == null || pivotCfg === 'origin') return [0, 0, 0];
+  const mid = (a) => (bbox.min[a] + bbox.max[a]) / 2;
+  if (pivotCfg === 'center') return [mid(0), mid(1), mid(2)];
+  if (pivotCfg === 'feet') return [mid(0), bbox.min[1], mid(2)];
+  if (Array.isArray(pivotCfg) && pivotCfg.length === 3 && pivotCfg.every((n) => Number.isFinite(n))) {
+    return [pivotCfg[0], pivotCfg[1], pivotCfg[2]];
+  }
+  throw new Error(`"pivot" must be "origin", "center", "feet", or [x, y, z] — got ${JSON.stringify(pivotCfg)}`);
+}
+
 // The dominant bone of a triangle: the bone with the highest summed skin weight
 // across its three vertices. `acc` is scratch sized to the bone count.
 export function dominantBone(skinIndex, skinWeight, influences, index, tri, acc) {
@@ -478,18 +499,44 @@ async function bakeInPage(page, cfg) {
       clips[anim.name] = { duration: anim.duration, tracks };
     }
 
+    // ── pivot: where body.(x,y,z) sits in the model ──────────────────────────
+    // Resolved against the bind-pose bbox of the extracted positions. Mirrors
+    // resolvePivot — this copy runs in-page, because the broadphase radius
+    // below must be measured about the pivot: the runtime centres its sphere on
+    // body, and body IS the pivot point, so a radius measured about the origin
+    // could undersize the sphere and silently reject true edge hits.
+    const bbox = { min: [Infinity, Infinity, Infinity], max: [-Infinity, -Infinity, -Infinity] };
+    for (let i = 0; i < V * 3; i += 3) {
+      for (let a = 0; a < 3; a++) {
+        const c = position[i + a];
+        if (c < bbox.min[a]) bbox.min[a] = c;
+        if (c > bbox.max[a]) bbox.max[a] = c;
+      }
+    }
+    let pivot;
+    {
+      const p = config.pivot;
+      const mid = (a) => (bbox.min[a] + bbox.max[a]) / 2;
+      if (p == null || p === 'origin') pivot = [0, 0, 0];
+      else if (p === 'center') pivot = [mid(0), mid(1), mid(2)];
+      else if (p === 'feet') pivot = [mid(0), bbox.min[1], mid(2)];
+      else if (Array.isArray(p) && p.length === 3 && p.every((n) => Number.isFinite(n))) pivot = [p[0], p[1], p[2]];
+      else return { error: `"pivot" must be "origin", "center", "feet", or [x, y, z] — got ${JSON.stringify(p)}` };
+    }
+
     // ── broadphase radius: worst case across rest + every baked clip ─────────
     // The sphere exists to REJECT cheaply, so it must never reject a true hit:
     // measure every pose the clips can produce, then carry 3% slack (a ray
     // grazing an extremity is near-tangent, and float error then discards a hit
-    // that visibly connects).
+    // that visibly connects). Distances are about the pivot — the sphere's
+    // runtime centre.
     let radius = 0;
     const measure = () => {
       scene.updateMatrixWorld(true);
       sk.skeleton.update?.();
       for (let i = 0; i < V; i++) {
         sk.getVertexPosition(i, v3);
-        const d = Math.hypot(v3.x, v3.y, v3.z);
+        const d = Math.hypot(v3.x - pivot[0], v3.y - pivot[1], v3.z - pivot[2]);
         if (d > radius) radius = d;
       }
     };
@@ -534,6 +581,7 @@ async function bakeInPage(page, cfg) {
     return {
       notes,
       root: { t: [rp.x, rp.y, rp.z], r: [rq.x, rq.y, rq.z, rq.w], s: [rs.x, rs.y, rs.z] },
+      pivot,
       bones: outBones,
       clips,
       mesh: {
@@ -638,6 +686,7 @@ export async function bakeModel(glbPath, { dir = process.cwd(), log = console.lo
 
     const skeletonJson = {
       root: { t: baked.root.t, r: baked.root.r, s: rootS },
+      pivot: baked.pivot,
       bones: baked.bones.map((b) => ({ name: b.name, parent: b.parent, t: b.t, r: b.r, s: b.sAvg })),
       clips: baked.clips,
     };

package/lib/update.mjs

@@ -17,6 +17,7 @@ import { login } from './login.mjs';
 import { DEFAULT_API_BASE } from './llm-shim.mjs';
 import { compareVersions, renderReleases } from './changelog.mjs';
 import { syncCli, reportCli } from './self-update.mjs';
+import { fetchStatus, landedIn } from './feedback-sync.mjs';
 
 // The report is the point. A creator reading this must be able to answer, with
 // no further digging: what changed, was any of it mine, and what do I do now.
@@ -78,7 +79,7 @@ export async function update({
   const { latest, releases } = await res.json();
   if (!latest) throw new Error('the platform has no downloadable engine releases yet.');
 
-  // What the update is about to change UNDER the game (project note azlqm2).
+  // What the update is about to change UNDER the game.
   // Reporting the skill files we rewrote and nothing about the engine was the
   // whole gap: an agent crossed two versions of the shared library blind.
   //
@@ -172,6 +173,19 @@ export async function update({
     reportCli(log, cli);
   }
 
+  // Feedback this repo filed that a crossed release resolved. Best-effort on
+  // purpose: the back-channel must never block or fail an engine update, so
+  // any error here (an older platform without the endpoint, offline after the
+  // download, a bad response) reduces to "no landings to report".
+  let landed = [];
+  if (updated) {
+    try {
+      landed = landedIn(await fetchStatus({ apiBase, fetchImpl }), { from, to: latest });
+    } catch {
+      landed = [];
+    }
+  }
+
   if (updated) {
     log('');
     if (crossed === null) {
@@ -180,8 +194,14 @@ export async function update({
     } else if (crossed.length) {
       log(renderReleases(crossed, { pinned: from, latest }));
     }
+    if (landed.length) {
+      log('');
+      log('   Feedback you filed landed in this update:');
+      for (const r of landed) log(`   • "${r.title}" — resolved in ${r.resolved_in}`);
+      log('   Run `npx looop feedback` to pull the details into notes/feedback/.');
+    }
     log('');
     log('   Republish (`npx looop publish`) when you want the live game on it.');
   }
-  return { from, to: latest, updated, surface, crossed, cli };
+  return { from, to: latest, updated, surface, crossed, cli, landed };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looop-games/cli",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Looop game development CLI — dev server, login, and publishing for standalone Looop games.",
   "type": "module",
   "license": "Apache-2.0",