@lotics/cli 0.76.1 → 0.83.0

package/dist/src/cli.js

@@ -29709,15 +29709,6 @@ var LoticsClient = class {
   async listWorkspaces() {
     return this.request("GET", "/v1/workspaces");
   }
-  /**
-   * Resolve one workspace's info by id from the org's workspace list (the only
-   * API-key-accessible source carrying `is_dev`). Returns null when the
-   * workspace isn't visible to these credentials.
-   */
-  async getWorkspaceInfo(id) {
-    const workspaces = await this.listWorkspaces();
-    return workspaces.find((w) => w.id === id) ?? null;
-  }
   async createWorkspace(body) {
     return this.request("POST", "/v1/workspaces", body);
   }
@@ -29785,7 +29776,7 @@ var LoticsClient = class {
   /**
    * Uninstall a standalone content package — delete the installation row. By
    * default the package-bound docs are ARCHIVED; `keep_content` retains them as
-   * ordinary workspace docs. Admin-only. Backs `lotics package uninstall`.
+   * ordinary workspace docs. Admin-only. Backs `lotics uninstall`.
    */
   async uninstallContentPackage(installation_id, opts = {}) {
     const qs = opts.keep_content ? "?keep_content=true" : "";
@@ -29833,7 +29824,7 @@ var LoticsClient = class {
     );
   }
   /**
-   * Uninstall a package installation (backs `lotics package uninstall`). Does
+   * Uninstall a package installation (backs `lotics uninstall`). Does
    * everything DELETE does plus archives the installation's lifecycle
    * artifacts; with `archive_tables` it also archives the scaffolded entity
    * tables — refused server-side unless this installation created them
@@ -29851,10 +29842,11 @@ var LoticsClient = class {
     return this.request("PATCH", `/v1/apps/${encodeURIComponent(app_id)}/package-config`, body);
   }
   /**
-   * Retire (or `undo` un-retire) a registry package (backs `lotics package
-   * retire`). Retiring refuses NEW installs and hides the package from
-   * non-owning orgs; existing installations keep working and may still upgrade.
-   * Owner-org admin-only.
+   * Retire (or `undo` un-retire) a registry package (backs `lotics app
+   * unpublish` — the endpoint/audit action keep the `retire` name to avoid API
+   * churn). Retiring refuses NEW installs and hides the package from non-owning
+   * orgs; existing installations keep working and may still upgrade. Owner-org
+   * admin-only.
    */
   async retirePackage(package_id, body) {
     return this.request("POST", `/v1/packages/${encodeURIComponent(package_id)}/retire`, body);
@@ -29869,38 +29861,12 @@ var LoticsClient = class {
   async ejectPackage(app_id) {
     return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/eject`);
   }
-  /**
-   * Extract a DRAFT app package from an existing bespoke app — the promotion
-   * read (docs/packages.md § Promotion). Pure: nothing is written. Returns
-   * the alias-keyed draft `contract` (opaque to the CLI — the server is the
-   * validating authority), the origin workspace's `binding` (which doubles as
-   * the adopt binding), a findings `report` (any `error` ⇒ not publishable
-   * as-is), and the file-backed `template_files` the CLI must stage into the
-   * project at their `bytes_ref` paths. Backs `lotics package extract`.
-   * Admin-only.
-   */
-  async extractPackage(app_id, opts = {}) {
-    const qs = opts.knowledge && opts.knowledge.length > 0 ? `?knowledge=${encodeURIComponent(JSON.stringify(opts.knowledge))}` : "";
-    return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/package-extract${qs}`);
-  }
-  /**
-   * Adopt a published package onto an EXISTING (bespoke or ejected) app — the
-   * final promotion step. The workspace already holds the concrete objects, so
-   * nothing is scaffolded or rewritten: the server verifies the `binding` is
-   * complete, live, and FAITHFUL to the version's contract, then writes only the
-   * installation pin (the app becomes installation #1, upgradeable again). A
-   * ConflictError names the aliases that diverge. `version` omitted adopts the
-   * latest. Backs `lotics package adopt`. Admin-only.
-   */
-  async adoptPackage(app_id, body) {
-    return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-adopt`, body);
-  }
   /**
    * Fleet upgrade — bring every installation of a package across the CALLER'S
    * org to the target version (latest when omitted) in one call. Hands-off
    * applies only where the preview is clean; installations with breaking/
    * drift/modified-core findings are skipped and reported for the normal
-   * per-installation consent flow. Backs `lotics package fleet-upgrade`.
+   * per-installation consent flow. Backs `lotics upgrade <package_id>` (fleet).
    * Admin-only; org-scoped (no workspace header needed).
    */
   /**
@@ -29922,16 +29888,10 @@ var LoticsClient = class {
       body
     );
   }
-  // --- App packages (registry authoring + dev harness) ---
-  /**
-   * Create a registry app package — the Lotics-owned, workspace-agnostic
-   * blueprint. `lotics package publish` calls this on first publish (when the
-   * local manifest has no `package_id`), then publishes version 1 against the
-   * returned id. Admin-only.
-   */
-  async createPackage(body) {
-    return this.request("POST", "/v1/packages", body);
-  }
+  // --- Packages (registry reads + installations) ---
+  // Authoring is server-side: apps via `POST /v1/apps/{id}/package-publish|release`,
+  // content packages via the `publish_content`/`release_content` tools. There is no
+  // client-side create-package / upload-bundle path.
   /**
    * Fetch a registry app package's metadata (incl. `kind`, `latest_version` and
    * the Lotics-backed `is_official` trust badge). Admin-only; cross-tenant by id.
@@ -29943,33 +29903,6 @@ var LoticsClient = class {
   async listPackageVersions(package_id) {
     return this.request("GET", `/v1/packages/${encodeURIComponent(package_id)}/versions`);
   }
-  /**
-   * Publish a new immutable package version — multipart upload of the alias-keyed
-   * contract (JSON) + the prebuilt code bundle (a gzipped tarball carrying
-   * `source.tar.gz` + `dist.tar.gz` members). The server validates the contract +
-   * bundle, then allocates the next monotonic version. The `contract` is opaque
-   * JSON to the transport (the server is the validating authority). Admin-only.
-   */
-  async publishPackageVersion(package_id, args) {
-    const formData = new FormData();
-    formData.append("contract", JSON.stringify(args.contract));
-    formData.append(
-      "bundle",
-      new Blob([new Uint8Array(args.bundle)], { type: "application/gzip" }),
-      "bundle.tar.gz"
-    );
-    if (args.changelog) formData.append("changelog", args.changelog);
-    if (args.channel) formData.append("channel", args.channel);
-    const url2 = `${this.baseUrl}/v1/packages/${encodeURIComponent(package_id)}/versions`;
-    const response = await fetch(url2, {
-      method: "POST",
-      headers: this.buildHeaders(),
-      // no Content-Type — fetch sets the multipart boundary
-      body: formData
-    });
-    if (!response.ok) await this.throwResponseError(response);
-    return response.json();
-  }
   /**
    * Upgrade a package installation to a newer published version — extends the
    * binding additively, re-materializes the target version's
@@ -29996,18 +29929,6 @@ var LoticsClient = class {
       `/v1/apps/${encodeURIComponent(app_id)}/package-upgrade${query}`
     );
   }
-  /**
-   * Re-bind a package role to a different workspace group (the current group
-   * still exists). Re-materializes at the pinned version; refuses over
-   * modified-core findings. Admin-only.
-   */
-  async rebindPackageRole(app_id, body) {
-    return this.request(
-      "POST",
-      `/v1/apps/${encodeURIComponent(app_id)}/package-rebind-role`,
-      body
-    );
-  }
   /**
    * Workspace-wide dangling-reference sweep — active app/workflow artifacts
    * whose prefixed schema ids no longer resolve. Backs
@@ -30025,13 +29946,59 @@ var LoticsClient = class {
     return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/package-health`);
   }
   /**
-   * Reset a package installation in a DEV workspace — drop the package-owned
-   * scaffolded tables and re-scaffold clean. Hard-gated server-side to dev
-   * workspaces (a non-dev workspace is refused). Returns the resulting app.
-   * Admin-only.
+   * Preview a release — the dry run behind `lotics app release`. Runs the
+   * binding-aware extract of the origin (aliases stable through the app's current
+   * binding) and reports the next version number, the new + changed aliases, and
+   * any extract findings (an `error` blocks the apply). No writes. Admin,
+   * owning-org only.
    */
-  async resetPackage(app_id) {
-    return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-reset`);
+  async previewPackageRelease(app_id) {
+    return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/package-release`);
+  }
+  /**
+   * Release — snapshot the origin app into the next registry version. The server
+   * binding-aware-extracts it, repackages its deployed source + dist as the
+   * bundle, publishes the next `release`-channel version with the changelog, and
+   * re-pins the origin. Error findings from extract surface as a 409. Admin,
+   * owning-org only. Backs `lotics app release --yes`.
+   */
+  async releasePackage(app_id, body) {
+    return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-release`, body);
+  }
+  /**
+   * Dry-run preview of a first-release — the `GET` behind `lotics app publish`
+   * (no `--yes`), the publish-side analogue of `previewPackageRelease`. The
+   * server runs the same fresh-alias extract + `src/` scan the apply runs
+   * (through any `renames`) and returns the package name it would mint, the
+   * auto-minted RENAMABLE aliases (the exact `--rename` keys), and the extract
+   * findings (an `error` blocks the apply). No writes. Admin-only.
+   */
+  async previewPublishAppPackage(app_id, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.knowledge !== void 0 && opts.knowledge.length > 0) {
+      params.set("knowledge", JSON.stringify(opts.knowledge));
+    }
+    if (opts.renames !== void 0 && opts.renames.length > 0) {
+      params.set("renames", JSON.stringify(opts.renames));
+    }
+    const query = params.toString();
+    return this.request(
+      "GET",
+      `/v1/apps/${encodeURIComponent(app_id)}/package-publish${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * First-release apply — mint a package from a BESPOKE app and publish v1 in one
+   * call (the `POST` behind `lotics app publish --yes`). The server extracts an
+   * alias-keyed contract from the app (fresh aliases; `renames` fixes them before
+   * v1 freezes), creates the registry package (name/description from the app),
+   * publishes v1 from the app's deployed source + dist, and pins the origin as
+   * installation #1. Error findings from extract surface as a 409. An
+   * already-linked app must use `releasePackage` instead. Admin-only. Backs
+   * `lotics app publish <app_id>`.
+   */
+  async publishAppAsPackage(app_id, body) {
+    return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-publish`, body);
   }
   /**
    * Resolve the display name + fields (incl. select options) of the given tables
@@ -31360,379 +31327,6 @@ See https://lotics.ai/docs/app-sdk for the SDK reference.
     }
   ];
 }
-function buildPackageStarterOverrides(args) {
-  const nameLit = JSON.stringify(args.app_name);
-  return [
-    {
-      // The package App.tsx imports `../.lotics/app_fields` — a DETERMINISTIC
-      // pure function of contract.json (generate_package_fields.ts) — so unlike
-      // the app starter's fully-ignored `.lotics`, it must be committed or the
-      // scaffold's own shipped CI (npm ci → typecheck/test/build on a clean
-      // clone) fails on the missing module. The sync-written `.d.ts` companions
-      // stay ignored: they need a live workspace and their absence only degrades
-      // hooks to untyped overloads, never breaks the build.
-      path: ".gitignore",
-      content: `node_modules
-dist
-*.tsbuildinfo
-.DS_Store
-.lotics/*
-!.lotics/app_fields.ts
-coverage
-`
-    },
-    {
-      path: "src/App.tsx",
-      content: `import { useMemo, type ReactNode } from "react";
-import { ScrollView, View } from "react-native";
-import { useConfig, useQuery, readSelect, row } from "@lotics/app-sdk";
-import { AppRouter } from "@lotics/app-sdk/router";
-import { Text } from "@lotics/ui/text";
-import { Card } from "@lotics/ui/card";
-import { Button } from "@lotics/ui/button";
-import { OptionBadge } from "@lotics/ui/option_badge";
-import { Skeleton } from "@lotics/ui/skeleton";
-import { EmptyState } from "@lotics/ui/empty_state";
-import { Callout, CalloutTitle, CalloutText, CalloutActions } from "@lotics/ui/callout";
-import { F, OPT } from "../.lotics/app_fields";
-
-// This is a PACKAGE starter \u2014 a workspace-agnostic blueprint installed into many
-// workspaces, each binding the contract's aliases to DIFFERENT concrete ids. So a
-// screen never hardcodes a \`fld_\u2026\`/\`opt_\u2026\` id: it addresses a field by contract
-// alias through \`F\` and a select option through \`OPT\`, both from the generated
-// \`.lotics/app_fields.ts\` (which resolves every alias to THIS installation's id at
-// module load from the binding). The aliases come from contract.json \u2014 entity
-// \`item\`, fields name/notes/status, options open/done, query \`items\`, config knob
-// \`heading\`. Edit contract.json, then \`lotics package sync\` to regenerate F/OPT.
-
-interface Item {
-  id: string;
-  name: string;
-  notes: string;
-  status: ReturnType<typeof readSelect>[number] | null;
-  done: boolean;
-}
-
-// The \`items\` query is a bare from_entity, so a row is keyed by FIELD id: read a
-// cell as \`r[F.ITEM.<field>]\` and decode it with the SDK's pure readers (\`row.text\`,
-// \`readSelect\`). \`OPT.ITEM.status.done\` is this install's \`opt_\u2026\` id, so comparing
-// the cell's stored option key to it marks a done row.
-function decode(r: Record<string, unknown>): Item {
-  const status = readSelect(r[F.ITEM.status])[0] ?? null;
-  return {
-    id: row.text(r.__source_record_id),
-    name: row.text(r[F.ITEM.name]),
-    notes: row.text(r[F.ITEM.notes]),
-    status,
-    done: status?.key === OPT.ITEM.status.done,
-  };
-}
-
-// Outer <View flex:1> claims the iframe height (index.html sets html/body/#root to
-// 100% + #root is a flex column); the list scrolls beneath the heading. Keep this
-// flex chain plain (not @lotics/ui/stack) so a fill-remaining-space child gets height.
-function Screen({ children }: { children: ReactNode }) {
-  return (
-    <View style={{ flex: 1 }}>
-      <ScrollView contentContainerStyle={{ padding: 24, alignItems: "center" }}>
-        <View style={{ maxWidth: 640, width: "100%", gap: 16 }}>{children}</View>
-      </ScrollView>
-    </View>
-  );
-}
-
-function ItemsScreen() {
-  // \`heading\` is a contract config knob \u2014 an installation overrides it and
-  // useConfig() renders the customized value; the literal here is only the fallback.
-  const { config } = useConfig({ heading: ${nameLit} });
-  const itemsQ = useQuery("items");
-  const items = useMemo(() => itemsQ.rows.map(decode), [itemsQ.rows]);
-  // First-load only: a skeleton while the very first fetch is in flight with no rows
-  // yet \u2014 never blank already-loaded rows to a spinner on a background refetch.
-  const firstLoad = itemsQ.loading && items.length === 0;
-
-  return (
-    <Screen>
-      <Text size="xxl" weight="semibold" level={1}>
-        {config.heading}
-      </Text>
-
-      {itemsQ.error ? (
-        <Callout tone="error">
-          <CalloutTitle>Couldn't load items</CalloutTitle>
-          <CalloutText>{itemsQ.error}</CalloutText>
-          <CalloutActions>
-            <Button title="Try again" onPress={() => itemsQ.refetch()} />
-          </CalloutActions>
-        </Callout>
-      ) : firstLoad ? (
-        <View style={{ gap: 10 }}>
-          {[0, 1, 2].map((i) => (
-            <Skeleton key={i} height={64} radius={12} />
-          ))}
-        </View>
-      ) : items.length > 0 ? (
-        <View style={{ gap: 10 }}>
-          {items.map((item) => (
-            <Card key={item.id}>
-              <View style={{ flexDirection: "row", alignItems: "center", gap: 12 }}>
-                <View style={{ flex: 1, gap: 2 }}>
-                  <Text weight="medium" color={item.done ? "muted" : undefined}>
-                    {item.name}
-                  </Text>
-                  {item.notes.length > 0 ? (
-                    <Text size="sm" color="muted" numberOfLines={1}>
-                      {item.notes}
-                    </Text>
-                  ) : null}
-                </View>
-                <OptionBadge value={item.status} />
-              </View>
-            </Card>
-          ))}
-        </View>
-      ) : (
-        <EmptyState
-          icon="list-checks"
-          message="No items yet"
-          hint="Rows in this package's table appear here."
-        />
-      )}
-    </Screen>
-  );
-}
-
-const routes = [{ path: "/", element: <ItemsScreen /> }];
-
-export default function App() {
-  return <AppRouter routes={routes} />;
-}
-`
-    },
-    {
-      path: "src/App.test.tsx",
-      content: `import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
-import { render, screen, cleanup } from "@testing-library/react";
-import App from "./App";
-
-// Mock @lotics/app-sdk \u2014 the app's one external boundary (data + RPC + the package
-// binding). \`importOriginal\` keeps the PURE cell readers (\`row\`, \`readSelect\`) real,
-// so mock rows decode exactly like wire rows; only the hooks and getAppBinding are
-// stubbed. The binding ids below are what F.ITEM.* / OPT.ITEM.status.* resolve to;
-// the query rows are keyed by the SAME ids.
-const h = vi.hoisted(() => ({
-  state: {
-    rows: [] as Array<Record<string, unknown>>,
-    loading: false,
-    error: null as string | null,
-  },
-  binding: {
-    fields: { "item.name": "fld_name", "item.notes": "fld_notes", "item.status": "fld_status" },
-    options: { "item.status:open": "opt_open", "item.status:done": "opt_done" },
-    roles: {},
-  },
-}));
-
-vi.mock("@lotics/app-sdk", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@lotics/app-sdk")>();
-  return {
-    ...actual,
-    getAppBinding: async () => h.binding,
-    useConfig: (defaults: Record<string, unknown>) => ({ config: defaults, loading: false }),
-    useQuery: () => ({
-      rows: h.state.rows,
-      loading: h.state.loading,
-      isValidating: false,
-      error: h.state.error,
-      refetch: () => {},
-    }),
-  };
-});
-
-const rowOf = (id: string, name: string, notes: string, statusKey: string) => ({
-  __source_record_id: id,
-  fld_name: name,
-  fld_notes: notes,
-  fld_status: [{ key: statusKey, label: statusKey === "opt_done" ? "Done" : "Open" }],
-});
-
-beforeEach(() => {
-  h.state.rows = [];
-  h.state.loading = false;
-  h.state.error = null;
-});
-
-// vitest globals are off, so @testing-library/react's automatic afterEach cleanup is
-// never registered \u2014 clean up explicitly or renders accumulate across tests and a
-// second render's duplicate matches fail getByText.
-afterEach(cleanup);
-
-describe("App", () => {
-  test("renders the heading and the loaded items with status badges", () => {
-    h.state.rows = [
-      rowOf("1", "First item", "with a note", "opt_open"),
-      rowOf("2", "Second item", "", "opt_done"),
-    ];
-    render(<App />);
-
-    expect(screen.getByText(${nameLit})).toBeTruthy();
-    expect(screen.getByText("First item")).toBeTruthy();
-    expect(screen.getByText("Second item")).toBeTruthy();
-    expect(screen.getByText("with a note")).toBeTruthy();
-    expect(screen.getByText("Open")).toBeTruthy();
-    expect(screen.getByText("Done")).toBeTruthy();
-    expect(screen.queryByText("No items yet")).toBeNull();
-  });
-
-  test("shows the empty state when there are no items", () => {
-    render(<App />);
-    expect(screen.getByText("No items yet")).toBeTruthy();
-  });
-
-  test("does not flash the list or empty state on first load", () => {
-    h.state.loading = true;
-    render(<App />);
-    expect(screen.queryByText("No items yet")).toBeNull();
-  });
-
-  test("surfaces a load error loudly", () => {
-    h.state.error = "Network unreachable";
-    render(<App />);
-    expect(screen.getByText("Couldn't load items")).toBeTruthy();
-    expect(screen.getByText("Network unreachable")).toBeTruthy();
-  });
-});
-`
-    },
-    {
-      path: "README.md",
-      content: `# ${escapeHtml(args.app_name)}
-
-A Lotics **app package** \u2014 a versioned, installable blueprint (a \`contract.json\`
-data model + app source) that installs into many workspaces. Authored locally,
-published and run through the \`lotics package\` CLI. See \`docs/app_packages.md\`.
-
-## Dev loop
-
-\`\`\`bash
-lotics workspace create "${escapeHtml(args.app_name)} dev" --dev   # a throwaway dev workspace
-lotics package dev --workspace <dev_ws>                # sync into it + run the dev server
-# edit contract.json  \u2192 re-run \`lotics package sync\` to migrate + re-materialize
-# edit src/*          \u2192 hot reload
-\`\`\`
-
-\`sync\` / \`dev\` regenerate \`.lotics/app_fields.ts\` (the runtime \`F\` / \`OPT\` / \`ROLE\`
-surface) from \`contract.json\`, plus the typed \`.lotics/app_{queries,workflows,agents}.d.ts\`
-companions from the live installation \u2014 so \`useQuery\` / \`useWorkflow\` stay typed in the
-dev loop.
-
-## Quality
-
-\`\`\`bash
-npm run typecheck
-npm run lint
-npm test
-\`\`\`
-
-## Publish
-
-\`\`\`bash
-lotics package publish -m "v1"        # build + publish an immutable version
-lotics package install <package_id>   # install into any workspace
-\`\`\`
-
-## The app screen
-
-\`src/App.tsx\` reads the contract BY ALIAS through \`F\` / \`OPT\` (from the generated
-\`.lotics/app_fields.ts\`) \u2014 never a raw \`fld_\u2026\` / \`opt_\u2026\` id, since every install binds
-different concrete ids. It lists the \`items\` query and renders the \`heading\` config knob.
-\`@lotics/ui\` primitives render via react-native-web (aliased in \`vite.config.ts\`).
-
-## Contract reference
-
-\`contract.json\` is the package's alias-keyed data model
-(schema: \`@lotics/shared/schemas/app_packages\`). Every cross-reference is by **alias**;
-the materializer resolves alias \u2192 this workspace's concrete id at install.
-
-### Aliases
-
-- Entity / field / option / role / template / config aliases are lowercase slugs
-  matching \`^[a-z][a-z0-9_]*$\`. A field's fully-qualified key is \`<entity>.<field>\`
-  (e.g. \`item.status\`); a select option's is \`<entity>.<field>:<option>\`
-  (e.g. \`item.status:done\`).
-- Query / workflow / agent aliases are runtime lookup keys (1\u2013200 chars) \u2014 the app
-  source invokes them verbatim (\`useQuery("items")\`), so renaming one severs the call.
-
-### Entities & fields
-
-\`\`\`jsonc
-{ "alias": "item", "label": "Item", "fields": [
-  { "alias": "name",   "label": "Name",   "type": "text", "required": true },
-  { "alias": "status", "label": "Status", "type": "select",
-    "options": [ { "alias": "open", "label": "Open", "color": "blue" },
-                 { "alias": "done", "label": "Done", "color": "green" } ] } ] }
-\`\`\`
-
-Field \`type\`: \`text\`, \`number\`, \`date\`, \`boolean\`, \`select\` (+ \`options\`),
-\`select_member\`, \`select_record_link\` (\`target_entity\` = an entity alias), \`files\`,
-\`formula\` (expression references same-entity fields as \`{alias}\`), \`rollup\`, \`lookup\`,
-\`autonumber\`. \`required\` is advisory (app / workflow-layer UX only \u2014 the table model
-has no required constraint). Select \`options\` are \`{ alias, label, color }\`.
-
-### Queries
-
-Alias-form AST \u2014 the same node kinds as the runtime query engine, except a
-\`from_table\` node carries \`from_entity\` (an entity alias) instead of a \`table_id\`:
-
-\`\`\`jsonc
-{ "alias": "items", "ast": {
-  "kind": "from_table", "from_entity": "item",
-  "sort": [ { "field_key": "name", "order": "asc" } ] } }
-\`\`\`
-
-### Workflows
-
-The sole app-side mutation path. Each workflow has a \`trigger\`, typed \`inputs\` /
-\`outputs\`, and a JS-subset \`body\`.
-
-- Trigger \u2014 app-invoked or table-lifecycle:
-  - \`{ "type": "app" }\` \u2014 called by alias from the app (\`useWorkflow("<alias>")\`).
-  - \`{ "type": "entity_lifecycle", "entity": "<entity>", "event": "<event>" }\` \u2014 fires
-    on the bound table. \`event\` \u2208 \`before_create\`, \`after_create\`, \`before_update\`,
-    \`after_update\`, \`before_delete\`, \`after_delete\`.
-- Typed \`inputs\` (\`text\` / \`number\` / \`date\` / \`member\` / \`select\` / \`record_link\`,
-  plus \`object\` / \`array\`):
-  - \`record_link\` \u2014 its \`table_id\` names an **entity alias**.
-  - \`member\` \u2014 its \`group\` names a **role alias**.
-  - \`select\` \u2014 an option \`value\` in \`entity.field:option\` form binds to that option's
-    id (a plain value is a literal, left as-is).
-- Body **sentinel tokens** \u2014 a body addresses package objects by reserved tokens the
-  materializer rewrites to concrete ids at install. Always inside a **string literal**:
-  - \`@@entity:<entity>@@\`
-  - \`@@field:<entity>.<field>@@\`
-  - \`@@option:<entity>.<field>:<option>@@\`
-  - \`@@role:<role>@@\`
-  - \`@@template:<template>@@\`
-
-### Config knobs
-
-Typed customization knobs the app reads via \`useConfig()\`. Each has an \`alias\`,
-\`label\`, \`type\`, and \`default\`:
-
-- \`text\` \u2192 a string default; \`boolean\` \u2192 a boolean; \`number\` \u2192 a number;
-  \`color\` \u2192 a palette color token; \`select\` \u2192 \`options: [{ value, label }]\` with the
-  \`default\` being one of those \`value\`s.
-
-\`\`\`jsonc
-{ "alias": "heading", "label": "List heading", "type": "text", "default": "Items" }
-\`\`\`
-
-Publish validates the whole contract (alias uniqueness, every cross-reference
-resolves, sentinel tokens name declared objects) before storing the version.
-`
-    }
-  ];
-}
 function escapeHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -32802,6 +32396,123 @@ export type AppOptions = typeof OPT;
 `;
 }
 
+// src/generate_package_fields.ts
+var HEADER5 = `// Auto-generated by 'lotics app codegen' (linked/published app; also app pull/dev/deploy).
+// DO NOT EDIT \u2014 regenerated from the installation's live binding.
+//
+// A package installation resolves F/OPT/ROLE at MODULE LOAD from its binding
+// (contract alias \u2192 THIS workspace's concrete id) via the SDK's \`binding\` RPC.
+// Top-level await: the module graph waits for the binding before any importer
+// evaluates, so every entry is a plain string.
+import { getAppBinding } from "@lotics/app-sdk";
+
+const binding = await getAppBinding();
+
+function bound(map: Record<string, string>, key: string, kind: string): string {
+  const id = map[key];
+  if (id === undefined) {
+    throw new Error(
+      \`app_fields: \${kind} "\${key}" is not in this installation's binding \u2014 \` +
+        \`the generated app_fields.ts is stale relative to the installed contract version.\`,
+    );
+  }
+  return id;
+}
+`;
+function parseBinding(binding) {
+  const entities = [];
+  const entityByAlias = /* @__PURE__ */ new Map();
+  const fieldByKey = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(binding.fields)) {
+    const dot = key.indexOf(".");
+    if (dot <= 0 || dot >= key.length - 1) continue;
+    const entityAlias = key.slice(0, dot);
+    const fieldAlias = key.slice(dot + 1);
+    let entity = entityByAlias.get(entityAlias);
+    if (entity === void 0) {
+      entity = { alias: entityAlias, fields: [] };
+      entityByAlias.set(entityAlias, entity);
+      entities.push(entity);
+    }
+    const field = { alias: fieldAlias, key, options: [] };
+    entity.fields.push(field);
+    fieldByKey.set(key, field);
+  }
+  for (const key of Object.keys(binding.options)) {
+    const colon = key.indexOf(":");
+    if (colon <= 0 || colon >= key.length - 1) continue;
+    const fieldKey = key.slice(0, colon);
+    const optionAlias = key.slice(colon + 1);
+    const field = fieldByKey.get(fieldKey);
+    if (field === void 0) continue;
+    field.options.push({ alias: optionAlias, key });
+  }
+  return { entities, roles: Object.keys(binding.roles) };
+}
+function emitFieldMap2(entities) {
+  if (entities.length === 0) return `export const F = {} as const;`;
+  const blocks = entities.map((entity) => {
+    const lines = entity.fields.map(
+      (field) => `    ${propKey(field.alias)}: bound(binding.fields, ${JSON.stringify(field.key)}, "field"),`
+    );
+    return `  ${propKey(entity.alias.toUpperCase())}: {
+${lines.join("\n")}
+  },`;
+  });
+  return `export const F = {
+${blocks.join("\n")}
+} as const;`;
+}
+function emitOptionMap2(entities) {
+  const entityBlocks = [];
+  for (const entity of entities) {
+    const fieldBlocks = [];
+    for (const field of entity.fields) {
+      if (field.options.length === 0) continue;
+      const lines = field.options.map(
+        (option) => `      ${propKey(option.alias)}: bound(binding.options, ${JSON.stringify(option.key)}, "option"),`
+      );
+      fieldBlocks.push(`    ${propKey(field.alias)}: {
+${lines.join("\n")}
+    },`);
+    }
+    if (fieldBlocks.length === 0) continue;
+    entityBlocks.push(`  ${propKey(entity.alias.toUpperCase())}: {
+${fieldBlocks.join("\n")}
+  },`);
+  }
+  if (entityBlocks.length === 0) return `export const OPT = {} as const;`;
+  return `export const OPT = {
+${entityBlocks.join("\n")}
+} as const;`;
+}
+function emitRoleMap(roles) {
+  if (roles.length === 0) return `export const ROLE = {} as const;`;
+  const lines = roles.map(
+    (role) => `  ${propKey(role)}: bound(binding.roles, ${JSON.stringify(role)}, "role"),`
+  );
+  return `export const ROLE = {
+${lines.join("\n")}
+} as const;`;
+}
+function generatePackageAppFields(binding) {
+  const { entities, roles } = parseBinding(binding);
+  return `${HEADER5}
+${emitFieldMap2(entities)}
+
+${emitOptionMap2(entities)}
+
+${emitRoleMap(roles)}
+
+/** Field-id alias map: \`F[<ENTITY>][<field>]\` is this installation's \`fld_\u2026\` id. */
+export type AppFields = typeof F;
+/** Select-option alias map: \`OPT[<ENTITY>][<field>][<option>]\` is this installation's \`opt_\u2026\` id. */
+export type AppOptions = typeof OPT;
+/** Role alias map: \`ROLE[<role>]\` is this installation's \`grp_\u2026\` id. */
+export type AppRoles = typeof ROLE;
+`;
+}
+
 // src/app_workflow_check.ts
 import fs3 from "node:fs";
 import path4 from "node:path";
@@ -33128,6 +32839,13 @@ function writeAppFields(projectDir, tables) {
   fs4.writeFileSync(file2, generateAppFields(tables));
   return file2;
 }
+function writeBindingAppFields(projectDir, binding) {
+  const dotLotics = path5.join(projectDir, ".lotics");
+  fs4.mkdirSync(dotLotics, { recursive: true });
+  const file2 = path5.join(dotLotics, "app_fields.ts");
+  fs4.writeFileSync(file2, generatePackageAppFields(binding));
+  return file2;
+}
 async function appCodegen(args) {
   const projectDir = path5.resolve(args.projectDir ?? process.cwd());
   const meta3 = readAppMeta(projectDir);
@@ -33143,14 +32861,24 @@ async function appCodegen(args) {
     );
     return;
   }
-  const tableIds = resolveCodegenTableIds(projectDir, meta3.queries ?? {});
   try {
-    const tables = await args.client.getWorkspaceSchema(tableIds);
-    const fieldsPath = writeAppFields(projectDir, tables);
-    console.error(`Regenerated ${fieldsPath} (${tables.length} table${tables.length === 1 ? "" : "s"})`);
+    const app = await args.client.getApp(meta3.app_id);
+    if (app.package_id) {
+      const binding = await args.client.appBinding(meta3.app_id);
+      const fieldsPath = writeBindingAppFields(projectDir, binding);
+      const count = Object.keys(binding.fields).length;
+      console.error(
+        `Regenerated ${fieldsPath} (binding form \u2014 ${count} field alias${count === 1 ? "" : "es"} resolved per-install)`
+      );
+    } else {
+      const tableIds = resolveCodegenTableIds(projectDir, meta3.queries ?? {});
+      const tables = await args.client.getWorkspaceSchema(tableIds);
+      const fieldsPath = writeAppFields(projectDir, tables);
+      console.error(`Regenerated ${fieldsPath} (${tables.length} table${tables.length === 1 ? "" : "s"})`);
+    }
   } catch (err2) {
     console.error(
-      `\u26A0 Could not fetch the workspace schema (${err2 instanceof Error ? err2.message : String(err2)}). Kept the existing .lotics/app_fields.ts.`
+      `\u26A0 Could not regenerate .lotics/app_fields.ts (${err2 instanceof Error ? err2.message : String(err2)}). Kept the existing file.`
     );
   }
   await refreshWorkflowGlobals(args.client, projectDir, meta3.app_id, Object.keys(meta3.workflows ?? {}));
@@ -33834,10 +33562,8 @@ function escapeRegExp(s) {
 }
 
 // src/package_commands.ts
-import fs6 from "node:fs";
-import path7 from "node:path";
-import { tmpdir as tmpdir2 } from "node:os";
-import { createHash } from "node:crypto";
+import fs5 from "node:fs";
+import path6 from "node:path";
 
 // ../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -49725,7 +49451,7 @@ var appSchema = zod_default.object({
   // avoid a circular import; the shapes mirror Binding / AppInstallationConfig.
   package_id: zod_default.string().nullable().optional().describe("App-package registry id this app was installed from; null for a bespoke app or after eject."),
   package_version: zod_default.number().int().nullable().optional().describe("Installed package version (the upgrade pin); null for a bespoke app or after eject."),
-  binding: zod_default.record(zod_default.string(), zod_default.record(zod_default.string(), zod_default.string())).nullable().optional().describe("App-package install join: per-namespace (entities/fields/options/templates/roles) alias \u2192 concrete-id maps. Null for a bespoke app."),
+  binding: zod_default.record(zod_default.string(), zod_default.record(zod_default.string(), zod_default.string())).nullable().optional().describe("App-package install join: per-namespace (entities/fields/options/templates/roles/workflows/knowledge) alias \u2192 concrete-id maps. Null for a bespoke app."),
   config: zod_default.record(zod_default.string(), zod_default.union([zod_default.string(), zod_default.number(), zod_default.boolean()])).nullable().optional().describe("Installation-level customization config values (the customization-ladder first rung). Null for a bespoke app."),
   ejected_at: zod_default.string().nullable().optional().describe("When the app was ejected from its package (severing upgrades); null if never ejected."),
   created_at: zod_default.string().describe("Timestamp when app was created"),
@@ -49768,7 +49494,6 @@ var workspaceSchema = zod_default.object({
   default_currency: zod_default.string().describe("Default currency code for the workspace"),
   timezone: zod_default.string().describe("IANA timezone name (e.g., 'America/New_York', 'Asia/Tokyo')"),
   organization_id: zod_default.string().describe("Organization ID this workspace belongs to"),
-  is_dev: zod_default.boolean().optional().describe("Marks a throwaway app-package dev workspace \u2014 gates `lotics package dev/sync/reset`."),
   created_at: zod_default.string().describe("Timestamp when workspace was created")
 });
 var memberGroupSchema = zod_default.object({
@@ -50315,7 +50040,14 @@ var bindingSchema = zod_default.object({
   // it, and hashes look rows up through it. Excluded from BINDING_NAMESPACES:
   // a deleted row is a modified-core finding (fingerprints), never binding
   // drift, so validateBinding/applyDriftResolutions ignore it.
-  workflows: bindingMapSchema.default({})
+  workflows: bindingMapSchema.default({}),
+  // The app's BUNDLED knowledge corpus: contract knowledge alias → the
+  // workspace's concrete `kdc_` id. One row, one pin — the app installation IS
+  // the anchor for its bundled docs (`package_content_installations` rows are
+  // standalone content packages only). Excluded from BINDING_NAMESPACES: a
+  // gone/edited doc is detected by the knowledge upgrade preview (live doc +
+  // content-sha reads), never by validateBinding's live-id sweep.
+  knowledge: bindingMapSchema.default({})
 });
 var BINDING_NAMESPACES = ["entities", "fields", "options", "templates", "roles"];
 var contentBindingMapSchema = zod_default.record(zod_default.string().min(1), zod_default.string().min(1));
@@ -50349,10 +50081,6 @@ var packageArtifactHashesSchema = zod_default.object({
   agents: zod_default.record(zod_default.string(), zod_default.string())
 });
 var modificationResolutionSchema = zod_default.union([zod_default.literal("revert"), zod_default.literal("keep")]);
-var upgradeResolutionsSchema = zod_default.record(
-  zod_default.string(),
-  zod_default.union([driftResolutionSchema, modificationResolutionSchema])
-);
 var KNOWLEDGE_UPGRADE_CHANGES = ["added", "changed", "removed", "drifted"];
 var knowledgeUpgradeEntrySchema = zod_default.object({
   alias: zod_default.string(),
@@ -50381,15 +50109,15 @@ function validKnowledgeResolutions(change) {
       return [];
   }
 }
+var upgradeResolutionsSchema = zod_default.record(
+  zod_default.string(),
+  zod_default.union([driftResolutionSchema, modificationResolutionSchema, knowledgeResolutionSchema])
+);
 var knowledgeBindConsentSchema = zod_default.record(zod_default.string(), zod_default.string());
 var knowledgeUpgradeResolutionsSchema = zod_default.object({
   resolutions: zod_default.record(zod_default.string(), knowledgeResolutionSchema).default({}),
   bind_to: knowledgeBindConsentSchema.default({})
 });
-var contentUpgradeResolutionsSchema = zod_default.object({
-  knowledge: knowledgeUpgradeResolutionsSchema.default({ resolutions: {}, bind_to: {} }),
-  templates: zod_default.record(zod_default.string(), modificationResolutionSchema).default({})
-});
 var knowledgeBoundRefSchema = zod_default.object({
   alias: zod_default.string(),
   name: zod_default.string(),
@@ -50403,261 +50131,38 @@ var appInstallationConfigSchema = zod_default.record(
 );
 var appInstallationProvenanceSchema = zod_default.enum(["install", "adopt"]);
 
-// src/generate_package_fields.ts
-var HEADER5 = `// Auto-generated by 'lotics package new/extract/dev/sync' from contract.json.
-// DO NOT EDIT \u2014 regenerated whenever the contract changes.
-//
-// Package apps resolve F/OPT/ROLE at MODULE LOAD from the installation's
-// binding (contract alias \u2192 THIS workspace's concrete id) via the SDK's
-// \`binding\` RPC. Top-level await: the module graph waits for the binding
-// before any importer evaluates, so every entry is a plain string.
-import { getAppBinding } from "@lotics/app-sdk";
-
-const binding = await getAppBinding();
-
-function bound(map: Record<string, string>, key: string, kind: string): string {
-  const id = map[key];
-  if (id === undefined) {
-    throw new Error(
-      \`app_fields: \${kind} "\${key}" is not in this installation's binding \u2014 \` +
-        \`the generated app_fields.ts is stale relative to the installed contract version.\`,
-    );
-  }
-  return id;
-}
-`;
-function generatePackageAppFields(contract) {
-  const entities = contract.entities ?? [];
-  const roles = contract.roles ?? [];
-  const fieldBlocks = [];
-  for (const entity of entities) {
-    const lines = (entity.fields ?? []).map(
-      (field) => `    ${propKey(field.alias)}: bound(binding.fields, ${JSON.stringify(`${entity.alias}.${field.alias}`)}, "field"),`
-    );
-    if (lines.length === 0) continue;
-    fieldBlocks.push(`  ${propKey(entity.alias.toUpperCase())}: {
-${lines.join("\n")}
-  },`);
-  }
-  const optionBlocks = [];
-  for (const entity of entities) {
-    const perField = [];
-    for (const field of entity.fields ?? []) {
-      const options = field.options ?? [];
-      if (options.length === 0) continue;
-      const lines = options.map(
-        (option) => `      ${propKey(option.alias)}: bound(binding.options, ${JSON.stringify(`${entity.alias}.${field.alias}:${option.alias}`)}, "option"),`
-      );
-      perField.push(`    ${propKey(field.alias)}: {
-${lines.join("\n")}
-    },`);
-    }
-    if (perField.length > 0) {
-      optionBlocks.push(`  ${propKey(entity.alias.toUpperCase())}: {
-${perField.join("\n")}
-  },`);
-    }
-  }
-  const fMap = fieldBlocks.length > 0 ? `export const F = {
-${fieldBlocks.join("\n")}
-} as const;` : `export const F = {} as const;`;
-  const optMap = optionBlocks.length > 0 ? `export const OPT = {
-${optionBlocks.join("\n")}
-} as const;` : `export const OPT = {} as const;`;
-  const roleMap = roles.length > 0 ? `export const ROLE = {
-${roles.map((role) => `  ${propKey(role.alias)}: bound(binding.roles, ${JSON.stringify(role.alias)}, "role"),`).join("\n")}
-} as const;` : `export const ROLE = {} as const;`;
-  return `${HEADER5}
-${fMap}
-
-${optMap}
-
-${roleMap}
-
-/** Field-id alias map: \`F[<ENTITY>][<field>]\` is this installation's \`fld_\u2026\` id. */
-export type AppFields = typeof F;
-/** Select-option alias map: \`OPT[<ENTITY>][<field>][<option>]\` is this installation's \`opt_\u2026\` id. */
-export type AppOptions = typeof OPT;
-/** Role alias map: \`ROLE[<role>]\` is this installation's \`grp_\u2026\` id. */
-export type AppRoles = typeof ROLE;
-`;
-}
-
-// src/file_command_io.ts
-import fs5 from "node:fs";
-import path6 from "node:path";
-var CliError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CliError";
-  }
-};
-function fail(message) {
-  throw new CliError(message);
-}
-function writeFileAtomic(filePath, bytes) {
-  const dir = path6.dirname(path6.resolve(filePath));
-  const tmp = path6.join(dir, `.${path6.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
-  fs5.writeFileSync(tmp, bytes);
-  try {
-    fs5.renameSync(tmp, filePath);
-  } catch (error51) {
-    try {
-      fs5.unlinkSync(tmp);
-    } catch {
-    }
-    throw error51;
-  }
-  console.error(`Wrote ${filePath}`);
-}
-
 // src/package_commands.ts
-var CONTRACT_FILE = "contract.json";
-var ADOPT_BINDING_FILE = "adopt_binding.json";
-var PACKAGE_TEMPLATE_KINDS = /* @__PURE__ */ new Set([
-  "html",
-  "email",
-  "excel",
-  "word",
-  "pdf-form"
-]);
 function packageJsonPath(projectDir) {
-  return path7.join(projectDir, "package.json");
+  return path6.join(projectDir, "package.json");
 }
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readPackageProject(projectDir) {
+function readLocalAppManifest(projectDir) {
   const pkgPath2 = packageJsonPath(projectDir);
-  if (!fs6.existsSync(pkgPath2)) {
-    throw new Error(
-      `No package.json in ${projectDir}. Run this inside a package project (lotics package new <name>).`
-    );
-  }
-  const parsed = JSON.parse(fs6.readFileSync(pkgPath2, "utf-8"));
-  if (!isPlainObject2(parsed)) throw new Error(`Malformed package.json in ${projectDir}.`);
-  const lotics = parsed.lotics;
-  const pkg2 = isPlainObject2(lotics) ? lotics.package : void 0;
-  if (!isPlainObject2(pkg2) || typeof pkg2.name !== "string") {
-    throw new Error(
-      `${pkgPath2} has no lotics.package manifest \u2014 not a package project. Use "lotics package new <name>".`
-    );
-  }
-  const dev = {};
-  if (isPlainObject2(pkg2.dev)) {
-    for (const [ws, entry] of Object.entries(pkg2.dev)) {
-      if (isPlainObject2(entry) && typeof entry.app_id === "string" && typeof entry.version === "number") {
-        dev[ws] = { app_id: entry.app_id, version: entry.version };
-      }
-    }
-  }
-  const knowledge = {};
-  if (isPlainObject2(pkg2.knowledge)) {
-    for (const [alias, entry] of Object.entries(pkg2.knowledge)) {
-      if (!isPlainObject2(entry) || typeof entry.name !== "string" || entry.name.length === 0) {
-        throw new Error(
-          `${pkgPath2}: lotics.package.knowledge.${alias} must be an object with a non-empty "name".`
-        );
-      }
-      knowledge[alias] = {
-        name: entry.name,
-        description: typeof entry.description === "string" ? entry.description : null,
-        active_by_default: typeof entry.active_by_default === "boolean" ? entry.active_by_default : true
-      };
-    }
-  }
-  const templates = {};
-  if (isPlainObject2(pkg2.templates)) {
-    for (const [alias, entry] of Object.entries(pkg2.templates)) {
-      if (!isPlainObject2(entry) || typeof entry.name !== "string" || entry.name.length === 0 || typeof entry.type !== "string" || !PACKAGE_TEMPLATE_KINDS.has(entry.type) || typeof entry.file !== "string" || entry.file.length === 0) {
-        throw new Error(
-          `${pkgPath2}: lotics.package.templates.${alias} must be an object with a non-empty "name", a "type" of html|email|excel|word|pdf-form, and a non-empty "file" (a name in templates/).`
-        );
+  if (!fs5.existsSync(pkgPath2)) return null;
+  const parsed = JSON.parse(fs5.readFileSync(pkgPath2, "utf-8"));
+  if (!isPlainObject2(parsed)) return null;
+  const lotics = isPlainObject2(parsed.lotics) ? parsed.lotics : {};
+  const app_id = typeof lotics.app_id === "string" ? lotics.app_id : null;
+  const knowledge = [];
+  if (Array.isArray(lotics.knowledge)) {
+    for (const entry of lotics.knowledge) {
+      if (isPlainObject2(entry) && typeof entry.alias === "string" && typeof entry.doc_id === "string") {
+        knowledge.push({ alias: entry.alias, doc_id: entry.doc_id });
       }
-      templates[alias] = {
-        name: entry.name,
-        type: entry.type,
-        file: entry.file
-      };
     }
   }
-  const knowledge_expects = Array.isArray(pkg2.knowledge_expects) ? pkg2.knowledge_expects.filter((v) => typeof v === "string") : [];
-  const manifest = {
-    id: typeof pkg2.id === "string" ? pkg2.id : null,
-    name: pkg2.name,
-    description: typeof pkg2.description === "string" ? pkg2.description : null,
-    kind: pkg2.kind === "content" ? "content" : "app",
-    version: typeof pkg2.version === "number" ? pkg2.version : null,
-    knowledge,
-    templates,
-    knowledge_expects,
-    dev
-  };
-  return { pkgJson: parsed, manifest };
-}
-function writePackageManifest(projectDir, project) {
-  const next = {
-    ...project.pkgJson,
-    lotics: {
-      ...isPlainObject2(project.pkgJson.lotics) ? project.pkgJson.lotics : {},
-      package: project.manifest
-    }
-  };
-  writeFileAtomic(
-    packageJsonPath(projectDir),
-    new TextEncoder().encode(JSON.stringify(next, null, 2) + "\n")
-  );
+  return { app_id, knowledge };
 }
-function sanitizePackageJsonForSource(pkgJson) {
-  const lotics = isPlainObject2(pkgJson.lotics) ? pkgJson.lotics : {};
-  const pkg2 = isPlainObject2(lotics.package) ? lotics.package : {};
-  const { dev: _dev, ...pkgWithoutDev } = pkg2;
-  return {
-    ...pkgJson,
-    lotics: { ...lotics, package: pkgWithoutDev }
-  };
-}
-function draftPackageProjectFromApp(appPkgJson, args) {
-  const { lotics: _appManifest, ...rest } = appPkgJson;
-  return {
-    pkgJson: rest,
-    manifest: {
-      id: null,
-      name: args.name,
-      description: args.description,
-      // Extraction promotes a bespoke APP to a package — always app kind.
-      kind: "app",
-      version: null,
-      knowledge: {},
-      templates: {},
-      knowledge_expects: [],
-      dev: {}
-    }
-  };
-}
-function parseAdoptBindingFile(raw, expectedAppId) {
-  if (!isPlainObject2(raw) || typeof raw.app_id !== "string" || typeof raw.workspace_id !== "string" || !isPlainObject2(raw.binding)) {
-    throw new Error(
-      "Malformed .lotics/adopt_binding.json \u2014 expected { app_id, workspace_id, binding }."
-    );
-  }
-  if (raw.app_id !== expectedAppId) {
-    throw new Error(
-      `.lotics/adopt_binding.json records app ${raw.app_id}, but you are adopting ${expectedAppId}. A binding maps one app's concrete ids and must never be applied to another \u2014 run "lotics package extract ${expectedAppId}" to produce the right pin.`
-    );
-  }
-  const knowledge_binding = {};
-  if (isPlainObject2(raw.knowledge_binding)) {
-    for (const [alias, id] of Object.entries(raw.knowledge_binding)) {
-      if (typeof id === "string") knowledge_binding[alias] = id;
+function parseRenameFlags(renames) {
+  return renames.map((entry) => {
+    const eq = entry.indexOf("=");
+    if (eq <= 0 || eq === entry.length - 1) {
+      throw new Error(`Invalid --rename "${entry}" \u2014 expected old=new (an alias to rename before v1 freezes it).`);
     }
-  }
-  return {
-    app_id: raw.app_id,
-    workspace_id: raw.workspace_id,
-    binding: raw.binding,
-    knowledge_binding
-  };
+    return { from: entry.slice(0, eq), to: entry.slice(eq + 1) };
+  });
 }
 function formatExtractReport(report) {
   const order = ["error", "warning", "info"];
@@ -50666,573 +50171,32 @@ function formatExtractReport(report) {
   );
   return { lines, hasError: report.some((f) => f.severity === "error") };
 }
-function dotLoticsDirEnsured(projectDir) {
-  const dir = path7.join(projectDir, ".lotics");
-  fs6.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function cmpVersions(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
-  for (let i2 = 0; i2 < 3; i2++) {
-    const d = (pa[i2] || 0) - (pb[i2] || 0);
-    if (d !== 0) return d;
-  }
-  return 0;
-}
-function packageSdkRange(sdkLatest) {
-  const version2 = sdkLatest !== null && cmpVersions(sdkLatest, STARTER_FALLBACK_SDK_VERSION) > 0 ? sdkLatest : STARTER_FALLBACK_SDK_VERSION;
-  return `^${version2}`;
-}
-function readContract(projectDir) {
-  const contractPath = path7.join(projectDir, CONTRACT_FILE);
-  if (!fs6.existsSync(contractPath)) {
-    throw new Error(
-      `No ${CONTRACT_FILE} in ${projectDir}. A package project declares its data model there.`
-    );
-  }
-  return JSON.parse(fs6.readFileSync(contractPath, "utf-8"));
-}
-function foldKnowledgeIntoContract(projectDir, project, contract) {
-  const aliases = Object.keys(project.manifest.knowledge);
-  const expects = project.manifest.knowledge_expects;
-  if (aliases.length === 0 && expects.length === 0) return contract;
-  const knowledge = {};
-  for (const alias of aliases) {
-    const entry = project.manifest.knowledge[alias];
-    const contentRef = `knowledge/${alias}.md`;
-    const filePath = path7.join(projectDir, "knowledge", `${alias}.md`);
-    if (!fs6.existsSync(filePath)) {
-      throw new Error(
-        `Declared knowledge doc "${alias}" (lotics.package.knowledge) has no ${contentRef} in the project. Create the file, or remove the manifest entry.`
-      );
-    }
-    const bytes = fs6.readFileSync(filePath);
-    knowledge[alias] = {
-      name: entry.name,
-      description: entry.description ?? "",
-      content_ref: contentRef,
-      content_sha256: createHash("sha256").update(bytes).digest("hex"),
-      active_by_default: entry.active_by_default
-    };
-  }
-  return { ...contract, knowledge, knowledge_expects: expects };
-}
-function foldTemplatesIntoContract(projectDir, project, contract) {
-  if (!isPlainObject2(contract)) {
-    throw new Error(`${CONTRACT_FILE} in ${projectDir} must be a JSON object.`);
-  }
-  const aliases = Object.keys(project.manifest.templates);
-  if (aliases.length === 0) return contract;
-  const existing = Array.isArray(contract.templates) ? contract.templates : [];
-  const existingAliases = new Set(
-    existing.filter((t) => isPlainObject2(t)).map((t) => t.alias).filter((a) => typeof a === "string")
-  );
-  const folded = aliases.map((alias) => {
-    if (existingAliases.has(alias)) {
-      throw new Error(
-        `Template alias "${alias}" is declared in both lotics.package.templates and ${CONTRACT_FILE} \u2014 declare each template once.`
-      );
-    }
-    const entry = project.manifest.templates[alias];
-    const filePath = path7.join(projectDir, "templates", entry.file);
-    if (!fs6.existsSync(filePath)) {
-      throw new Error(
-        `Declared template "${alias}" (lotics.package.templates) has no templates/${entry.file} in the project. Stage the file, then rebuild.`
-      );
-    }
-    if (entry.type === "html" || entry.type === "email") {
-      return { alias, label: entry.name, type: entry.type, content: fs6.readFileSync(filePath, "utf-8") };
-    }
-    return { alias, label: entry.name, type: entry.type, bytes_ref: `templates/${entry.file}` };
-  });
-  return { ...contract, templates: [...existing, ...folded] };
-}
-function foldTemplateShasIntoContract(projectDir, contract) {
-  const templates = contract.templates;
-  if (!Array.isArray(templates) || templates.length === 0) return contract;
-  const withShas = templates.map((template) => {
-    if (!isPlainObject2(template) || typeof template.type !== "string" || typeof template.alias !== "string") {
-      return template;
-    }
-    if (template.type === "html" || template.type === "email") {
-      if (typeof template.content !== "string") {
-        throw new Error(`Inline template "${template.alias}" must carry a string "content".`);
-      }
-      return {
-        ...template,
-        content_sha256: createHash("sha256").update(Buffer.from(template.content, "utf-8")).digest("hex")
-      };
-    }
-    if (typeof template.bytes_ref !== "string") {
-      throw new Error(`File-backed template "${template.alias}" must carry a string "bytes_ref".`);
-    }
-    const filePath = path7.join(projectDir, template.bytes_ref);
-    if (!fs6.existsSync(filePath)) {
-      throw new Error(
-        `Template "${template.alias}" references "${template.bytes_ref}", which is not in the project. Stage the file, then rebuild.`
-      );
-    }
-    const bytes = fs6.readFileSync(filePath);
-    return { ...template, content_sha256: createHash("sha256").update(bytes).digest("hex") };
-  });
-  return { ...contract, templates: withShas };
-}
-function writePackageAppFields(projectDir) {
-  const contract = readContract(projectDir);
-  const dotLotics = path7.join(projectDir, ".lotics");
-  fs6.mkdirSync(dotLotics, { recursive: true });
-  fs6.writeFileSync(path7.join(dotLotics, "app_fields.ts"), generatePackageAppFields(contract));
-  console.error("Wrote .lotics/app_fields.ts (contract-derived, runtime-resolved)");
-}
-var SOURCE_STAGE_EXCLUDES = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  ".lotics",
-  ".git",
-  "bundle.tar.gz",
-  "package.json"
-]);
-function stagePackageSource(projectDir, sourceStage) {
-  const project = readPackageProject(projectDir);
-  fs6.mkdirSync(sourceStage, { recursive: true });
-  for (const entry of fs6.readdirSync(projectDir)) {
-    if (SOURCE_STAGE_EXCLUDES.has(entry) || entry.endsWith(".tsbuildinfo")) continue;
-    fs6.cpSync(path7.join(projectDir, entry), path7.join(sourceStage, entry), { recursive: true });
-  }
-  fs6.writeFileSync(
-    path7.join(sourceStage, "package.json"),
-    JSON.stringify(sanitizePackageJsonForSource(project.pkgJson), null, 2) + "\n"
-  );
-}
-async function buildPackageBundle(projectDir) {
-  const { manifest } = readPackageProject(projectDir);
-  const stage = fs6.mkdtempSync(path7.join(tmpdir2(), "lotics-pkg-"));
-  const bundlePath = path7.join(tmpdir2(), `lotics-bundle-${Date.now()}.tar.gz`);
-  try {
-    let distDir;
-    if (manifest.kind === "content") {
-      console.error("Content package \u2014 skipping app build.");
-      distDir = path7.join(stage, "empty-dist");
-      fs6.mkdirSync(distDir, { recursive: true });
-      fs6.writeFileSync(
-        path7.join(distDir, ".content-package"),
-        "Content package \u2014 no frontend bundle. Content ships in source.tar.gz under knowledge/.\n"
-      );
-    } else {
-      console.error("Building...");
-      await runNpm(["run", "build"], projectDir);
-      distDir = path7.join(projectDir, "dist");
-      if (!fs6.existsSync(distDir)) {
-        throw new Error(
-          `Build did not produce a dist/ directory in ${projectDir}. Check that 'npm run build' is configured correctly.`
-        );
-      }
-    }
-    console.error("Packaging source...");
-    const sourceStage = path7.join(stage, "source");
-    stagePackageSource(projectDir, sourceStage);
-    await runTar(["-czf", path7.join(stage, "source.tar.gz"), "-C", sourceStage, "."], projectDir);
-    console.error("Packaging dist...");
-    await runTar(["-czf", path7.join(stage, "dist.tar.gz"), "-C", distDir, "."], projectDir);
-    console.error("Bundling...");
-    await runTar(["-czf", bundlePath, "source.tar.gz", "dist.tar.gz"], stage);
-    return fs6.readFileSync(bundlePath);
-  } finally {
-    fs6.rmSync(stage, { recursive: true, force: true });
-    if (fs6.existsSync(bundlePath)) fs6.unlinkSync(bundlePath);
-  }
-}
-function starterContract(name) {
-  return {
-    entities: [
-      {
-        alias: "item",
-        label: name,
-        description: `Records managed by the ${name} package.`,
-        fields: [
-          { alias: "name", label: "Name", type: "text", required: true },
-          { alias: "notes", label: "Notes", type: "text" },
-          {
-            alias: "status",
-            label: "Status",
-            type: "select",
-            options: [
-              { alias: "open", label: "Open", color: "blue" },
-              { alias: "done", label: "Done", color: "green" }
-            ]
-          }
-        ]
-      }
-    ],
-    roles: [],
-    templates: [],
-    queries: [
-      {
-        alias: "items",
-        ast: {
-          kind: "from_table",
-          from_entity: "item",
-          sort: [{ field_key: "name", order: "asc" }]
-        }
-      }
-    ],
-    workflows: [],
-    agents: [],
-    config: [
-      { alias: "heading", label: "List heading", type: "text", default: name }
-    ]
-  };
-}
-function emptyContract() {
-  return {
-    entities: [],
-    roles: [],
-    templates: [],
-    queries: [],
-    workflows: [],
-    agents: [],
-    config: []
-  };
-}
-function scaffoldContentPackage(name, targetPath) {
-  const exampleAlias = "overview";
-  const manifest = {
-    id: null,
-    name,
-    description: null,
-    kind: "content",
-    version: null,
-    knowledge: {
-      [exampleAlias]: {
-        name: `${name} Overview`,
-        description: "What this corpus covers \u2014 replace with your doc's summary.",
-        active_by_default: true
-      }
-    },
-    // A content package can also ship standalone document templates — declare them
-    // under `lotics.package.templates` with the files in a `templates/` dir. See
-    // the commented example printed by the scaffold + docs/packages.md § Content.
-    templates: {},
-    knowledge_expects: [],
-    dev: {}
-  };
-  const pkgJson = {
-    name: appDirName(name),
-    private: true,
-    version: "0.0.0",
-    lotics: { package: manifest }
-  };
-  fs6.writeFileSync(
-    packageJsonPath(targetPath),
-    JSON.stringify(pkgJson, null, 2) + "\n"
-  );
-  fs6.writeFileSync(
-    path7.join(targetPath, CONTRACT_FILE),
-    JSON.stringify(emptyContract(), null, 2) + "\n"
-  );
-  const knowledgeDir = path7.join(targetPath, "knowledge");
-  fs6.mkdirSync(knowledgeDir, { recursive: true });
-  fs6.writeFileSync(
-    path7.join(knowledgeDir, `${exampleAlias}.md`),
-    `# ${name}
-
-Replace this file with the corpus content. Structure it under clear
-Markdown headers so an agent can outline and read it by section.
-`
-  );
-  console.error(`Scaffolded a content package into ${targetPath}`);
-  console.error(`
-Ready. Next steps:`);
-  console.error(`  cd ${path7.relative(process.cwd(), targetPath) || "."}`);
-  console.error(`  # add docs: create knowledge/<alias>.md + a lotics.package.knowledge.<alias> entry`);
-  console.error(`  #           (name/description/active_by_default), then publish:`);
-  console.error(`  # add templates: create templates/<file> + a lotics.package.templates.<alias> entry:`);
-  console.error(`  #   "templates": { "quote": { "name": "Quote", "type": "html", "file": "quote.html" } }`);
-  console.error(`  #   inline kinds html|email read templates/<file> as content; file-backed`);
-  console.error(`  #   excel|word|pdf-form pack the bytes into the bundle (bytes_ref = templates/<file>).`);
-  console.error(`  lotics package publish -m "v1"`);
-  console.error(`  lotics package install <package_id>`);
-}
-async function packageNew(args) {
-  const targetPath = path7.resolve(args.targetPath ?? appDirName(args.name));
-  if (fs6.existsSync(targetPath) && fs6.readdirSync(targetPath).length > 0) {
-    throw new Error(`Target directory ${targetPath} is not empty.`);
-  }
-  fs6.mkdirSync(targetPath, { recursive: true });
-  if ((args.kind ?? "app") === "content") {
-    scaffoldContentPackage(args.name, targetPath);
-    return;
-  }
-  const [uiLatest, sdkLatest] = await Promise.all([
-    fetchLatestNpmVersion("@lotics/ui"),
-    fetchLatestNpmVersion("@lotics/app-sdk")
-  ]);
-  const files = buildStarterTemplate({
-    app_name: args.name,
-    app_id: "",
-    workspace_id: "",
-    ui_version: uiLatest ? `^${uiLatest}` : void 0,
-    sdk_version: packageSdkRange(sdkLatest)
-  });
-  const overrides = new Map(
-    buildPackageStarterOverrides({ app_name: args.name }).map((f) => [f.path, f.content])
-  );
-  for (const file2 of files) {
-    const fullPath = path7.join(targetPath, file2.path);
-    if (file2.path === "package.json") {
-      const pkg2 = JSON.parse(file2.content);
-      const manifest = {
-        id: null,
-        name: args.name,
-        description: null,
-        kind: "app",
-        version: null,
-        knowledge: {},
-        templates: {},
-        knowledge_expects: [],
-        dev: {}
-      };
-      pkg2.lotics = { package: manifest };
-      fs6.mkdirSync(path7.dirname(fullPath), { recursive: true });
-      fs6.writeFileSync(fullPath, JSON.stringify(pkg2, null, 2) + "\n");
-      continue;
-    }
-    fs6.mkdirSync(path7.dirname(fullPath), { recursive: true });
-    fs6.writeFileSync(fullPath, overrides.get(file2.path) ?? file2.content);
-  }
-  fs6.writeFileSync(
-    path7.join(targetPath, CONTRACT_FILE),
-    JSON.stringify(starterContract(args.name), null, 2) + "\n"
-  );
-  writePackageAppFields(targetPath);
-  console.error(`Scaffolded ${files.length + 1} files into ${targetPath}`);
-  console.error("Installing npm dependencies...");
-  await runNpm(["install"], targetPath);
-  console.error(`
-Ready. Next steps:`);
-  console.error(`  cd ${path7.relative(process.cwd(), targetPath) || "."}`);
-  console.error(`  # edit contract.json + src/App.tsx, then run it against a dev workspace:`);
-  console.error(`  lotics workspace create "<name> dev" --dev`);
-  console.error(`  lotics package dev --workspace <dev_ws>`);
-}
-async function packageBuild(args) {
-  const projectDir = path7.resolve(args.projectDir ?? process.cwd());
-  readPackageProject(projectDir);
-  const bundle = await buildPackageBundle(projectDir);
-  const out = path7.join(projectDir, "bundle.tar.gz");
-  fs6.writeFileSync(out, bundle);
-  console.error(`Built ${out} (${(bundle.byteLength / 1024).toFixed(1)} KB)`);
-}
-async function publishVersion(client, projectDir, opts) {
-  const project = readPackageProject(projectDir);
-  const rawContract = readContract(projectDir);
-  if (!isPlainObject2(rawContract)) {
-    throw new Error(`${CONTRACT_FILE} in ${projectDir} must be a JSON object.`);
-  }
-  const contract = foldTemplateShasIntoContract(
-    projectDir,
-    foldKnowledgeIntoContract(
-      projectDir,
-      project,
-      foldTemplatesIntoContract(projectDir, project, rawContract)
-    )
-  );
-  let packageId = project.manifest.id;
-  if (packageId === null) {
-    const pkg2 = await client.createPackage({
-      name: project.manifest.name,
-      description: project.manifest.description,
-      // Kind is fixed at package creation and immutable after — a knowledge
-      // package must be created as such so publish enforces its constraint.
-      kind: project.manifest.kind
-    });
-    packageId = pkg2.id;
-    project.manifest.id = packageId;
-    writePackageManifest(projectDir, project);
-    console.error(`Created package ${pkg2.name} (${pkg2.id}).`);
-  }
-  const bundle = await buildPackageBundle(projectDir);
-  console.error("Publishing version...");
-  const version2 = await client.publishPackageVersion(packageId, {
-    contract,
-    bundle,
-    changelog: opts.changelog ?? null,
-    channel: opts.channel ?? "release"
-  });
-  project.manifest.version = version2.version;
-  writePackageManifest(projectDir, project);
-  return { package_id: packageId, version: version2.version };
-}
-async function packagePublish(client, args) {
-  const projectDir = path7.resolve(args.projectDir ?? process.cwd());
-  const { package_id, version: version2 } = await publishVersion(client, projectDir, {
-    changelog: args.changelog
-  });
-  console.error(`Published ${package_id} v${version2}.`);
-  console.error(`  Install it:  lotics package install ${package_id} --version ${version2}`);
-}
-function assertDevWorkspace(workspace) {
-  if (workspace.is_dev === true) return;
-  throw new Error(
-    `Workspace "${workspace.name}" (${workspace.id}) is not a dev workspace. "lotics package dev"/"sync" scaffold package tables into the target workspace, so it must be a throwaway dev workspace. Create one with "lotics workspace create <name> --dev" and pass --workspace <dev_ws>.`
-  );
-}
-async function syncToDevWorkspace(client, projectDir) {
-  const devWorkspaceId = client.getWorkspaceId();
-  if (!devWorkspaceId) {
-    throw new Error(
-      "No dev workspace selected. Pass --workspace <dev_ws> (a workspace created with --dev)."
-    );
-  }
-  const workspace = await client.getWorkspaceInfo(devWorkspaceId);
-  if (!workspace) {
-    throw new Error(
-      `Workspace ${devWorkspaceId} is not accessible with these credentials. Pass --workspace <dev_ws> (a workspace created with --dev).`
-    );
-  }
-  assertDevWorkspace(workspace);
-  writePackageAppFields(projectDir);
-  const { package_id, version: version2 } = await publishVersion(client, projectDir, {
-    changelog: "dev sync",
-    channel: "dev"
-  });
-  const project = readPackageProject(projectDir);
-  const existing = project.manifest.dev[devWorkspaceId];
-  let appId;
-  if (existing) {
-    console.error(`Upgrading dev installation ${existing.app_id} \u2192 v${version2}...`);
-    const app = await client.upgradePackage(existing.app_id, { version: version2 });
-    appId = app.id;
-  } else {
-    console.error(`Installing ${package_id} v${version2} into dev workspace ${devWorkspaceId}...`);
-    const result = await client.installPackage(package_id, { version: version2 });
-    if (result.kind !== "app") {
-      throw new Error(
-        `Package ${package_id} is a content package \u2014 "lotics package dev/sync" run an app installation. Install a content package with "lotics package install ${package_id}".`
-      );
-    }
-    appId = result.app.id;
-  }
-  project.manifest.dev[devWorkspaceId] = { app_id: appId, version: version2 };
-  writePackageManifest(projectDir, project);
-  const installed = await client.getApp(appId);
-  writeAppDts(projectDir, {
-    workflows: installed.workflows ?? void 0,
-    queries: installed.queries ?? void 0,
-    agents: installed.agents ?? void 0
-  });
-  return { app_id: appId, app_name: installed.name, workspace_id: devWorkspaceId, version: version2 };
-}
-async function packageSync(client, args) {
-  const projectDir = path7.resolve(args.projectDir ?? process.cwd());
-  const result = await syncToDevWorkspace(client, projectDir);
-  console.error(
-    `Synced ${result.app_name} v${result.version} \u2192 ${result.app_id} (workspace ${result.workspace_id}).`
-  );
-}
-async function packageDev(client, args) {
-  const projectDir = path7.resolve(args.projectDir ?? process.cwd());
-  const synced = await syncToDevWorkspace(client, projectDir);
-  const handle = await startDevServer({
-    projectDir,
-    app_id: synced.app_id,
-    app_name: synced.app_name,
-    workspace_id: synced.workspace_id,
-    api_url: client.baseUrl,
-    port: args.port,
-    vitePort: args.vitePort,
-    client
-  });
-  await handle.ready;
-  const url2 = `http://localhost:${handle.port}`;
-  console.error(`
-  lotics package dev`);
-  console.error(`  package:   ${synced.app_name} (dev installation ${synced.app_id} v${synced.version})`);
-  console.error(`  workspace: ${synced.workspace_id} (dev)`);
-  if (client.viewAsMemberId) {
-    console.error(`  view as:   ${client.viewAsMemberId}`);
-  }
-  console.error(`  vite:      http://localhost:${handle.vitePort}/`);
-  console.error(`  open:      ${url2}`);
-  console.error(`  rpc:       ${client.baseUrl} (via Bearer API key)
-`);
-  console.error(`  Edit contract.json then re-run "lotics package dev" / "lotics package sync" to migrate.`);
-  console.error(`  Ctrl-C to stop.
-`);
-  openBrowser(url2);
-  await new Promise((resolve2) => {
-    const onSig = () => {
-      process.off("SIGINT", onSig);
-      process.off("SIGTERM", onSig);
-      resolve2();
-    };
-    process.on("SIGINT", onSig);
-    process.on("SIGTERM", onSig);
-  });
-  console.error("\nStopping\u2026");
-  await handle.stop();
-}
-async function packageReset(client, args) {
-  const projectDir = path7.resolve(args.projectDir ?? process.cwd());
-  const devWorkspaceId = client.getWorkspaceId();
-  if (!devWorkspaceId) {
-    throw new Error(
-      "No dev workspace selected. Pass --workspace <dev_ws> (a workspace created with --dev)."
-    );
-  }
-  const { manifest } = readPackageProject(projectDir);
-  const pin = manifest.dev[devWorkspaceId];
-  if (!pin) {
-    throw new Error(
-      `No dev installation recorded for workspace ${devWorkspaceId}. Run "lotics package dev --workspace ${devWorkspaceId}" first.`
-    );
-  }
-  console.error(`Resetting dev installation ${pin.app_id} in workspace ${devWorkspaceId}...`);
-  const app = await client.resetPackage(pin.app_id);
-  console.error(`Reset ${app.name} \u2192 ${app.id}. The scaffolded tables were dropped and re-created clean.`);
-}
-function resolveInstallationAppId(client, explicit) {
+function resolveInstallationAppId(explicit) {
   if (explicit) return explicit;
-  const workspaceId = client.getWorkspaceId();
-  if (!workspaceId) {
-    throw new Error("Pass an app id (lotics package doctor <app_id>) or select a workspace.");
-  }
-  let manifest;
-  try {
-    ({ manifest } = readPackageProject(path7.resolve(process.cwd())));
-  } catch {
-    throw new Error(
-      "No app id given and the current directory is not a package project. Pass one explicitly: lotics package doctor <app_id>."
-    );
-  }
-  const pin = manifest.dev[workspaceId];
-  if (!pin) {
-    throw new Error(
-      `No app id given and no dev installation recorded for workspace ${workspaceId}. Pass one explicitly: lotics package doctor <app_id>.`
-    );
-  }
-  return pin.app_id;
+  throw new Error("Pass an app id \u2014 e.g. lotics package doctor <app_id>.");
 }
+var RESOLVE_VERBS = /* @__PURE__ */ new Set(["recreate", "revert", "keep", "apply", "archive", "unbind"]);
 function parseResolveFlags(resolve2) {
   const resolutions = {};
   for (const entry of resolve2) {
     const eq = entry.indexOf("=");
     if (eq <= 0 || eq === entry.length - 1) {
       throw new Error(
-        `Invalid --resolve "${entry}" \u2014 expected <key>=recreate|revert|keep or <key>=<existing_id>.`
+        `Invalid --resolve "${entry}" \u2014 expected <key>=<verb> (recreate|revert|keep|apply|archive|unbind) or <key>=<existing_id>.`
       );
     }
     const key = entry.slice(0, eq);
     const value = entry.slice(eq + 1);
-    resolutions[key] = value === "recreate" || value === "revert" || value === "keep" ? value : { bind_to: value };
+    resolutions[key] = RESOLVE_VERBS.has(value) ? value : { bind_to: value };
   }
   return resolutions;
 }
 async function packageDoctor(client, args) {
-  const app_id = resolveInstallationAppId(client, args.app_id);
+  const app_id = resolveInstallationAppId(args.app_id);
   const health = await client.getPackageHealth(app_id);
-  console.error(`${health.package_name} \u2014 installation ${health.app_id}`);
+  console.error(
+    `${health.package_name} \u2014 installation ${health.app_id}` + (health.is_origin ? " (origin \u2014 this app IS installation #1, the release working copy)" : "")
+  );
   console.error(
     `  Installed: v${health.installed_version}   Latest: v${health.latest_version}` + (health.update_available ? "   \u2192 update available" : "")
   );
@@ -51245,12 +50209,22 @@ async function packageDoctor(client, args) {
     }
     console.error(
       `  Resolve while upgrading:
-    lotics package upgrade ${app_id} --resolve <namespace.alias>=recreate   (or =<existing_id> to re-point)`
+    lotics upgrade ${app_id} --resolve <namespace.alias>=recreate   (or =<existing_id> to re-point)`
     );
     process.exitCode = 1;
   }
   if (health.modified.length === 0) {
-    console.error("  Package artifacts: pristine \u2014 no local edits an upgrade would revert.");
+    console.error(
+      health.is_origin ? "  Package artifacts: no changes since the last release." : "  Package artifacts: pristine \u2014 no local edits an upgrade would revert."
+    );
+  } else if (health.is_origin) {
+    console.error(
+      `  Changed since v${health.installed_version} (${health.modified.length}) \u2014 a release will publish these:`
+    );
+    for (const m of health.modified) {
+      console.error(`    - ${m.kind}.${m.alias}`);
+    }
+    console.error(`  Cut the next version:  lotics app release ${app_id} -m "<what changed>"`);
   } else {
     console.error(`  Locally modified package artifacts (${health.modified.length}):`);
     for (const m of health.modified) {
@@ -51258,7 +50232,7 @@ async function packageDoctor(client, args) {
     }
     console.error(
       `  Consent while upgrading:
-    lotics package upgrade ${app_id} --resolve <kind.alias>=revert   (or =keep to retain the edit)`
+    lotics upgrade ${app_id} --resolve <kind.alias>=revert   (or =keep to retain the edit)`
     );
     process.exitCode = 1;
   }
@@ -51269,9 +50243,18 @@ async function packageDoctor(client, args) {
     }
   }
   if (health.knowledge_modified.length > 0) {
-    console.error(`  Locally edited package knowledge (${health.knowledge_modified.length}):`);
-    for (const m of health.knowledge_modified) {
-      console.error(`    - ${m.alias} "${m.name}" (an upgrade overwrites this unless kept)`);
+    if (health.is_origin) {
+      console.error(
+        `  Knowledge changed since v${health.installed_version} (${health.knowledge_modified.length}) \u2014 a release will re-snapshot these:`
+      );
+      for (const m of health.knowledge_modified) {
+        console.error(`    - ${m.alias} "${m.name}"`);
+      }
+    } else {
+      console.error(`  Locally edited package knowledge (${health.knowledge_modified.length}):`);
+      for (const m of health.knowledge_modified) {
+        console.error(`    - ${m.alias} "${m.name}" (an upgrade overwrites this unless kept)`);
+      }
     }
   }
   if (health.missing_expected_docs.length > 0) {
@@ -51280,14 +50263,14 @@ async function packageDoctor(client, args) {
       console.error(`    - "${name}" (the package's agents route to this name; no matching doc exists)`);
     }
   }
-  if (health.knowledge_drift.length > 0 || health.knowledge_modified.length > 0) {
+  if (health.knowledge_drift.length > 0 || health.knowledge_modified.length > 0 && !health.is_origin) {
     process.exitCode = 1;
   }
   if (health.knowledge_drift.length === 0 && health.knowledge_modified.length === 0 && health.missing_expected_docs.length === 0) {
     console.error("  Knowledge: healthy \u2014 bound docs resolve, none locally edited, expects met.");
   }
   if (health.update_available) {
-    console.error(`  Upgrade: lotics package upgrade ${app_id}`);
+    console.error(`  Upgrade: lotics upgrade ${app_id}`);
   }
 }
 async function packageUpgrade(client, args) {
@@ -51322,27 +50305,17 @@ async function packageUpgrade(client, args) {
     );
     process.exit(1);
   }
-  const coreKeys = /* @__PURE__ */ new Set([
-    ...preview.drift.map((d) => `${d.namespace}.${d.alias}`),
-    ...preview.modified.map((m) => `${m.kind}.${m.alias}`)
-  ]);
-  const { coreResolve, knowledgeResolutions } = routeAppUpgradeResolve(
-    args.resolve,
-    preview.knowledge,
-    coreKeys
-  );
-  const resolutions = parseResolveFlags(coreResolve);
+  const resolutions = parseResolveFlags(args.resolve);
+  for (const [alias, id] of Object.entries(parseBindToFlags(args.bindTo))) {
+    resolutions[`knowledge.${alias}`] = { bind_to: id };
+  }
   if (args.applyAll) {
     for (const entry of preview.knowledge) {
-      if (knowledgeEntryNeedsConsent(entry) && knowledgeResolutions[entry.alias] === void 0) {
-        knowledgeResolutions[entry.alias] = knowledgeAcceptResolution(entry.change);
+      if (knowledgeEntryNeedsConsent(entry) && resolutions[`knowledge.${entry.alias}`] === void 0) {
+        resolutions[`knowledge.${entry.alias}`] = knowledgeAcceptResolution(entry.change);
       }
     }
   }
-  const knowledge_resolutions = {
-    resolutions: knowledgeResolutions,
-    bind_to: parseBindToFlags(args.bindTo)
-  };
   const unresolvedDrift = preview.drift.filter(
     (d) => resolutions[`${d.namespace}.${d.alias}`] === void 0
   );
@@ -51350,7 +50323,7 @@ async function packageUpgrade(client, args) {
     (m) => resolutions[`${m.kind}.${m.alias}`] === void 0
   );
   const unresolvedKnowledge = preview.knowledge.filter(
-    (e) => knowledgeEntryNeedsConsent(e) && knowledgeResolutions[e.alias] === void 0
+    (e) => knowledgeEntryNeedsConsent(e) && resolutions[`knowledge.${e.alias}`] === void 0
   );
   if (unresolvedDrift.length > 0 || unresolvedModified.length > 0 || unresolvedKnowledge.length > 0) {
     if (unresolvedDrift.length > 0) {
@@ -51379,11 +50352,9 @@ async function packageUpgrade(client, args) {
     }
     process.exit(1);
   }
-  const hasKnowledgeResolutions = Object.keys(knowledge_resolutions.resolutions).length > 0 || Object.keys(knowledge_resolutions.bind_to).length > 0;
   const app = await client.upgradePackage(args.app_id, {
     ...args.version !== void 0 ? { version: args.version } : {},
-    ...Object.keys(resolutions).length > 0 ? { resolutions } : {},
-    ...hasKnowledgeResolutions ? { knowledge_resolutions } : {}
+    ...Object.keys(resolutions).length > 0 ? { resolutions } : {}
   });
   console.error(`Upgraded ${app.name} \u2192 v${app.package_version} (${app.id}).`);
 }
@@ -51433,82 +50404,11 @@ function formatKnowledgeEntryLine(entry) {
 }
 function formatKnowledgeResolveHint(entry) {
   const note = entry.change === "changed" || entry.change === "removed" ? "   (a local edit \u2014 apply/archive overwrites it; keep retains it)" : "   (bound doc is gone; recreate from the package, or unbind)";
-  return `    --resolve ${entry.alias}=${validKnowledgeResolutions(entry.change).join("|")}${note}`;
-}
-function routeAppUpgradeResolve(resolve2, knowledgeEntries, coreKeys) {
-  const byAlias = new Map(knowledgeEntries.map((e) => [e.alias, e]));
-  const coreResolve = [];
-  const knowledgeResolutions = {};
-  for (const entry of resolve2) {
-    const eq = entry.indexOf("=");
-    if (eq <= 0 || eq === entry.length - 1) {
-      throw new Error(`Invalid --resolve "${entry}" \u2014 expected <key>=<value>.`);
-    }
-    const key = entry.slice(0, eq);
-    const value = entry.slice(eq + 1);
-    const known = byAlias.get(key);
-    if (known && coreKeys.has(key)) {
-      throw new Error(
-        `--resolve "${key}" is ambiguous \u2014 it names both a bundled knowledge doc and a core artifact in this upgrade. Rename one alias so it is unambiguous; refusing to guess.`
-      );
-    }
-    if (known) {
-      const valid = validKnowledgeResolutions(known.change);
-      const match = valid.find((v) => v === value);
-      if (match === void 0) {
-        throw new Error(
-          `Invalid --resolve value "${value}" for knowledge doc "${key}" (${known.change}) \u2014 expected ${valid.join("|")}.`
-        );
-      }
-      knowledgeResolutions[key] = match;
-    } else {
-      coreResolve.push(entry);
-    }
-  }
-  return { coreResolve, knowledgeResolutions };
-}
-function routeContentResolveFlags(resolve2, knowledgeAliases, templateAliases) {
-  const knowledge = {};
-  const templates = {};
-  const knowledgeValid = /* @__PURE__ */ new Set(["apply", "keep", "archive", "recreate", "unbind"]);
-  const templateValid = /* @__PURE__ */ new Set(["revert", "keep"]);
-  for (const entry of resolve2) {
-    const eq = entry.indexOf("=");
-    if (eq <= 0 || eq === entry.length - 1) {
-      throw new Error(`Invalid --resolve "${entry}" \u2014 expected <alias>=<value>.`);
-    }
-    const key = entry.slice(0, eq);
-    const value = entry.slice(eq + 1);
-    const isKnowledge = knowledgeAliases.has(key);
-    const isTemplate = templateAliases.has(key);
-    if (isKnowledge && isTemplate) {
-      throw new Error(
-        `--resolve "${key}" is ambiguous \u2014 it names both a knowledge doc and a template in this upgrade. Rename one alias in the package so the two content namespaces are disjoint.`
-      );
-    }
-    if (isTemplate) {
-      if (!templateValid.has(value)) {
-        throw new Error(`Invalid --resolve value "${value}" for template "${key}" \u2014 expected revert|keep.`);
-      }
-      templates[key] = value;
-      continue;
-    }
-    if (isKnowledge) {
-      if (!knowledgeValid.has(value)) {
-        throw new Error(
-          `Invalid --resolve value "${value}" for knowledge alias "${key}" \u2014 expected apply|keep|archive|recreate|unbind.`
-        );
-      }
-      knowledge[key] = value;
-      continue;
-    }
-    throw new Error(`--resolve "${key}" does not name a knowledge doc or template in this upgrade.`);
-  }
-  return { knowledge, templates };
+  return `    --resolve knowledge.${entry.alias}=${validKnowledgeResolutions(entry.change).join("|")}${note}`;
 }
 function formatTemplateResolveHint(entry) {
   const note = entry.baseline_unknown ? "   (can't verify the local edit \u2014 older package version; revert overwrites, keep retains)" : "   (a local edit \u2014 revert overwrites it with the package's version; keep retains it)";
-  return `    --resolve ${entry.alias}=revert|keep${note}`;
+  return `    --resolve template.${entry.alias}=revert|keep${note}`;
 }
 async function packageUpgradeKnowledge(client, args) {
   const preview = await client.previewContentInstallationUpgrade(args.installation_id, {
@@ -51532,7 +50432,7 @@ async function packageUpgradeKnowledge(client, args) {
     console.error(
       "  No changes needing consent \u2014 advancing the version pin; clean template updates apply automatically."
     );
-    await apply({ knowledge: { resolutions: {}, bind_to: {} }, templates: {} });
+    await apply({});
     return;
   }
   for (const entry of preview.entries) {
@@ -51541,30 +50441,27 @@ async function packageUpgradeKnowledge(client, args) {
   for (const entry of preview.templates) {
     console.error(`  [template] ${entry.alias} (modified \u2014 needs consent)`);
   }
-  const routed = routeContentResolveFlags(
-    args.resolve,
-    new Set(preview.entries.map((e) => e.alias)),
-    new Set(preview.templates.map((t) => t.alias))
-  );
-  const resolutions = {
-    knowledge: { resolutions: { ...routed.knowledge }, bind_to: { ...args.bind_to } },
-    templates: { ...routed.templates }
-  };
+  const resolutions = parseResolveFlags(args.resolve);
+  for (const [alias, id] of Object.entries(args.bind_to)) {
+    resolutions[`knowledge.${alias}`] = { bind_to: id };
+  }
   if (args.applyAll) {
     for (const entry of preview.entries) {
-      if (knowledgeEntryNeedsConsent(entry) && resolutions.knowledge.resolutions[entry.alias] === void 0) {
-        resolutions.knowledge.resolutions[entry.alias] = knowledgeAcceptResolution(entry.change);
+      if (knowledgeEntryNeedsConsent(entry) && resolutions[`knowledge.${entry.alias}`] === void 0) {
+        resolutions[`knowledge.${entry.alias}`] = knowledgeAcceptResolution(entry.change);
       }
     }
     for (const entry of preview.templates) {
-      if (resolutions.templates[entry.alias] === void 0) resolutions.templates[entry.alias] = "revert";
+      if (resolutions[`template.${entry.alias}`] === void 0) {
+        resolutions[`template.${entry.alias}`] = "revert";
+      }
     }
   }
   const unresolvedKnowledge = preview.entries.filter(
-    (entry) => knowledgeEntryNeedsConsent(entry) && resolutions.knowledge.resolutions[entry.alias] === void 0
+    (entry) => knowledgeEntryNeedsConsent(entry) && resolutions[`knowledge.${entry.alias}`] === void 0
   );
   const unresolvedTemplates = preview.templates.filter(
-    (entry) => resolutions.templates[entry.alias] === void 0
+    (entry) => resolutions[`template.${entry.alias}`] === void 0
   );
   if (unresolvedKnowledge.length > 0 || unresolvedTemplates.length > 0) {
     console.error(
@@ -51624,8 +50521,8 @@ async function packageInstall(client, args) {
       );
     }
     warnMissingExpectedDocs(warnings.missing_expected_docs);
-    console.error(`  Upgrade later:  lotics package upgrade ${installation.id}`);
-    console.error(`  Uninstall:      lotics package uninstall ${installation.id} [--keep-content]`);
+    console.error(`  Upgrade later:  lotics upgrade ${installation.id}`);
+    console.error(`  Uninstall:      lotics uninstall ${installation.id} [--keep-content]`);
     return;
   }
   const { app, knowledge_warnings } = result;
@@ -51633,7 +50530,9 @@ async function packageInstall(client, args) {
   console.error(`Installed ${app.name} ${versionLabel} \u2192 ${app.id} (workspace ${app.workspace_id}).`);
   console.error("  The data model, queries, workflows, and agents are live.");
   warnMissingExpectedDocs(knowledge_warnings.missing_expected_docs);
-  console.error("  Pull it for local editing:  lotics app pull " + app.id);
+  console.error(`  Pull it for local editing:  lotics app pull ${app.id}`);
+  console.error(`  Upgrade later:              lotics upgrade ${app.id}`);
+  console.error(`  Health / uninstall:         lotics package doctor ${app.id}  \xB7  lotics uninstall ${app.id} [--archive-tables]`);
 }
 async function packageUninstall(client, args) {
   if (args.id.startsWith("pci_")) {
@@ -51702,10 +50601,9 @@ async function packageListContent(client) {
     const name = inst.package_registry?.name ?? "(unknown package)";
     const latest = inst.package_registry?.latest_version;
     const updateAvailable = inst.package_registry?.update_available ?? false;
-    const source = inst.app_id === null ? "standalone" : `app-bundled (${inst.app_id})`;
     const versionLabel = latest !== void 0 && latest !== inst.package_version ? `v${inst.package_version} \u2192 latest v${latest}` : `v${inst.package_version}`;
     console.error(
-      `  ${inst.id}  ${name}  ${versionLabel}  ${source}` + (updateAvailable ? "  \u2192 update available" : "")
+      `  ${inst.id}  ${name}  ${versionLabel}` + (updateAvailable ? "  \u2192 update available" : "")
     );
   }
 }
@@ -51781,200 +50679,134 @@ async function packageConfig(client, args) {
     console.log(`  ${key} = ${JSON.stringify(config2[key])}${marker}`);
   }
 }
-async function packageRetire(client, args) {
-  const pkg2 = await client.retirePackage(args.package_id, { undo: args.undo });
+async function appUnpublish(client, args) {
+  let packageId = args.id;
+  if (args.id.startsWith("app_")) {
+    const app = await client.getApp(args.id);
+    if (!app.package_id) {
+      throw new Error(
+        `App ${args.id} is not a package installation \u2014 it has no package to unpublish. Pass the package id directly.`
+      );
+    }
+    packageId = app.package_id;
+  }
+  const pkg2 = await client.retirePackage(packageId, { undo: args.undo });
   if (pkg2.retired_at !== null) {
     console.error(
-      `Retired ${pkg2.name} (${pkg2.id}). New installs refuse it and it is hidden from other orgs; existing installations keep working and may still upgrade.`
+      `Unpublished ${pkg2.name} (${pkg2.id}). New installs refuse it and it is hidden from other orgs; existing installations keep working and may still upgrade. Undo: lotics app unpublish ${pkg2.id} --undo`
     );
   } else {
-    console.error(`Un-retired ${pkg2.name} (${pkg2.id}) \u2014 installable again.`);
+    console.error(`Re-published ${pkg2.name} (${pkg2.id}) \u2014 installable again.`);
   }
 }
-function readAppKnowledgeDeclaration(appPkgJson) {
-  const lotics = isPlainObject2(appPkgJson.lotics) ? appPkgJson.lotics : {};
-  const knowledge = [];
-  if (Array.isArray(lotics.knowledge)) {
-    for (const entry of lotics.knowledge) {
-      if (isPlainObject2(entry) && typeof entry.alias === "string" && typeof entry.doc_id === "string") {
-        knowledge.push({ alias: entry.alias, doc_id: entry.doc_id });
-      }
-    }
-  }
-  const knowledge_expects = Array.isArray(lotics.knowledge_expects) ? lotics.knowledge_expects.filter((v) => typeof v === "string") : [];
-  return { knowledge, knowledge_expects };
-}
-function knowledgeManifestFromContract(contract) {
-  const out = {};
-  if (!isPlainObject2(contract) || !isPlainObject2(contract.knowledge)) return out;
-  for (const [alias, entry] of Object.entries(contract.knowledge)) {
-    if (!isPlainObject2(entry) || typeof entry.name !== "string") continue;
-    out[alias] = {
-      name: entry.name,
-      description: typeof entry.description === "string" ? entry.description : null,
-      active_by_default: typeof entry.active_by_default === "boolean" ? entry.active_by_default : true
-    };
-  }
-  return out;
-}
-async function packageExtract(client, args) {
-  const app = await client.getApp(args.app_id);
-  if (!app.current_version_id) {
+async function appPublish(client, args) {
+  const projectDir = path6.resolve(args.projectDir ?? process.cwd());
+  const local = readLocalAppManifest(projectDir);
+  const explicit = args.app_id !== void 0 && args.app_id !== "." ? args.app_id : void 0;
+  const appId = explicit ?? local?.app_id ?? null;
+  if (appId === null) {
     throw new Error(
-      `App ${app.id} has no deployed version \u2014 extract stages its source archive, so deploy it first.`
+      "No app id. Run `lotics app publish` from a pulled app project (lotics app pull <app_id>), or pass one: lotics app publish <app_id>."
     );
   }
-  const targetPath = path7.resolve(args.targetPath ?? appDirName(app.name));
-  if (fs6.existsSync(targetPath) && fs6.readdirSync(targetPath).length > 0) {
-    throw new Error(`Target directory ${targetPath} is not empty.`);
-  }
-  fs6.mkdirSync(targetPath, { recursive: true });
-  const version2 = await client.getAppVersion(app.id, app.current_version_id);
-  const sourceUrl = await client.getAppVersionSourceUrl(app.id, version2.id);
-  const tmpFile = path7.join(tmpdir2(), `lotics-extract-${app.id}-${Date.now()}.tar.gz`);
-  console.error("Downloading source archive...");
-  await client.downloadFile(sourceUrl, tmpFile);
-  try {
-    console.error(`Extracting to ${targetPath}...`);
-    await runTar(["-xzf", tmpFile, "-C", targetPath], targetPath);
-  } finally {
-    if (fs6.existsSync(tmpFile)) fs6.unlinkSync(tmpFile);
-  }
-  const appPkgJson = JSON.parse(
-    fs6.readFileSync(packageJsonPath(targetPath), "utf-8")
-  );
-  const appKnowledge = readAppKnowledgeDeclaration(appPkgJson);
-  const extracted = await client.extractPackage(args.app_id, {
-    knowledge: appKnowledge.knowledge
-  });
-  const { lines, hasError } = formatExtractReport(extracted.report);
-  if (lines.length > 0) {
-    console.error(`Extraction report (${extracted.report.length}):`);
-    for (const line of lines) console.error(line);
-  } else {
-    console.error("Extraction report: no findings.");
-  }
-  const draft = draftPackageProjectFromApp(appPkgJson, { name: app.name, description: null });
-  draft.manifest.knowledge = knowledgeManifestFromContract(extracted.contract);
-  draft.manifest.knowledge_expects = appKnowledge.knowledge_expects;
-  const deps = isPlainObject2(draft.pkgJson.dependencies) ? draft.pkgJson.dependencies : {};
-  const originRange = typeof deps["@lotics/app-sdk"] === "string" ? deps["@lotics/app-sdk"] : null;
-  const originFloor = originRange?.replace(/^[\^~]/, "") ?? null;
-  if (originFloor === null || cmpVersions(originFloor, STARTER_FALLBACK_SDK_VERSION) < 0) {
-    const raised = packageSdkRange(await fetchLatestNpmVersion("@lotics/app-sdk"));
-    draft.pkgJson.dependencies = { ...deps, "@lotics/app-sdk": raised };
-    console.error(`Raised @lotics/app-sdk to ${raised} (generated app_fields needs getAppBinding)`);
-  }
-  writePackageManifest(targetPath, draft);
-  fs6.writeFileSync(
-    path7.join(targetPath, CONTRACT_FILE),
-    JSON.stringify(extracted.contract, null, 2) + "\n"
-  );
-  console.error(`Wrote ${CONTRACT_FILE}`);
-  writePackageAppFields(targetPath);
-  const starterViteConfig = buildStarterTemplate({
-    app_name: app.name,
-    app_id: "",
-    workspace_id: ""
-  }).find((f) => f.path === "vite.config.ts");
-  if (starterViteConfig === void 0) {
-    throw new Error("starter template is missing vite.config.ts \u2014 cannot refresh the package project");
-  }
-  const viteConfigPath = path7.join(targetPath, "vite.config.ts");
-  const originViteConfig = fs6.existsSync(viteConfigPath) ? fs6.readFileSync(viteConfigPath, "utf-8") : null;
-  fs6.writeFileSync(viteConfigPath, starterViteConfig.content);
-  if (originViteConfig !== null && originViteConfig !== starterViteConfig.content) {
-    const stash = path7.join(dotLoticsDirEnsured(targetPath), "vite.config.origin.ts");
-    fs6.writeFileSync(stash, originViteConfig);
+  const knowledge = local && local.app_id === appId ? local.knowledge : [];
+  const renames = parseRenameFlags(args.renames);
+  const preview = await client.previewPublishAppPackage(appId, { renames, knowledge });
+  const { lines, hasError } = formatExtractReport(preview.findings);
+  console.error(`Publish preview \u2014 ${appId} as new package "${preview.package_name}" (v1):`);
+  const groups = [
+    ["entities", preview.renamable_aliases.entities],
+    ["fields", preview.renamable_aliases.fields],
+    ["options", preview.renamable_aliases.options],
+    ["roles", preview.renamable_aliases.roles],
+    ["templates", preview.renamable_aliases.templates],
+    ["workflows", preview.renamable_aliases.workflows]
+  ];
+  if (groups.some(([, vals]) => vals.length > 0)) {
+    console.error("  Auto-minted aliases \u2014 rename any with --rename <alias>=<new> before v1 freezes them:");
+    for (const [label, vals] of groups) {
+      if (vals.length > 0) console.error(`    ${`${label}:`.padEnd(11)} ${vals.join(", ")}`);
+    }
     console.error(
-      "Refreshed vite.config.ts from the starter (build.target es2022). The origin app's config differed \u2014 its original was saved to .lotics/vite.config.origin.ts; re-apply any custom optimizeDeps/plugins entries you still need (never dev-link aliases)."
+      "  (query / app-workflow / agent runtime aliases are fixed \u2014 the shipped source calls them verbatim.)"
     );
   } else {
-    console.error("Refreshed vite.config.ts from the starter (build.target es2022)");
-  }
-  for (const tf of extracted.template_files) {
-    const dest = path7.join(targetPath, tf.bytes_ref);
-    fs6.mkdirSync(path7.dirname(dest), { recursive: true });
-    const { path: downloaded } = await client.downloadFileById(tf.file_id, path7.dirname(dest));
-    if (path7.resolve(downloaded) !== path7.resolve(dest)) fs6.renameSync(downloaded, dest);
-    console.error(`Wrote ${tf.bytes_ref}`);
-  }
-  for (const kf of extracted.knowledge_files) {
-    const dest = path7.join(targetPath, kf.content_ref);
-    fs6.mkdirSync(path7.dirname(dest), { recursive: true });
-    fs6.writeFileSync(dest, kf.content);
-    console.error(`Wrote ${kf.content_ref}`);
-  }
-  const dotLotics = path7.join(targetPath, ".lotics");
-  fs6.mkdirSync(dotLotics, { recursive: true });
-  fs6.writeFileSync(
-    path7.join(dotLotics, ADOPT_BINDING_FILE),
-    JSON.stringify(
-      {
-        app_id: app.id,
-        workspace_id: app.workspace_id,
-        binding: extracted.binding,
-        knowledge_binding: extracted.knowledge_binding
-      },
-      null,
-      2
-    ) + "\n"
-  );
-  console.error(`Wrote .lotics/${ADOPT_BINDING_FILE}`);
-  console.error("Installing npm dependencies...");
-  await runNpm(["install"], targetPath);
+    console.error("  No renamable aliases.");
+  }
+  if (lines.length > 0) {
+    console.error(`  Findings (${preview.findings.length}):`);
+    for (const line of lines) console.error(line);
+  }
   if (hasError) {
     console.error(
-      "\nExtraction produced error findings \u2014 the draft is written but NOT publishable as-is."
-    );
-    console.error(
-      "Fix the reported items above, then publish (which re-validates the contract)."
+      "\nExtract found error findings \u2014 the app cannot be published as-is. Fix them in the app, redeploy, and retry."
     );
     process.exitCode = 1;
     return;
   }
-  console.error("\nDraft package project written. Next steps:");
-  console.error(`  cd ${path7.relative(process.cwd(), targetPath) || "."}`);
-  console.error("  # review the aliases in contract.json, then:");
-  console.error(`  lotics package publish -m "v1"`);
-  console.error(`  lotics package adopt ${app.id}   (from this project, same workspace)`);
+  if (!args.yes) {
+    const idArg = explicit ?? ".";
+    const renameArgs = args.renames.map((r) => ` --rename ${r}`).join("");
+    const mArg = args.changelog ? ` -m ${JSON.stringify(args.changelog)}` : "";
+    console.error(`
+Re-run with --yes to publish v1:`);
+    console.error(`  lotics app publish ${idArg}${renameArgs}${mArg} --yes`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = await client.publishAppAsPackage(appId, {
+    renames,
+    changelog: args.changelog ?? null,
+    knowledge
+  });
+  console.error(`Published ${result.package_id} v${result.version} from app ${appId}.`);
+  console.error(`  The app is now installation #1 \u2014 develop it in place, then release the next version:`);
+  console.error(`    lotics app pull ${appId}   # edit, then lotics app deploy`);
+  console.error(`    lotics app release ${appId} -m "<what changed>"`);
+  console.error(`  Install it elsewhere:  lotics install ${result.package_id}`);
+}
+function resolveOriginAppId(projectDir, explicit) {
+  if (explicit !== void 0 && explicit !== ".") return explicit;
+  const local = readLocalAppManifest(projectDir);
+  if (local?.app_id) return local.app_id;
+  throw new Error(
+    "No app id. Run this from a pulled app project (lotics app pull <app_id>), or pass an app id explicitly."
+  );
 }
-async function packageAdopt(client, args) {
-  const projectDir = path7.resolve(args.projectDir ?? process.cwd());
-  const { manifest } = readPackageProject(projectDir);
-  if (manifest.id === null) {
-    throw new Error(
-      "This package project has never been published (no package id). Publish first:\n  lotics package publish"
-    );
+async function appRelease(client, args) {
+  const projectDir = path6.resolve(args.projectDir ?? process.cwd());
+  const appId = resolveOriginAppId(projectDir, args.app_id);
+  const preview = await client.previewPackageRelease(appId);
+  const { lines, hasError } = formatExtractReport(preview.findings);
+  console.error(`Release preview \u2014 ${appId} \u2192 ${preview.package_id} v${preview.version}:`);
+  if (preview.added_aliases.length > 0) {
+    console.error(`  New (${preview.added_aliases.length}): ${preview.added_aliases.join(", ")}`);
   }
-  const version2 = args.version ?? manifest.version;
-  if (version2 === null) {
-    throw new Error(
-      "No version to adopt \u2014 publish this project first (lotics package publish) or pass --version N."
-    );
+  if (preview.changed_artifacts.length > 0) {
+    console.error(`  Changed (${preview.changed_artifacts.length}): ${preview.changed_artifacts.join(", ")}`);
   }
-  const bindingPath = path7.join(projectDir, ".lotics", ADOPT_BINDING_FILE);
-  if (!fs6.existsSync(bindingPath)) {
-    throw new Error(
-      `No .lotics/${ADOPT_BINDING_FILE} in ${projectDir}. Adopt binds the origin app that "lotics package extract" recorded \u2014 run extract to produce this project.`
-    );
+  if (preview.added_aliases.length === 0 && preview.changed_artifacts.length === 0) {
+    console.error("  No contract changes since the current version (a fresh code/dist snapshot still ships).");
   }
-  const pin = parseAdoptBindingFile(
-    JSON.parse(fs6.readFileSync(bindingPath, "utf-8")),
-    args.app_id
-  );
-  const app = await client.adoptPackage(args.app_id, {
-    package_id: manifest.id,
-    version: version2,
-    binding: pin.binding,
-    // The origin knowledge binding (empty when the app owns no package-managed
-    // docs) — the server verifies it maps the contract's knowledge aliases faithfully.
-    ...Object.keys(pin.knowledge_binding).length > 0 ? { knowledge_binding: pin.knowledge_binding } : {}
-  });
-  console.error(
-    `Adopted ${app.name} \u2192 installation of ${app.package_id} v${app.package_version}.`
-  );
-  console.error(`  Verify the installation:  lotics package doctor ${app.id}`);
+  if (lines.length > 0) {
+    console.error(`  Findings (${preview.findings.length}):`);
+    for (const line of lines) console.error(line);
+  }
+  if (hasError) {
+    console.error("\nExtract found error findings \u2014 the origin cannot be released as-is. Fix them in the app and retry.");
+    process.exitCode = 1;
+    return;
+  }
+  if (!args.yes) {
+    console.error(`
+Re-run with --yes to publish v${preview.version}:`);
+    console.error(`  lotics app release ${args.app_id ?? "."} -m ${JSON.stringify(args.changelog)} --yes`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = await client.releasePackage(appId, { changelog: args.changelog });
+  console.error(`Released ${result.package_id} v${result.version}.`);
+  console.error(`  The origin was re-pinned to v${result.version} \u2014 verify:  lotics package doctor ${appId}`);
 }
 async function packageYank(client, args) {
   const result = await client.yankPackageVersion(args.package_id, args.version, !args.undo);
@@ -52006,7 +50838,7 @@ async function packageFleetUpgrade(client, args) {
         `${line}: breaking=${inst.blockers.breaking} drift=${inst.blockers.drift} modified=${inst.blockers.modified}`
       );
       console.error(
-        `      resolve via:  lotics package upgrade ${inst.app_id} --version ${result.target_version} ...`
+        `      resolve via:  lotics upgrade ${inst.app_id} --version ${result.target_version} ...`
       );
     } else if (inst.message) {
       console.error(`${line}: ${inst.message}`);
@@ -52038,7 +50870,6 @@ function parseArgs(argv) {
     message: void 0,
     local: false,
     all: false,
-    dev: false,
     yes: false,
     printCreated: false,
     cleanup: false,
@@ -52047,7 +50878,7 @@ function parseArgs(argv) {
     bindTo: [],
     keepContent: false,
     applyAll: false,
-    kind: void 0,
+    rename: [],
     config: [],
     set: [],
     archiveTables: false,
@@ -52102,9 +50933,6 @@ function parseArgs(argv) {
       case "--local":
         flags.local = true;
         break;
-      case "--dev":
-        flags.dev = true;
-        break;
       case "--all":
         flags.all = true;
         break;
@@ -52143,9 +50971,14 @@ function parseArgs(argv) {
       case "--apply-all":
         flags.applyAll = true;
         break;
-      case "--kind":
-        flags.kind = argv[++i2];
+      case "--rename": {
+        const value = argv[++i2];
+        if (value === void 0 || value.startsWith("-")) {
+          throw new Error("--rename requires a value: old=new (an alias to rename before v1 freezes it).");
+        }
+        flags.rename.push(value);
         break;
+      }
       case "--config": {
         const value = argv[++i2];
         if (value === void 0 || value.startsWith("-")) {
@@ -52171,10 +51004,10 @@ function parseArgs(argv) {
       case "--version":
       case "-v": {
         const next = argv[i2 + 1];
-        if (command === "package") {
+        if (command === "package" || command === "install" || command === "upgrade") {
           if (next === void 0 || next.startsWith("-")) {
             throw new Error(
-              "--version requires a version number for package commands (e.g. --version 2)."
+              "--version requires a version number for install/upgrade/package commands (e.g. --version 2)."
             );
           }
           flags.packageVersion = next;
@@ -52236,6 +51069,34 @@ async function ingestJsonArgs(opts) {
 // src/xlsx.ts
 import fs7 from "node:fs";
 
+// src/file_command_io.ts
+import fs6 from "node:fs";
+import path7 from "node:path";
+var CliError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliError";
+  }
+};
+function fail(message) {
+  throw new CliError(message);
+}
+function writeFileAtomic(filePath, bytes) {
+  const dir = path7.dirname(path7.resolve(filePath));
+  const tmp = path7.join(dir, `.${path7.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+  fs6.writeFileSync(tmp, bytes);
+  try {
+    fs6.renameSync(tmp, filePath);
+  } catch (error51) {
+    try {
+      fs6.unlinkSync(tmp);
+    } catch {
+    }
+    throw error51;
+  }
+  console.error(`Wrote ${filePath}`);
+}
+
 // ../xlsx/node_modules/fast-xml-parser/src/util.js
 var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
 var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
@@ -68566,7 +67427,7 @@ async function runDocxCommand(subcommand, toolArgs, restArgs) {
 import { spawn as spawn3 } from "node:child_process";
 import { createServer } from "node:http";
 import { readFileSync as readFileSync2, writeFileSync, existsSync, mkdtempSync, rmSync, readdirSync } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir2 } from "node:os";
 import { join, dirname, resolve, extname, basename } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { setTimeout as sleep } from "node:timers/promises";
@@ -68659,7 +67520,7 @@ async function runPreviewCommand(filePath, flags) {
   });
   await new Promise((r) => server.listen(0, "127.0.0.1", () => r()));
   const httpPort = server.address().port;
-  const udd = mkdtempSync(join(tmpdir3(), "lotics-render-"));
+  const udd = mkdtempSync(join(tmpdir2(), "lotics-render-"));
   const child = spawn3(chrome, [
     "--headless=new",
     "--disable-gpu",
@@ -68808,10 +67669,22 @@ COMMANDS
   cat args.json | lotics run <tool>    Read JSON args from stdin (large payloads)
   lotics app create <name> [path]      Create a new custom-code app + scaffold locally
   lotics app pull <app_id> [path]      Bootstrap full local env (source + npm install + types)
-  lotics app deploy -m <message>       Build + upload current dir as a new version
-                                       (-m is required \u2014 it's the version's audit trail)
-                                       (code + queries only \u2014 workflow bindings are
+  lotics app deploy -m <message>       Build + upload current dir as a new version \u2014 COMMIT
+                                       (-m is required \u2014 it's the version's audit trail;
+                                       carries code + queries only \u2014 workflow bindings are
                                        managed by set_app_workflow / remove_app_workflow)
+  lotics app publish [app_id|.] [--rename old=new ...] [-m <changelog>] [--yes]
+                                       Make the app DISTRIBUTABLE \u2014 first-release it (v1) as a
+                                       package; later versions ship via "lotics app release".
+                                       Previews the auto-minted aliases + findings; --yes applies
+                                       (extract \u2192 create \u2192 publish v1 \u2192 pin origin). --rename fixes
+                                       an alias before v1 freezes; -m is an optional v1 changelog
+  lotics app release [app_id|.] -m <changelog> [--yes]
+                                       RELEASE the next package version from the origin app you
+                                       are happy with (preview; --yes publishes + re-pins)
+  lotics app unpublish <app_id|package_id> [--undo]
+                                       Take the published package off the shelf (installations
+                                       keep working); --undo restores it
   lotics app versions [app_id]         Show deploy history newest-first (version,
                                        timestamp, deployer, build status, -m message;
                                        * marks the currently served version)
@@ -68833,57 +67706,40 @@ COMMANDS
   lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address
   lotics app rename "<new name>"       Rename the app's display name (launcher title)
   lotics app dev [path]                Run the app locally with HMR (RPC forwarded to prod)
-  lotics package new <name> [path] [--kind app|content]
-                                       Scaffold a package project \u2014 an app (contract + source)
-                                       or a content corpus (docs-only, no app source)
-  lotics package build [path]          Build the publishable bundle (source + dist)
-  lotics package publish [path]        Publish a new immutable package version
-  lotics package dev [path]            Sync the package into a dev workspace + run the app
-                                       dev server (--workspace <dev_ws> selects it)
-  lotics package sync [path]           Re-sync (additive migrate + materialize) into a dev ws
-  lotics package reset [path]          DEV-ONLY: drop scaffolded tables + re-scaffold clean
-  lotics package install <package> [--version N] [--bind-to <alias>=<kdc_id> ...] [--config key=value ...]
+  # PACKAGES \u2014 consumer verbs are top-level; low-traffic ops live on "lotics package"
+  #            (author verbs live on "lotics app")
+  lotics install <package_id> [--version N] [--bind-to <alias>=<kdc_id> ...] [--config key=value ...]
                                        Install a package (app: scaffolds/deploys/materializes,
                                        --config sets its knobs; content: installs the doc corpus,
                                        --bind-to consents to adopt a same-named doc on a collision)
-  lotics package uninstall <app_id|pci_id> [--archive-tables] [--keep-content]
+  lotics uninstall <app_id|pci_id> [--archive-tables] [--keep-content]
                                        Uninstall \u2014 dispatched by id. App (app_id): archives
                                        artifacts (+ --archive-tables also archives scaffolded
                                        tables). Content (pci_): archives its package-bound docs
                                        unless --keep-content
-  lotics package config <app_id> [--set key=value ...]
-                                       Show or edit an installation's config knobs
-  lotics package show <package_id>     Registry metadata + version history
-  lotics package retire <package_id> [--undo]
-                                       Retire a package (refuse new installs, hide from other
-                                       orgs); existing installations keep working + upgrade
-  lotics package list-content          List the workspace's content installations
-                                       (standalone pci_ + app-bundled) \u2014 source for a pci_ id
-  lotics package upgrade <app_id|pci_id> [--version N] [--resolve <key>=... ] [--bind-to ...] [--apply-all]
-                                       Preview-then-apply an upgrade. App: refuses while any
-                                       drift/modified/bundled-knowledge finding lacks a --resolve
-                                       (a knowledge-alias --resolve routes to the doc). Content
-                                       (pci_): --resolve <alias>=apply|keep|archive|recreate|unbind;
-                                       --apply-all accepts the package's version for every doc
+  lotics upgrade <app_id|pci_id|package_id> [--version N] [--resolve <key>=... ] [--bind-to ...] [--apply-all]
+                                       Preview-then-apply an upgrade, dispatched by id. App
+                                       (app_id): refuses while any drift/modified/bundled-knowledge
+                                       finding lacks a --resolve. Content (pci_): --resolve
+                                       <alias>=apply|keep|archive|recreate|unbind. Package (apg_):
+                                       FLEET \u2014 every installation across your org (clean apply,
+                                       findings skip). --apply-all accepts the package's version
   lotics package doctor [app_id]       Installation health: version pin vs latest, binding
                                        drift, locally modified core, knowledge drift/edits
                                        (exit 1 on findings)
-  lotics package rebind-role <app_id> <alias> <grp_id>
-                                       Re-point a package role at a different group
-                                       (re-materializes at the pinned version)
+  lotics package config <app_id> [--set key=value ...]
+                                       Show or edit an installation's config knobs
   lotics package eject <app_id>        Sever an installation's package link
                                        (re-deploys the pinned source as a bespoke app)
-  lotics package extract <app_id> [path]   Promote a bespoke app to a draft package
-                                       project (contract + binding + templates); always
-                                       writes the draft, exits 1 on error findings
-  lotics package adopt <app_id> [path]     Bind the published package project onto the
-                                       origin app (reads .lotics/adopt_binding.json;
-                                       --version N pins a specific version)
-  lotics package fleet-upgrade <package_id> [--version N]
+  lotics package show <package_id>     Registry metadata + version history
+  lotics package list-content          List the workspace's content installations
+                                       (standalone content installs) \u2014 source for a pci_ id
   lotics package yank <package_id> <version> [--undo]
-                                       Upgrade EVERY installation of the package across
-                                       your org: applies where the preview is clean,
-                                       skips + reports findings (exit 1 unless all current)
+                                       Refuse new installs/upgrades of a broken published
+                                       version (pinned installations keep running)
+  lotics run publish_content '{"name":"\u2026","knowledge_doc_ids":[\u2026],"template_ids":[\u2026]}'
+                                       Publish a SET of live docs + templates as a content
+                                       package (v1 + origin pin); release_content cuts the next
   lotics ui link <component> [--ui-src <path>] [--remove]
                                        Dev-link @lotics/ui to packages/ui/src (Vite alias
                                        + tsc paths) for live HMR + typecheck. Monorepo apps
@@ -68912,13 +67768,12 @@ FLAGS
                      is_current_member / row-scoping resolve to them (also
                      LOTICS_VIEW_AS env; admin key only; writes stay yours)
   --local            Pin the current directory (lotics org use / auth api-key)
-  --dev              (lotics workspace create) Mark a throwaway app-package dev
-                     workspace \u2014 required for "lotics package reset"
-  --kind <k>         (lotics package new) Package kind: app (default) or content
-  --bind-to <a>=<id> (lotics package install/upgrade, repeatable) Adopt an existing
+  --rename <old>=<new> (lotics app publish, repeatable) Fix an auto-minted alias before
+                     the package's v1 contract freezes it
+  --bind-to <a>=<id> (lotics install/upgrade, repeatable) Adopt an existing
                      same-named doc as package-managed (resolves a knowledge collision)
-  --keep-content     (lotics package uninstall) Keep the docs instead of archiving them
-  --apply-all        (lotics package upgrade, knowledge) Accept the package's version
+  --keep-content     (lotics uninstall) Keep the docs instead of archiving them
+  --apply-all        (lotics upgrade, knowledge) Accept the package's version
                      for every doc (overwrites local edits)
   --all              (lotics auth logout) Remove every saved credential
   --version          Show version
@@ -69292,27 +68147,6 @@ async function main() {
     console.error("Usage: lotics ui link <component> [--ui-src <abs path>] [--remove]");
     process.exit(1);
   }
-  if (command === "package" && subcommand === "new") {
-    const name = toolArgs;
-    if (!name) {
-      console.error("Usage: lotics package new <name> [path] [--kind app|content]");
-      process.exit(1);
-    }
-    if (flags.kind !== void 0 && flags.kind !== "app" && flags.kind !== "content") {
-      console.error(`Invalid --kind "${flags.kind}" \u2014 expected "app" or "content".`);
-      process.exit(1);
-    }
-    await packageNew({
-      name,
-      targetPath: restArgs[0],
-      kind: flags.kind === "content" ? "content" : "app"
-    });
-    return;
-  }
-  if (command === "package" && subcommand === "build") {
-    await packageBuild({ projectDir: toolArgs });
-    return;
-  }
   if (command === "app" && subcommand === "workflow" && toolArgs === "check") {
     await appWorkflowCheck({ alias: restArgs[0] });
     return;
@@ -69387,7 +68221,7 @@ async function main() {
     }
     return;
   }
-  if (command !== "tools" && command !== "upload" && command !== "run" && command !== "download" && command !== "workspace" && command !== "app" && command !== "package") {
+  if (command !== "tools" && command !== "upload" && command !== "run" && command !== "download" && command !== "workspace" && command !== "app" && command !== "package" && command !== "install" && command !== "uninstall" && command !== "upgrade") {
     console.error(`Unknown command: ${command}`);
     console.error('Run "lotics --help" for usage.');
     process.exit(1);
@@ -69407,30 +68241,27 @@ async function main() {
     console.error("  lotics app subdomain <new-subdomain> Rename the app's public <slug>.lotics.app address");
     console.error(`  lotics app rename "<new name>"        Rename the app's display name (launcher title)`);
     console.error("  lotics app dev [path]                Run the app locally with HMR + RPC forwarding");
+    console.error("  lotics app publish [app_id|.] [--rename old=new ...] [-m <changelog>] [--yes]   First-release the app as a package (v1; preview, --yes applies)");
+    console.error("  lotics app release [app_id|.] -m <changelog> [--yes]   Release the next package version from the origin");
+    console.error("  lotics app unpublish <app_id|package_id> [--undo]      Take a published package off the shelf (any kind \u2014 app or content)");
     process.exit(1);
   }
   if (command === "package" && !subcommand) {
-    console.error("Usage:");
-    console.error("  lotics package new <name> [path] [--kind app|content]   Scaffold a package project (app source, or docs-only)");
-    console.error("  lotics package build [path]                      Build the publishable bundle (source + dist)");
-    console.error("  lotics package publish [path] [-m <changelog>]   Publish a new immutable package version");
-    console.error("  lotics package dev [path] [--workspace <ws>]     Sync into a dev workspace + run the app dev server");
-    console.error("  lotics package sync [path] [--workspace <ws>]    Re-sync (additive migrate + materialize) into a dev workspace");
-    console.error("  lotics package reset [path] [--workspace <ws>]   DEV-ONLY: drop scaffolded tables + re-scaffold clean");
-    console.error("  lotics package install <package> [--version N] [--bind-to <alias>=<kdc_id>] [--config key=value ...]   Install a package (app or content)");
-    console.error("  lotics package uninstall <app_id|pci_id> [--archive-tables] [--keep-content]   Uninstall \u2014 dispatched by id (app vs content)");
-    console.error("  lotics package config <app_id> [--set key=value ...]   Show or edit an installation's config knobs");
-    console.error("  lotics package show <package_id>                 Registry metadata + version history (channel, yank, changelog)");
-    console.error("  lotics package retire <package_id> [--undo]      Retire a package (refuse new installs; installs keep working)");
-    console.error("  lotics package list-content                      List the workspace's content installations (standalone + app-bundled)");
-    console.error("  lotics package upgrade <app_id|pci_id> [--version N] [--resolve <key>=... ] [--bind-to ...] [--apply-all]   Preview + apply an upgrade");
+    console.error("Usage (low-traffic consumer / registry ops \u2014 author verbs live on `lotics app`):");
+    console.error("  The high-traffic consumer verbs are top-level:");
+    console.error("    lotics install <package_id> [--version N] [--bind-to <alias>=<kdc_id>] [--config key=value ...]   Install a package (app or content)");
+    console.error("    lotics uninstall <app_id|pci_id> [--archive-tables] [--keep-content]   Uninstall \u2014 dispatched by id (app vs content)");
+    console.error("    lotics upgrade <app_id|pci_id|package_id> [--version N] [--resolve <key>=... ] [--bind-to ...] [--apply-all]   Upgrade \u2014 app / content / whole fleet (apg_)");
     console.error("  lotics package doctor [app_id]                   Health: version pin vs latest + binding/knowledge drift");
-    console.error("  lotics package rebind-role <app_id> <alias> <grp_id>   Re-point a package role at another group");
+    console.error("  lotics package config <app_id> [--set key=value ...]   Show or edit an installation's config knobs");
     console.error("  lotics package eject <app_id>                    Sever an installation's package link");
-    console.error("  lotics package extract <app_id> [path]           Promote a bespoke app to a draft package project");
-    console.error("  lotics package adopt <app_id> [path]             Bind the published project onto the origin app");
-    console.error("  lotics package fleet-upgrade <package_id> [--version N]   Upgrade every org installation (clean ones apply; findings skip)");
+    console.error("  lotics package show <package_id>                 Registry metadata + version history (channel, yank, changelog)");
+    console.error("  lotics package list-content                      List the workspace's content installations (standalone content installs)");
     console.error("  lotics package yank <package_id> <version> [--undo]       Refuse new installs/upgrades of a broken published version (pinned installations keep running)");
+    console.error("  A content package (a SET of live docs + templates) \u2014 publish + release with the tools, retire on `lotics app`:");
+    console.error(`    lotics run publish_content '{"name":"\u2026","knowledge_doc_ids":[\u2026],"template_ids":[\u2026]}'   Publish v1 (a fixed set)`);
+    console.error(`    lotics run release_content '{"package_id":"apg_\u2026","changelog":"\u2026"}'   Cut the next version (add "dry_run":true to preview)`);
+    console.error("    lotics app unpublish <package_id>   Take the whole package off the shelf (kind-agnostic \u2014 retires content too)");
     process.exit(1);
   }
   if (command === "run" && !subcommand) {
@@ -69506,11 +68337,11 @@ Available workspaces:`);
     if (subcommand === "create") {
       const name = toolArgs;
       if (!name) {
-        console.error("Usage: lotics workspace create <name> [--timezone <tz>] [--dev]");
+        console.error("Usage: lotics workspace create <name> [--timezone <tz>]");
         process.exit(1);
       }
       const timezone = flags.timezone;
-      const created = await client.createWorkspace({ name, timezone, is_dev: flags.dev || void 0 });
+      const created = await client.createWorkspace({ name, timezone });
       setSelectedWorkspace(created.id);
       client.setWorkspaceId(created.id);
       if (flags.json) {
@@ -69572,48 +68403,88 @@ Available workspaces:`);
     return;
   }
   await resolveWorkspace(client, ctx);
-  if (command === "package") {
-    if (subcommand === "install") {
-      const packageId = toolArgs;
-      if (!packageId) {
-        console.error(
-          "Usage: lotics package install <package> [--version N] [--bind-to <alias>=<kdc_id> ...]"
-        );
+  if (command === "install") {
+    const packageId = subcommand;
+    if (!packageId) {
+      console.error("Usage: lotics install <package_id> [--version N] [--bind-to <alias>=<kdc_id> ...] [--config key=value ...]");
+      process.exit(1);
+    }
+    let version2;
+    if (flags.packageVersion !== void 0) {
+      version2 = Number(flags.packageVersion);
+      if (!Number.isInteger(version2) || version2 <= 0) {
+        console.error(`Invalid --version "${flags.packageVersion}" \u2014 expected a positive integer.`);
         process.exit(1);
       }
-      let version2;
-      if (flags.packageVersion !== void 0) {
-        version2 = Number(flags.packageVersion);
-        if (!Number.isInteger(version2) || version2 <= 0) {
-          console.error(`Invalid --version "${flags.packageVersion}" \u2014 expected a positive integer.`);
-          process.exit(1);
-        }
-      }
-      const config2 = flags.config.length > 0 ? parseInstallConfigFlags(flags.config) : void 0;
-      await packageInstall(client, {
-        package_id: packageId,
-        version: version2,
-        bind_to: parseBindToFlags(flags.bindTo),
-        ...config2 !== void 0 ? { config: config2 } : {}
-      });
-      return;
     }
-    if (subcommand === "uninstall") {
-      const id = toolArgs;
-      if (!id) {
-        console.error("Usage: lotics package uninstall <app_id|pci_id> [--archive-tables] [--keep-content]");
-        console.error(
-          "Dispatched by id: an app installation (app_id; --archive-tables to also archive its scaffolded tables) or a standalone content installation (pci_ id from install / lotics package list-content; --keep-content to retain its docs)."
-        );
+    const config2 = flags.config.length > 0 ? parseInstallConfigFlags(flags.config) : void 0;
+    await packageInstall(client, {
+      package_id: packageId,
+      version: version2,
+      bind_to: parseBindToFlags(flags.bindTo),
+      ...config2 !== void 0 ? { config: config2 } : {}
+    });
+    return;
+  }
+  if (command === "uninstall") {
+    const id = subcommand;
+    if (!id) {
+      console.error("Usage: lotics uninstall <app_id|pci_id> [--archive-tables] [--keep-content]");
+      console.error(
+        "Dispatched by id: an app installation (app_id; --archive-tables to also archive its scaffolded tables) or a standalone content installation (pci_ id from `lotics install` / lotics package list-content; --keep-content to retain its docs)."
+      );
+      process.exit(1);
+    }
+    await packageUninstall(client, {
+      id,
+      keep_content: flags.keepContent,
+      archive_tables: flags.archiveTables
+    });
+    return;
+  }
+  if (command === "upgrade") {
+    const target = subcommand;
+    if (!target) {
+      console.error(
+        "Usage: lotics upgrade <app_id | pci_id | package_id> [--version N] [--resolve <key>=... ...] [--bind-to ...] [--apply-all]"
+      );
+      console.error(
+        "Dispatched by id: an app installation (app_id), a standalone content installation (pci_ id), or a package id (apg_ \u2014 fleet-upgrades every installation across your org)."
+      );
+      process.exit(1);
+    }
+    let version2;
+    if (flags.packageVersion !== void 0) {
+      version2 = Number(flags.packageVersion);
+      if (!Number.isInteger(version2) || version2 <= 0) {
+        console.error(`Invalid --version "${flags.packageVersion}" \u2014 expected a positive integer.`);
         process.exit(1);
       }
-      await packageUninstall(client, {
-        id,
-        keep_content: flags.keepContent,
-        archive_tables: flags.archiveTables
+    }
+    if (target.startsWith("apg_")) {
+      await packageFleetUpgrade(client, { package_id: target, version: version2 });
+      return;
+    }
+    if (target.startsWith("pci_")) {
+      await packageUpgradeKnowledge(client, {
+        installation_id: target,
+        version: version2,
+        resolve: flags.resolve,
+        bind_to: parseBindToFlags(flags.bindTo),
+        applyAll: flags.applyAll
       });
       return;
     }
+    await packageUpgrade(client, {
+      app_id: target,
+      version: version2,
+      resolve: flags.resolve,
+      bindTo: flags.bindTo,
+      applyAll: flags.applyAll
+    });
+    return;
+  }
+  if (command === "package") {
     if (subcommand === "list-content") {
       await packageListContent(client);
       return;
@@ -69627,15 +68498,6 @@ Available workspaces:`);
       await packageConfig(client, { app_id: appId, sets: flags.set });
       return;
     }
-    if (subcommand === "retire") {
-      const packageId = toolArgs;
-      if (!packageId) {
-        console.error("Usage: lotics package retire <package_id> [--undo]");
-        process.exit(1);
-      }
-      await packageRetire(client, { package_id: packageId, undo: flags.undo });
-      return;
-    }
     if (subcommand === "show") {
       const packageId = toolArgs;
       if (!packageId) {
@@ -69654,34 +68516,6 @@ Available workspaces:`);
       await packageEject(client, { app_id: appId });
       return;
     }
-    if (subcommand === "extract") {
-      const appId = toolArgs;
-      if (!appId) {
-        console.error("Usage: lotics package extract <app_id> [path]");
-        console.error("Promotes a bespoke app to a draft package project (contract + binding + templates).");
-        process.exit(1);
-      }
-      await packageExtract(client, { app_id: appId, targetPath: restArgs[0] });
-      return;
-    }
-    if (subcommand === "adopt") {
-      const appId = toolArgs;
-      if (!appId) {
-        console.error("Usage: lotics package adopt <app_id> [path]");
-        console.error("Binds the published package project (this dir, or [path]) onto the origin app.");
-        process.exit(1);
-      }
-      let version2;
-      if (flags.packageVersion !== void 0) {
-        version2 = Number(flags.packageVersion);
-        if (!Number.isInteger(version2) || version2 <= 0) {
-          console.error(`Invalid --version "${flags.packageVersion}" \u2014 expected a positive integer.`);
-          process.exit(1);
-        }
-      }
-      await packageAdopt(client, { app_id: appId, version: version2, projectDir: restArgs[0] });
-      return;
-    }
     if (subcommand === "yank") {
       const packageId = toolArgs;
       const version2 = Number(restArgs[0]);
@@ -69692,23 +68526,6 @@ Available workspaces:`);
       await packageYank(client, { package_id: packageId, version: version2, undo: flags.undo });
       return;
     }
-    if (subcommand === "fleet-upgrade") {
-      const packageId = toolArgs;
-      if (!packageId) {
-        console.error("Usage: lotics package fleet-upgrade <package_id> [--version N]");
-        process.exit(1);
-      }
-      let version2;
-      if (flags.packageVersion !== void 0) {
-        version2 = Number(flags.packageVersion);
-        if (!Number.isInteger(version2) || version2 <= 0) {
-          console.error(`Invalid --version "${flags.packageVersion}" \u2014 expected a positive integer.`);
-          process.exit(1);
-        }
-      }
-      await packageFleetUpgrade(client, { package_id: packageId, version: version2 });
-      return;
-    }
     if (subcommand === "doctor") {
       await packageDoctor(client, { app_id: toolArgs });
       return;
@@ -69716,78 +68533,23 @@ Available workspaces:`);
     if (subcommand === "rebind-role") {
       const appId = toolArgs;
       const [roleAlias, groupId] = restArgs;
-      if (!appId || !roleAlias || !groupId) {
-        console.error("Usage: lotics package rebind-role <app_id> <role_alias> <grp_id>");
-        process.exit(1);
-      }
-      const result = await client.rebindPackageRole(appId, {
-        role_alias: roleAlias,
-        group_id: groupId
-      });
       console.error(
-        `Rebound role "${result.role_alias}" \u2192 ${result.group_id}` + (result.previous_group_id ? ` (was ${result.previous_group_id})` : "") + ". Package workflows/agents were re-materialized against the new group."
+        `\`lotics package rebind-role\` was folded into the upgrade grammar. Re-point a live role with:
+  lotics upgrade ${appId ?? "<app_id>"} --resolve roles.${roleAlias ?? "<alias>"}=${groupId ?? "<grp_id>"}`
       );
-      return;
-    }
-    if (subcommand === "upgrade") {
-      const target = toolArgs;
-      if (!target) {
-        console.error(
-          "Usage: lotics package upgrade <app_id | pci_installation_id> [--version N] [--resolve <key>=... ...]"
-        );
-        process.exit(1);
-      }
-      let version2;
-      if (flags.packageVersion !== void 0) {
-        version2 = Number(flags.packageVersion);
-        if (!Number.isInteger(version2) || version2 <= 0) {
-          console.error(`Invalid --version "${flags.packageVersion}" \u2014 expected a positive integer.`);
-          process.exit(1);
-        }
-      }
-      if (target.startsWith("pci_")) {
-        await packageUpgradeKnowledge(client, {
-          installation_id: target,
-          version: version2,
-          resolve: flags.resolve,
-          bind_to: parseBindToFlags(flags.bindTo),
-          applyAll: flags.applyAll
-        });
-        return;
-      }
-      await packageUpgrade(client, {
-        app_id: target,
-        version: version2,
-        resolve: flags.resolve,
-        bindTo: flags.bindTo,
-        applyAll: flags.applyAll
-      });
-      return;
-    }
-    if (subcommand === "publish") {
-      await packagePublish(client, { projectDir: toolArgs, changelog: flags.message });
-      return;
-    }
-    if (subcommand === "sync") {
-      await packageSync(client, { projectDir: toolArgs });
-      return;
-    }
-    if (subcommand === "reset") {
-      await packageReset(client, { projectDir: toolArgs });
-      return;
+      process.exit(1);
     }
-    if (subcommand === "dev") {
-      const projectDir = toolArgs;
-      let port;
-      let vitePort;
-      for (const a of restArgs) {
-        const portMatch = /^--port=(\d+)$/.exec(a);
-        const vitePortMatch = /^--vite-port=(\d+)$/.exec(a);
-        if (portMatch) port = Number(portMatch[1]);
-        else if (vitePortMatch) vitePort = Number(vitePortMatch[1]);
-      }
-      await packageDev(client, { projectDir, port, vitePort });
-      return;
+    const movedVerbs = {
+      install: "lotics install <package_id>",
+      uninstall: "lotics uninstall <app_id|pci_id>",
+      upgrade: "lotics upgrade <app_id|pci_id|package_id>",
+      "fleet-upgrade": "lotics upgrade <package_id>"
+    };
+    if (subcommand !== void 0 && subcommand in movedVerbs) {
+      console.error(
+        `\`lotics package ${subcommand}\` moved to the top level \u2014 run \`${movedVerbs[subcommand]}\` instead.`
+      );
+      process.exit(1);
     }
     console.error(`Unknown package subcommand: ${subcommand}`);
     console.error("Run 'lotics package' for usage.");
@@ -69824,6 +68586,34 @@ Available workspaces:`);
       await appDeploy(client, { message });
       return;
     }
+    if (subcommand === "publish") {
+      await appPublish(client, {
+        app_id: toolArgs,
+        renames: flags.rename,
+        changelog: flags.message,
+        yes: flags.yes
+      });
+      return;
+    }
+    if (subcommand === "release") {
+      if (!flags.message) {
+        console.error("Usage: lotics app release [app_id|.] -m <changelog> [--yes]");
+        console.error("Snapshots the origin app into its next package version (preview, then --yes to publish).");
+        process.exit(1);
+      }
+      await appRelease(client, { app_id: toolArgs, changelog: flags.message, yes: flags.yes });
+      return;
+    }
+    if (subcommand === "unpublish") {
+      const id = toolArgs;
+      if (!id) {
+        console.error("Usage: lotics app unpublish <app_id|package_id> [--undo]");
+        console.error("Takes a published package off the shelf; existing installations keep working.");
+        process.exit(1);
+      }
+      await appUnpublish(client, { id, undo: flags.undo });
+      return;
+    }
     if (subcommand === "subdomain") {
       const newSubdomain = toolArgs;
       if (!newSubdomain) {