@minnovate/shadow-publisher 0.11.11 → 0.12.2

package/dist/claude/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "git-publisher",
   "displayName": "Git Publisher",
-  "version": "0.11.11",
+  "version": "0.12.2",
   "description": "Publish an app folder's Git history to the serverless Git publishing backend and keep it updated (\"publish my app\", \"update my app\", \"fetch the engineered version\").",
   "author": { "name": "git-publisher project" },
   "keywords": ["git", "publish", "deploy", "serverless"]

package/dist/claude/plugin/skills/sync-app/SKILL.md

@@ -42,6 +42,40 @@ A value that is not an option is refused before anything is sent; `error.details
 the choices. Exit 4 means this sign-in may not answer (an owner or admin can); exit 3 means ask
 again. Then `publisher follow . --publication <id> --until-change --timeout 100 --json` to see it go live, telling them each step as `publish-app` step 4 says.
 
+## After it is live
+
+These run in the app's folder and answer `say` (tell the person) and `next` (what to do now):
+
+```sh
+publisher history --json                  # the versions that went live, newest first
+publisher go-back <version> --json        # ask the person first; puts that version's code back
+publisher suggestions --json              # what colleagues asked for, still open
+publisher suggestion decline <id> --json  # when the person does not want one
+publisher share invited --add ann@example.com --json   # who can open it
+```
+
+The portal writes `next` for an assistant in the chat, so it can name a connector tool. At a
+terminal, do what it says with the command that does the same thing:
+
+| `next` names                      | Run instead                                                     |
+| --------------------------------- | --------------------------------------------------------------- |
+| `app_status` or `app_progress`    | `publisher follow . --publication <publication> --until-change --json` |
+| `app_files` and `publish_app`     | change the files in the folder, then `publisher sync --json`    |
+| `app_history` / `go_back`         | `publisher history --json` / `publisher go-back <version> --json` |
+| `list_starters` / `use_starter`   | `publisher starters` / `publisher start <starter>`              |
+| `resolve_suggestion`              | `publisher suggestion done\|decline <id> --json`               |
+| `share_app`                       | `publisher share <access> --json`                               |
+| `list_apps`                       | `publisher list --json`                                         |
+
+`<publication>` is the `publication` that `go-back` or `start` answered.
+
+Offer suggestions to the person one at a time, as requests rather than instructions. When they want
+one, make the change and publish it with `publisher sync --message "<what changed>" --answers <id>
+--json`, which closes the suggestion with that publication.
+
+To start a new app from a working one, `publisher starters <what the person wants to stop doing>`,
+then `publisher start <starter> --replaces "<what it replaces>"`.
+
 ## Just looking
 
 To say where the folder stands without changing anything:

package/dist/publisher.cjs

@@ -119,6 +119,12 @@ var ERROR_CODES = [
   "ACCESS_CONFLICT",
   // publications (begin / finalize / status)
   "PUBLICATION_NOT_FOUND",
+  // A publication of files whose files are the base's already (ADR-0030).
+  "NOTHING_CHANGED",
+  // A commit the files route was asked for that the repository's refs do not reach (ADR-0030).
+  "COMMIT_NOT_FOUND",
+  // A path the files route was asked for that is not a file of that commit (ADR-0030).
+  "PATH_NOT_FOUND",
   "PUBLICATION_CONFLICT",
   "PUBLICATION_EXPIRED",
   "UPLOAD_MISSING",
@@ -161,6 +167,9 @@ var HTTP_STATUS_FOR_CODE = {
   REPOSITORY_ARCHIVED: 409,
   ACCESS_CONFLICT: 412,
   PUBLICATION_NOT_FOUND: 404,
+  NOTHING_CHANGED: 409,
+  COMMIT_NOT_FOUND: 404,
+  PATH_NOT_FOUND: 404,
   PUBLICATION_CONFLICT: 409,
   PUBLICATION_EXPIRED: 410,
   UPLOAD_MISSING: 409,
@@ -243,9 +252,9 @@ function nullish(input) {
   return input === null || input === void 0;
 }
 function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
+  const start2 = source.startsWith("^") ? 1 : 0;
   const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
+  return source.slice(start2, end);
 }
 function assignProp(target, prop, value) {
   Object.defineProperty(target, prop, {
@@ -443,9 +452,9 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
   return typeof message === "string" ? message : message?.message;
 }
-function attachSchema(issues, start, inst) {
+function attachSchema(issues, start2, inst) {
   var _a2;
-  for (let i = start; i < issues.length; i++) {
+  for (let i = start2; i < issues.length; i++) {
     (_a2 = issues[i]).schema ?? (_a2.schema = inst);
   }
 }
@@ -2479,6 +2488,18 @@ function object(shape, params) {
 function extend2(schema, shape) {
   return extend(schema, shape);
 }
+var ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
+  $ZodUnion.init(inst, def);
+  ZodMiniType.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function union(options, params) {
+  return new ZodMiniUnion({
+    type: "union",
+    options,
+    ...normalizeParams(params)
+  });
+}
 var ZodMiniDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodMiniDiscriminatedUnion", (inst, def) => {
   $ZodDiscriminatedUnion.init(inst, def);
   ZodMiniType.init(inst, def);
@@ -2666,7 +2687,14 @@ var LimitsSchema = object({
    * Named `maxRepositoriesPerPrincipal` before 0.9.0, when it counted a creator's repositories.
    * Defaulted so an older server reads as the default, not a failure.
    */
-  maxRepositoriesPerOrganisation: _default(positiveInt(), 25)
+  maxRepositoriesPerOrganisation: _default(positiveInt(), 25),
+  // ---- a publication of files (ADR-0030) ----
+  /** the UTF-8 bytes of the files one file publication writes; the commit builder is invoked with them, and Lambda takes 6 MB */
+  maxFilePublicationBytes: _default(positiveInt(), 4 * 1024 * 1024),
+  /** the paths one file publication writes and removes, together */
+  maxFilePublicationPaths: _default(positiveInt(), 1e3),
+  /** the largest file `GET …/files` shows as text, one at a time or in a listing; a larger one is `too-large` */
+  maxShownFileBytes: _default(positiveInt(), 512 * 1024)
 });
 var DEFAULT_LIMITS = {
   maxPackBytes: 256 * 1024 * 1024,
@@ -2684,7 +2712,10 @@ var DEFAULT_LIMITS = {
   maxProcessMemoryBytes: 2 * 1024 * 1024 * 1024,
   maxTemporaryBytes: 3 * 512 * 1024 * 1024,
   gitTimeoutMs: 3e5,
-  maxRepositoriesPerOrganisation: 25
+  maxRepositoriesPerOrganisation: 25,
+  maxFilePublicationBytes: 4 * 1024 * 1024,
+  maxFilePublicationPaths: 1e3,
+  maxShownFileBytes: 512 * 1024
 };
 
 // ../protocol/src/storage-schema.ts
@@ -2850,6 +2881,11 @@ var PublicationRequestRecord = object({
   baseGeneration: Generation,
   refUpdates: array(RefUpdate).check(_minLength(1)),
   pack: nullable(PackClaim),
+  /**
+   * A publication of FILES (ADR-0030): the staged file set this service makes the commit from, in
+   * the worker, in the delivery that validates it. Its one ref update names no new commit until then.
+   */
+  files: _default(nullable(PackClaim), null),
   client: nullable(ClientInfo),
   principal: PrincipalId,
   receivedAt: IsoDate,
@@ -3026,6 +3062,63 @@ var BeginPublicationResponse = object({
   upload: nullable(UploadInstructions)
 });
 var PublicationStatusResponse = object({ publication: PublicationSummary });
+var FilePath = string2().check(_minLength(1), _maxLength(1024));
+var FilePublicationRequest = object({
+  publicationId: PublicationId,
+  /** the ref to move; the repository's head ref when left out */
+  ref: optional(RefName),
+  /** the commit the files go on top of: the ref's current target, or null for a ref that does not exist yet */
+  base: nullable(Oid),
+  /** path → the file's whole content, as UTF-8 text */
+  files: record(FilePath, string2()),
+  replace: _default(boolean2(), false),
+  delete: _default(array(FilePath), []),
+  message: string2().check(_minLength(1), _maxLength(4e3)),
+  client: _default(nullable(ClientInfo), null)
+});
+var FilePublicationResponse = object({ publication: PublicationSummary, ref: RefName, commit: nullable(Oid) });
+var StagedFileSet = object({
+  files: record(FilePath, string2()),
+  replace: boolean2(),
+  delete: array(FilePath),
+  message: string2()
+});
+var RepositoryFilesResponse = object({
+  ref: RefName,
+  /** the ref's current target: the base a publication of files goes on */
+  head: nullable(Oid),
+  /** the commit these files are: `head`, or the one asked for */
+  commit: nullable(Oid),
+  files: record(FilePath, string2()),
+  unreadable: array(FilePath),
+  tooLarge: boolean2()
+});
+var FileShown = _enum(["text", "binary", "too-large"]);
+var RepositoryFileListResponse = object({
+  commit: nullable(Oid),
+  entries: array(
+    object({
+      path: FilePath,
+      /** bytes; null for a submodule */
+      bytes: nullable(int()),
+      kind: _enum(["file", "symlink", "submodule"]),
+      /** null for a symlink or a submodule */
+      shown: nullable(FileShown)
+    })
+  )
+});
+var RepositoryFileResponse = object({ path: FilePath, bytes: int(), shown: FileShown, text: nullable(string2()) });
+var FileReadJob = object({
+  repoId: RepoId,
+  at: nullable(Oid),
+  read: union([object({ kind: literal("files") }), object({ kind: literal("list") }), object({ kind: literal("file"), path: FilePath })])
+});
+var FileReadResult = union([
+  object({ kind: literal("files"), answer: RepositoryFilesResponse }),
+  object({ kind: literal("list"), answer: RepositoryFileListResponse }),
+  object({ kind: literal("file"), answer: RepositoryFileResponse }),
+  object({ kind: literal("refused"), code: _enum(ERROR_CODES), message: string2() })
+]);
 var DownloadDescriptor = object({
   url: url(),
   sha256: Sha256Hex,
@@ -3232,8 +3325,8 @@ function closeOrIgnored(child) {
   if (lc.ignored) {
     return Promise.resolve(false);
   }
-  return new Promise((resolve4) => {
-    lc.waiters.add(() => resolve4(childClosed(child)));
+  return new Promise((resolve5) => {
+    lc.waiters.add(() => resolve5(childClosed(child)));
   });
 }
 async function endedOrIgnored(child) {
@@ -3270,7 +3363,7 @@ function signalChildGroup(child, signal) {
     }
   }
 }
-function waitWithin(start, ms, stop) {
+function waitWithin(start2, ms, stop) {
   if (ms <= 0) {
     return Promise.resolve({ status: "timeout" });
   }
@@ -3278,7 +3371,7 @@ function waitWithin(start, ms, stop) {
     return Promise.resolve({ status: "stopped" });
   }
   const ac = new AbortController();
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let timer = null;
     let done = false;
     const onStop = () => settle({ status: "stopped" });
@@ -3294,11 +3387,11 @@ function waitWithin(start, ms, stop) {
       if (r.status !== "value" && r.status !== "error") {
         ac.abort();
       }
-      resolve4(r);
+      resolve5(r);
     };
     let p;
     try {
-      p = start(ac.signal);
+      p = start2(ac.signal);
     } catch (error2) {
       settle({ status: "error", error: error2 });
       return;
@@ -3333,24 +3426,24 @@ function spawnTracked(args, opts) {
 }
 function feedStdin(child, input, onSourceError) {
   let unpipe = () => void 0;
-  const done = new Promise((resolve4) => {
-    child.stdin.on("error", () => resolve4());
+  const done = new Promise((resolve5) => {
+    child.stdin.on("error", () => resolve5());
     if (input === void 0) {
       child.stdin.end();
-      resolve4();
+      resolve5();
     } else if (typeof input === "string" || Buffer.isBuffer(input)) {
-      child.stdin.end(input, () => resolve4());
+      child.stdin.end(input, () => resolve5());
     } else {
       input.on("error", () => {
         onSourceError();
-        resolve4();
+        resolve5();
       });
       input.pipe(child.stdin);
       unpipe = () => {
         input.unpipe(child.stdin);
-        resolve4();
+        resolve5();
       };
-      child.stdin.on("finish", () => resolve4());
+      child.stdin.on("finish", () => resolve5());
       child.on("close", unpipe);
     }
   });
@@ -3463,18 +3556,18 @@ function startWatchdog(child, opts, kill, isClosed) {
   const pgid = child.pid;
   let stopped = false;
   const stopper = new AbortController();
-  const sleep2 = (ms) => new Promise((resolve4) => {
+  const sleep2 = (ms) => new Promise((resolve5) => {
     const wake = () => {
       clearTimeout(t);
       stopper.signal.removeEventListener("abort", wake);
-      resolve4();
+      resolve5();
     };
     const t = setTimeout(wake, ms);
     t.unref();
     stopper.signal.addEventListener("abort", wake, { once: true });
   });
-  const sample = async (what, start) => {
-    const r = await waitWithin(start, sampleBoundMs, stopper.signal);
+  const sample = async (what, start2) => {
+    const r = await waitWithin(start2, sampleBoundMs, stopper.signal);
     if (isClosed() || stopped) {
       return null;
     }
@@ -3724,7 +3817,7 @@ async function reapChild(child, opts = {}) {
       if (groupCleared || !childClosed(child) || Date.now() >= deadline) {
         break;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, Math.min(25, deadline - Date.now())));
+      await new Promise((resolve5) => setTimeout(resolve5, Math.min(25, deadline - Date.now())));
     }
     if (groupCleared === false) {
       timedOut = true;
@@ -3779,12 +3872,12 @@ var import_promises2 = require("node:fs/promises");
 async function sha256File(path) {
   const h = (0, import_node_crypto2.createHash)("sha256");
   let size = 0;
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     (0, import_node_fs2.createReadStream)(path).on("data", (c) => {
       const b = typeof c === "string" ? Buffer.from(c) : c;
       size += b.length;
       h.update(b);
-    }).on("error", reject).on("end", () => resolve4());
+    }).on("error", reject).on("end", () => resolve5());
   });
   const st = await (0, import_promises2.stat)(path);
   if (st.size !== size) {
@@ -3803,8 +3896,8 @@ async function indexPackFromFile(dir, packPath, opts = {}) {
   if (opts.maxInputBytes) {
     args.push(`--max-input-size=${opts.maxInputBytes}`);
   }
-  const run = { cwd: dir, input: (0, import_node_fs3.createReadStream)(packPath), label: "index-pack", ...opts };
-  const res = await runGit(args, { ...run, allowFailure: true });
+  const run2 = { cwd: dir, input: (0, import_node_fs3.createReadStream)(packPath), label: "index-pack", ...opts };
+  const res = await runGit(args, { ...run2, allowFailure: true });
   if (res.code !== 0) {
     const msg = res.stderr.trim().split("\n").pop() ?? "index-pack failed";
     const missing = /did not receive expected object|not a valid|missing/i.test(res.stderr);
@@ -3844,8 +3937,8 @@ async function refTransaction(dir, updates, opts = {}) {
 }
 async function batchCheck(dir, oids, opts = {}) {
   const input = Array.from(oids).join("\n") + "\n";
-  const run = { cwd: dir, input, maxStdoutBytes: 512 * 1024 * 1024, ...opts };
-  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"], run);
+  const run2 = { cwd: dir, input, maxStdoutBytes: 512 * 1024 * 1024, ...opts };
+  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"], run2);
   const out = [];
   for (const line of stdout.toString("utf8").split("\n")) {
     if (!line) {
@@ -3867,14 +3960,14 @@ async function resolveRevs(dir, revs, opts = {}) {
   const out = revs.map(
     (r) => r.startsWith("-") ? null : r.includes("\0") ? new PublisherError("INVALID_REQUEST", "NUL in git argument") : null
   );
-  const ask4 = revs.flatMap((r, i) => out[i] === null && !r.startsWith("-") ? [i] : []);
-  if (ask4.length === 0) {
+  const ask2 = revs.flatMap((r, i) => out[i] === null && !r.startsWith("-") ? [i] : []);
+  if (ask2.length === 0) {
     return out;
   }
-  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname)", "-Z"], { cwd: dir, input: ask4.map((i) => revs[i]).join("\0") + "\0", ...opts });
+  const { stdout } = await runGit(["cat-file", "--batch-check=%(objectname)", "-Z"], { cwd: dir, input: ask2.map((i) => revs[i]).join("\0") + "\0", ...opts });
   const records = stdout.toString("utf8").split("\0");
   const misses = [];
-  for (const [j, i] of ask4.entries()) {
+  for (const [j, i] of ask2.entries()) {
     const record2 = records[j] ?? "";
     if (record2 && !/ (missing|ambiguous)$/.test(record2)) {
       out[i] = record2;
@@ -3910,7 +4003,7 @@ async function packObjectsToFile(repoDir, extraArgs, stdinLines, opts) {
   opts.signal?.addEventListener("abort", onAbort, { once: true });
   let failure2 = null;
   try {
-    const finished = new Promise((resolve4, reject) => out.on("finish", () => resolve4()).on("error", reject));
+    const finished = new Promise((resolve5, reject) => out.on("finish", () => resolve5()).on("error", reject));
     finished.catch(() => void 0);
     child.stdout.pipe(out);
     child.stdin.on("error", () => void 0);
@@ -3959,8 +4052,8 @@ async function packObjectsToFile(repoDir, extraArgs, stdinLines, opts) {
 }
 function delay(ms) {
   let t;
-  const p = new Promise((resolve4) => {
-    t = setTimeout(resolve4, ms);
+  const p = new Promise((resolve5) => {
+    t = setTimeout(resolve5, ms);
     t.unref();
   });
   p.cancel = () => clearTimeout(t);
@@ -4109,12 +4202,12 @@ async function commitPaths(dir, paths, opts) {
   if (paths.length === 0) {
     throw new PublisherError("LOCAL_STATE", "no files selected to commit");
   }
-  const run = { cwd: dir, env: authorEnv(opts) };
+  const run2 = { cwd: dir, env: authorEnv(opts) };
   if (opts.signal) {
-    run.signal = opts.signal;
+    run2.signal = opts.signal;
   }
-  await runGit(["add", "--pathspec-from-file=-", "--pathspec-file-nul"], { ...run, input: paths.join("\0") + "\0" });
-  await runGit(["commit", "-q", "--no-verify", "-m", opts.message], run);
+  await runGit(["add", "--pathspec-from-file=-", "--pathspec-file-nul"], { ...run2, input: paths.join("\0") + "\0" });
+  await runGit(["commit", "-q", "--no-verify", "-m", opts.message], run2);
   const head = await headCommit(dir);
   if (!head) {
     throw new PublisherError("GIT", "commit did not produce HEAD");
@@ -5043,6 +5136,49 @@ async function updateEntry(url2, change) {
   await writeCredentials(file);
 }
 
+// ../client/src/portal-request.ts
+var PortalSession = class {
+  constructor(credential) {
+    this.credential = credential;
+  }
+  credential;
+  #refreshed = false;
+  async ask(url2, body) {
+    const { token, refresh } = this.credential;
+    for (; ; ) {
+      const answer2 = await askPortal(this.credential.fetch ?? fetch, url2, await token(), body);
+      if (answer2.status === 401 && !this.#refreshed && refresh !== void 0) {
+        this.#refreshed = true;
+        if (await refresh()) {
+          continue;
+        }
+      }
+      return answer2;
+    }
+  }
+};
+async function askPortal(fetchImpl, url2, token, body) {
+  try {
+    const res = await fetchImpl(url2, {
+      method: body === void 0 ? "GET" : "POST",
+      headers: { authorization: `Bearer ${token}`, accept: "application/json", ...body === void 0 ? {} : { "content-type": "application/json" } },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      signal: AbortSignal.timeout(3e4)
+    });
+    const text = await res.text();
+    try {
+      return { status: res.status, body: text ? JSON.parse(text) : null };
+    } catch {
+      return { status: res.status, body: void 0 };
+    }
+  } catch {
+    return { status: 0, body: null };
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ../client/src/portal-refusal.ts
 function portalRefusalCode(body) {
   if (!isRecord(body)) {
@@ -5058,9 +5194,6 @@ function portalRefusalCode(body) {
   const { code, message } = error2;
   return typeof code === "string" && code !== "" && typeof message === "string" ? code : null;
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // ../client/src/application.ts
 var APPLICATION_CREATION = "application-creation";
@@ -5070,19 +5203,12 @@ var REFUSALS = {
   "repository-conflict": "REPOSITORY_CONFLICT"
 };
 async function createApplication(input, opts) {
-  const fetchImpl = opts.fetch ?? fetch;
   const url2 = `${input.portal.replace(/\/+$/, "")}/api/v1/terminal/applications`;
   const body = { creationId: input.creationId ?? newCreationId(), name: input.name, defaultBranch: input.defaultBranch ?? "main" };
-  let refreshed = false;
+  const portal = new PortalSession(opts);
   let lastOutage = "";
   for (let attempt = 0; attempt < ATTEMPTS; ) {
-    const answer2 = await post(fetchImpl, url2, await opts.token(), body);
-    if (answer2.status === 401 && !refreshed && opts.refresh !== void 0) {
-      refreshed = true;
-      if (await opts.refresh()) {
-        continue;
-      }
-    }
+    const answer2 = await portal.ask(url2, body);
     if (answer2.status === 200 || answer2.status === 201) {
       return read(answer2.body, answer2.status === 201);
     }
@@ -5102,40 +5228,19 @@ async function createApplication(input, opts) {
     lastOutage = answer2.status === 0 ? "the portal could not be reached" : `the portal answered ${answer2.status}`;
     attempt += 1;
     if (attempt < ATTEMPTS) {
-      await new Promise((resolve4) => setTimeout(resolve4, (opts.retryDelayMs ?? 1e3) * attempt));
+      await new Promise((resolve5) => setTimeout(resolve5, (opts.retryDelayMs ?? 1e3) * attempt));
     }
   }
   throw new PublisherError("UNAVAILABLE", `could not make the application: ${lastOutage}; run init again`, { retryable: true });
 }
 function read(body, created) {
-  const application = isRecord2(body) ? body["application"] : void 0;
-  const repository = RepositoryInfo.safeParse(isRecord2(body) ? body["repository"] : void 0);
-  if (!isRecord2(application) || typeof application["appId"] !== "string" || !repository.success) {
+  const application = isRecord(body) ? body["application"] : void 0;
+  const repository = RepositoryInfo.safeParse(isRecord(body) ? body["repository"] : void 0);
+  if (!isRecord(application) || typeof application["appId"] !== "string" || !repository.success) {
     throw new PublisherError("UNAVAILABLE", "the portal answered with an application this version cannot read");
   }
   return { appId: application["appId"], created, repository: repository.data };
 }
-async function post(fetchImpl, url2, token, body) {
-  try {
-    const res = await fetchImpl(url2, {
-      method: "POST",
-      headers: { authorization: `Bearer ${token}`, accept: "application/json", "content-type": "application/json" },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(3e4)
-    });
-    const text = await res.text();
-    try {
-      return { status: res.status, body: text ? JSON.parse(text) : null };
-    } catch {
-      return { status: res.status, body: void 0 };
-    }
-  } catch {
-    return { status: 0, body: null };
-  }
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // ../client/src/transport.ts
 function assertCredentialEndpoint(endpoint) {
@@ -5251,8 +5356,8 @@ function fallbackCode(status2) {
   return status2 >= 500 ? "UNAVAILABLE" : "INVALID_REQUEST";
 }
 function sleep(ms, signal) {
-  return new Promise((resolve4, reject) => {
-    const t = setTimeout(resolve4, ms);
+  return new Promise((resolve5, reject) => {
+    const t = setTimeout(resolve5, ms);
     signal?.addEventListener(
       "abort",
       () => {
@@ -5268,21 +5373,21 @@ function sleep(ms, signal) {
 var RUN_STAGES = ["received", "running", "deploying", "live"];
 var STAGE_WORDS = { received: "received", running: "checked", deploying: "going live", live: "live" };
 var STATES = ["pending", "in-progress", "done", "failed", "skipped"];
-function readStages(run) {
-  if (!isRecord3(run)) {
+function readStages(run2) {
+  if (!isRecord(run2)) {
     return { malformed: "a run that is not an object" };
   }
-  if (!Object.hasOwn(run, "stages")) {
+  if (!Object.hasOwn(run2, "stages")) {
     return null;
   }
-  const stages = run["stages"];
+  const stages = run2["stages"];
   if (!Array.isArray(stages) || stages.length !== RUN_STAGES.length) {
     return { malformed: "stages that are not exactly four" };
   }
   const out = [];
   for (const [index, entry] of stages.entries()) {
     const stage = RUN_STAGES[index];
-    if (!isRecord3(entry) || entry["stage"] !== stage) {
+    if (!isRecord(entry) || entry["stage"] !== stage) {
       return { malformed: `stage ${index + 1} is not ${stage}` };
     }
     const state = entry["state"];
@@ -5315,7 +5420,7 @@ function ending(stages) {
 var POLL_INTERVAL_MS = 5e3;
 var FOLLOW_TIMEOUT_MS = 15 * 6e4;
 async function followRun(input, opts) {
-  const fetchImpl = opts.fetch ?? fetch;
+  const portal = new PortalSession(opts);
   const sleep2 = opts.sleep ?? sleep;
   const now = opts.now ?? Date.now;
   const interval2 = opts.intervalMs ?? POLL_INTERVAL_MS;
@@ -5325,16 +5430,9 @@ async function followRun(input, opts) {
   const seen = /* @__PURE__ */ new Map();
   let last = null;
   let lastError = null;
-  let refreshed = false;
   let answered = false;
   for (; ; ) {
-    const answer2 = await ask(fetchImpl, url2, await opts.token());
-    if (answer2.status === 401 && !refreshed && opts.refresh !== void 0) {
-      refreshed = true;
-      if (await opts.refresh()) {
-        continue;
-      }
-    }
+    const answer2 = await portal.ask(url2, void 0);
     if (answer2.status === 401) {
       return { kind: "unauthorized" };
     }
@@ -5345,12 +5443,12 @@ async function followRun(input, opts) {
       return { kind: "forbidden" };
     }
     if (answer2.status === 200) {
-      const run = soleRun(answer2.body);
-      if ("detail" in run) {
-        return { kind: "malformed", detail: run.detail };
+      const run2 = soleRun(answer2.body);
+      if ("detail" in run2) {
+        return { kind: "malformed", detail: run2.detail };
       }
-      if (run.run !== null) {
-        const read2 = readStages(run.run);
+      if (run2.run !== null) {
+        const read2 = readStages(run2.run);
         if (read2 === null) {
           return { kind: "unavailable", reason: "no-stages" };
         }
@@ -5367,12 +5465,12 @@ async function followRun(input, opts) {
           opts.onStage?.(entry);
           moved = true;
         }
-        if (isRecord3(run.run) && run.run["status"] === "awaiting-approval") {
+        if (isRecord(run2.run) && run2.run["status"] === "awaiting-approval") {
           return { kind: "waiting", stages: read2.stages };
         }
         const end = ending(read2.stages);
         if (end !== null) {
-          const runId = isRecord3(run.run) && typeof run.run["runId"] === "string" ? run.run["runId"] : null;
+          const runId = isRecord(run2.run) && typeof run2.run["runId"] === "string" ? run2.run["runId"] : null;
           return { kind: "settled", ending: end, failedAt: read2.stages.find((s) => s.state === "failed")?.word ?? null, stages: read2.stages, runId };
         }
         if (opts.untilChange === true && moved && answered) {
@@ -5391,7 +5489,7 @@ async function followRun(input, opts) {
   }
 }
 function soleRun(body) {
-  if (!isRecord3(body) || !Array.isArray(body["runs"])) {
+  if (!isRecord(body) || !Array.isArray(body["runs"])) {
     return { detail: "an answer with no list of runs" };
   }
   const runs = body["runs"];
@@ -5400,23 +5498,6 @@ function soleRun(body) {
   }
   return { run: runs[0] ?? null };
 }
-async function ask(fetchImpl, url2, token) {
-  try {
-    const res = await fetchImpl(url2, { headers: { authorization: `Bearer ${token}`, accept: "application/json" }, signal: AbortSignal.timeout(3e4) });
-    const text = await res.text();
-    let body = null;
-    try {
-      body = text ? JSON.parse(text) : null;
-    } catch {
-      if (res.status === 200) {
-        return { status: 200, body: void 0 };
-      }
-    }
-    return { status: res.status, body };
-  } catch {
-    return { status: 0, body: null };
-  }
-}
 function portalForEndpoint(endpoint) {
   let url2;
   try {
@@ -5448,9 +5529,6 @@ async function confirmPortal(portal, endpoint, fetchImpl = fetch) {
     return null;
   }
 }
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // ../client/src/preparation.ts
 var PREPARATION = "preparation";
@@ -5464,38 +5542,28 @@ function answerPreparation(input, opts) {
   return call(input, opts, { id: input.id, revision: input.revision, action: "answers", answers: input.answers });
 }
 async function call(input, opts, body) {
-  const fetchImpl = opts.fetch ?? fetch;
   const url2 = `${input.portal.replace(/\/+$/, "")}/api/v1/terminal/repositories/${encodeURIComponent(input.repoId)}/preparation`;
-  let refreshed = false;
-  for (; ; ) {
-    const answer2 = await ask2(fetchImpl, url2, await opts.token(), body);
-    if (answer2.status === 401 && !refreshed && opts.refresh !== void 0) {
-      refreshed = true;
-      if (await opts.refresh()) {
-        continue;
-      }
-    }
-    if (answer2.status === 401) {
-      return { kind: "unauthorized" };
-    }
-    if (answer2.status === 403) {
-      return { kind: "forbidden" };
-    }
-    if (answer2.status === 409) {
-      return { kind: "moved-on" };
-    }
-    if (answer2.status === 404) {
-      return portalRefusalCode(answer2.body) === "no-such-application" ? { kind: "no-application" } : { kind: "unavailable", detail: "the portal does not serve this address" };
-    }
-    if (answer2.status === 200) {
-      const view = readView(answer2.body);
-      return "detail" in view ? { kind: "malformed", detail: view.detail } : { kind: "view", view };
-    }
-    return { kind: "unavailable", detail: answer2.status === 0 ? "the portal could not be reached" : `the portal answered ${answer2.status}` };
+  const answer2 = await new PortalSession(opts).ask(url2, body);
+  if (answer2.status === 401) {
+    return { kind: "unauthorized" };
   }
+  if (answer2.status === 403) {
+    return { kind: "forbidden" };
+  }
+  if (answer2.status === 409) {
+    return { kind: "moved-on" };
+  }
+  if (answer2.status === 404) {
+    return portalRefusalCode(answer2.body) === "no-such-application" ? { kind: "no-application" } : { kind: "unavailable", detail: "the portal does not serve this address" };
+  }
+  if (answer2.status === 200) {
+    const view = readView(answer2.body);
+    return "detail" in view ? { kind: "malformed", detail: view.detail } : { kind: "view", view };
+  }
+  return { kind: "unavailable", detail: answer2.status === 0 ? "the portal could not be reached" : `the portal answered ${answer2.status}` };
 }
 function readView(body) {
-  if (!isRecord4(body)) {
+  if (!isRecord(body)) {
     return { detail: "an answer that is not a preparation" };
   }
   const { id, revision, status: status2, message, questions, publication } = body;
@@ -5516,12 +5584,12 @@ function readView(body) {
   }
   const read2 = [];
   for (const q of questions) {
-    if (!isRecord4(q) || typeof q["id"] !== "string" || typeof q["text"] !== "string" || !Array.isArray(q["options"]) || q["options"].length === 0) {
+    if (!isRecord(q) || typeof q["id"] !== "string" || typeof q["text"] !== "string" || !Array.isArray(q["options"]) || q["options"].length === 0) {
       return { detail: "a question that cannot be answered" };
     }
     const options = [];
     for (const o of q["options"]) {
-      if (!isRecord4(o) || typeof o["value"] !== "string" || typeof o["label"] !== "string") {
+      if (!isRecord(o) || typeof o["value"] !== "string" || typeof o["label"] !== "string") {
         return { detail: "a question with an unreadable option" };
       }
       options.push({ value: o["value"], label: o["label"] });
@@ -5529,7 +5597,7 @@ function readView(body) {
     read2.push({ id: q["id"], text: q["text"], options });
   }
   let pub = null;
-  if (isRecord4(publication) && typeof publication["status"] === "string" && typeof publication["message"] === "string") {
+  if (isRecord(publication) && typeof publication["status"] === "string" && typeof publication["message"] === "string") {
     pub = { status: publication["status"], message: publication["message"], ...typeof publication["url"] === "string" ? { url: publication["url"] } : {} };
   }
   return { id, revision, status: status2, message, questions: read2, publication: pub, findings: readFindings(body["findings"]) };
@@ -5544,7 +5612,7 @@ function readFindings(value) {
     if (out.length === MAX_FINDINGS) {
       break;
     }
-    if (!isRecord4(f)) {
+    if (!isRecord(f)) {
       continue;
     }
     const kind = text(f["kind"]);
@@ -5566,26 +5634,30 @@ function readFindings(value) {
   }
   return out;
 }
-async function ask2(fetchImpl, url2, token, body) {
-  try {
-    const res = await fetchImpl(url2, {
-      method: body === void 0 ? "GET" : "POST",
-      headers: { authorization: `Bearer ${token}`, accept: "application/json", ...body === void 0 ? {} : { "content-type": "application/json" } },
-      ...body === void 0 ? {} : { body: JSON.stringify(body) },
-      signal: AbortSignal.timeout(3e4)
-    });
-    const text = await res.text();
-    try {
-      return { status: res.status, body: text ? JSON.parse(text) : null };
-    } catch {
-      return { status: res.status, body: void 0 };
-    }
-  } catch {
-    return { status: 0, body: null };
+
+// ../client/src/creator-tools.ts
+var CREATOR_TOOLS = "creator-tools";
+async function runCreatorTool(input, opts) {
+  const url2 = `${input.portal.replace(/\/+$/, "")}/api/v1/terminal/tools/${encodeURIComponent(input.tool)}`;
+  const answer2 = await new PortalSession(opts).ask(url2, input.args);
+  if (answer2.status === 401) {
+    return { kind: "unauthorized" };
   }
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  if (answer2.status === 403) {
+    return { kind: "forbidden" };
+  }
+  if (answer2.status === 404) {
+    return { kind: "unavailable", detail: "the portal does not serve this tool" };
+  }
+  if (answer2.status !== 200) {
+    return { kind: "unavailable", detail: answer2.status === 0 ? "the portal could not be reached" : `the portal answered ${answer2.status}` };
+  }
+  const body = answer2.body;
+  if (!isRecord(body) || typeof body["say"] !== "string" || typeof body["next"] !== "string") {
+    return { kind: "malformed", detail: "an answer with no say and next" };
+  }
+  const { say, next, isError, ...fields } = body;
+  return { kind: "answer", answer: { say, next, isError: isError === true, fields } };
 }
 
 // ../client/src/onboard.ts
@@ -6374,6 +6446,14 @@ var Publisher = class {
   async answerPreparation(input) {
     return answerPreparation(input, this.portalCall());
   }
+  /**
+   * One of the creator's tools at the portal that serves this endpoint — starters, status, history,
+   * going back, suggestions, sharing — with this publisher's credential and its one refresh. The
+   * caller confirms the portal's `/config` lists `CREATOR_TOOLS` first.
+   */
+  async runCreatorTool(input) {
+    return runCreatorTool(input, this.portalCall());
+  }
   portalCall() {
     return {
       token: this.tokenFn,
@@ -6782,6 +6862,11 @@ var OPTIONS = {
   theirs: { type: "string" },
   to: { type: "string" },
   cursor: { type: "string" },
+  replaces: { type: "string" },
+  run: { type: "string" },
+  answers: { type: "string" },
+  add: { type: "string", multiple: true },
+  remove: { type: "string", multiple: true },
   ref: { type: "string", multiple: true },
   json: { type: "boolean" },
   quiet: { type: "boolean" },
@@ -6845,6 +6930,28 @@ async function discoverEndpoint(portal, fetchImpl = fetch) {
   return endpoint;
 }
 
+// src/portal.ts
+var confirmed = /* @__PURE__ */ new Map();
+async function confirmedPortal(endpoint, opts = {}) {
+  const derived = portalForEndpoint(endpoint);
+  if (derived === null) {
+    return { kind: "none" };
+  }
+  const asked = opts.fetch === void 0 ? confirmed.get(endpoint) ?? confirmPortal(derived, endpoint) : confirmPortal(derived, endpoint, opts.fetch);
+  if (opts.fetch === void 0) {
+    confirmed.set(endpoint, asked);
+  }
+  const config2 = await asked;
+  return config2 === null ? { kind: "unconfirmed", portal: derived } : { kind: "confirmed", portal: derived, terminal: config2.terminal };
+}
+async function portalFor(endpoint, route, opts = {}) {
+  const at = await confirmedPortal(endpoint, opts);
+  if (at.kind !== "confirmed") {
+    return { kind: "no-portal" };
+  }
+  return at.terminal.includes(route) ? { kind: "served", portal: at.portal } : { kind: "no-route", portal: at.portal };
+}
+
 // src/progress.ts
 var SAYS = {
   received: { doing: "Shadow is picking up your changes", done: "Shadow has your changes", still: "still picking up your changes" },
@@ -6945,28 +7052,27 @@ function stageReporter(io) {
 
 // src/follow.ts
 async function followPublication(p, endpoint, o, opts) {
-  const derived = portalForEndpoint(endpoint);
-  const confirmed = derived === null ? null : await confirmPortal(derived, endpoint, opts.fetch);
-  const portal = confirmed === null ? null : derived;
+  const confirmed2 = await confirmedPortal(endpoint, opts);
+  const portal = confirmed2.kind === "confirmed" ? confirmed2.portal : null;
   const elsewhere = (reason) => ({ kind: "unavailable", reason, portal, hint: inPortal(portal, "Published.", "Follow it") });
-  if (portal === null || confirmed === null) {
+  if (portal === null || confirmed2.kind !== "confirmed") {
     return elsewhere("no-portal");
   }
-  if (!confirmed.terminal.includes(RUN_PROGRESS)) {
+  if (!confirmed2.terminal.includes(RUN_PROGRESS)) {
     const noRoute = { kind: "unavailable", reason: "no-route" };
     return { ...noRoute, portal, hint: progressHint(noRoute, portal) };
   }
-  const refs = Object.entries(o.refs ?? {});
-  if (refs.length !== 1) {
+  const moved = publishedRef(o);
+  if (moved === null) {
     return elsewhere("several-refs");
   }
-  const [ref, commit] = refs[0];
+  const { ref, commit } = moved;
   opts.log("Following it to live: received -> checked -> going live -> live. Ctrl-C stops watching; the publication is saved and carries on without you.");
   const outcome2 = await p.followRun(
     { portal, repoId: o.repoId, publicationId: o.publicationId, ref, commit },
     { onStage: opts.onStage, ...opts.timeoutMs === void 0 ? {} : { timeoutMs: opts.timeoutMs }, ...opts.untilChange === true ? { untilChange: true } : {} }
   ).finally(() => opts.stopStages?.());
-  const answerable = confirmed.terminal.includes(PREPARATION);
+  const answerable = confirmed2.terminal.includes(PREPARATION);
   const dir = shellWord(opts.dir);
   const next = outcome2.kind === "timed-out" || outcome2.kind === "moving" ? { action: "follow", command: `publisher follow ${dir} --publication ${o.publicationId}${opts.untilChange === true ? " --until-change" : ""} --json` } : outcome2.kind === "waiting" && answerable ? { action: "question", command: `publisher question ${dir} --json` } : void 0;
   const findings = await failedChecks(p, portal, o.repoId, outcome2, answerable);
@@ -6981,6 +7087,14 @@ async function followPublication(p, endpoint, o, opts) {
   }
   return { ...outcome2, portal, hint: progressHint(outcome2, portal, answerable), ...next === void 0 ? {} : { next } };
 }
+function publishedRef(o) {
+  const refs = Object.entries(o.refs ?? {});
+  if (refs.length !== 1) {
+    return null;
+  }
+  const [ref, commit] = refs[0];
+  return { ref, commit };
+}
 async function failedChecks(p, portal, repoId, outcome2, served) {
   if (!served || outcome2.kind !== "settled" || outcome2.ending !== "failed" || outcome2.runId === null) {
     return null;
@@ -7080,7 +7194,7 @@ function resolveChoice(answer2, names) {
   }
   return names.find((n) => n.toLowerCase() === a.toLowerCase()) ?? null;
 }
-async function ask3(question2) {
+async function ask(question2) {
   const rl = (0, import_promises11.createInterface)({ input: process.stdin, output: process.stderr });
   try {
     return await rl.question(question2);
@@ -7098,7 +7212,7 @@ ${purpose}
   names.forEach((n, i) => process.stderr.write(`  ${i + 1}) ${n}
 `));
   for (let attempt = 0; attempt < 3; attempt++) {
-    const answer2 = await ask3(`
+    const answer2 = await ask(`
 Which one? [1-${names.length}, or a name] `);
     if (answer2 === null) {
       return null;
@@ -7118,7 +7232,7 @@ Name this connection, so you never have to type ${endpoint} again.
 (for example: prod, dev, staging)
 `);
   for (let attempt = 0; attempt < 3; attempt++) {
-    const answer2 = await ask3(suggested ? `
+    const answer2 = await ask(suggested ? `
 Profile name [${suggested}]: ` : `
 Profile name: `);
     if (answer2 === null) {
@@ -7407,14 +7521,14 @@ function packageVersion() {
   }
 }
 function claude(args) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let stdout = "";
     let stderr = "";
     const child = (0, import_node_child_process3.spawn)("claude", args, { stdio: ["ignore", "pipe", "pipe"] });
     child.stdout.on("data", (d) => stdout += d.toString("utf8"));
     child.stderr.on("data", (d) => stderr += d.toString("utf8"));
-    child.on("error", (e) => resolve4({ code: null, stdout, stderr: e.message, missing: e.code === "ENOENT" }));
-    child.on("close", (code) => resolve4({ code, stdout, stderr, missing: false }));
+    child.on("error", (e) => resolve5({ code: null, stdout, stderr: e.message, missing: e.code === "ENOENT" }));
+    child.on("close", (code) => resolve5({ code, stdout, stderr, missing: false }));
   });
 }
 async function installSkills({ log }) {
@@ -7551,15 +7665,15 @@ var skills = {
 
 // src/init.ts
 async function repositoryForInit(p, endpoint, name, opts = {}) {
-  const portal = portalForEndpoint(endpoint);
-  if (portal === null) {
+  const confirmed2 = await confirmedPortal(endpoint, opts);
+  if (confirmed2.kind === "none") {
     return { repoId: (await p.createRepository({ name, grants: [] })).repoId, appId: null };
   }
-  const confirmed = await confirmPortal(portal, endpoint, opts.fetch);
-  if (confirmed === null) {
+  const { portal } = confirmed2;
+  if (confirmed2.kind === "unconfirmed") {
     throw new PublisherError("UNAVAILABLE", `could not confirm that ${portal} publishes to ${endpoint}; run init again`, { retryable: true });
   }
-  if (!confirmed.terminal.includes(APPLICATION_CREATION)) {
+  if (!confirmed2.terminal.includes(APPLICATION_CREATION)) {
     throw new PublisherError("UNAVAILABLE", `${portal} cannot make an application from a terminal yet, and a repository needs one; ask whoever runs it to update the portal`);
   }
   const made = await p.createApplication({ portal, name });
@@ -7766,15 +7880,20 @@ function parseSpecs(specs) {
   return answers;
 }
 async function portalAt(endpoint, opts) {
-  const derived = portalForEndpoint(endpoint);
-  const confirmed = derived === null ? null : await confirmPortal(derived, endpoint, opts.fetch);
-  if (derived === null || confirmed === null) {
-    return { kind: "unavailable", reason: "no-portal", portal: null, hint: "Answer it in the portal." };
-  }
-  if (!confirmed.terminal.includes(PREPARATION)) {
-    return { kind: "unavailable", reason: "no-route", portal: derived, hint: `This portal cannot show the question in the terminal yet. Answer it in the portal: ${derived}.` };
+  const at = await portalFor(endpoint, PREPARATION, opts);
+  switch (at.kind) {
+    case "served":
+      return { portal: at.portal };
+    case "no-portal":
+      return { kind: "unavailable", reason: "no-portal", portal: null, hint: "Answer it in the portal." };
+    case "no-route":
+      return {
+        kind: "unavailable",
+        reason: "no-route",
+        portal: at.portal,
+        hint: `This portal cannot show the question in the terminal yet. Answer it in the portal: ${at.portal}.`
+      };
   }
-  return { portal: derived };
 }
 function shown(portal, r) {
   switch (r.kind) {
@@ -7843,6 +7962,116 @@ var answer = {
   }
 };
 
+// src/commands/creator.ts
+var import_node_path10 = require("node:path");
+
+// src/creator.ts
+async function creatorTool(p, endpoint, tool, args, opts = {}) {
+  const at = await portalFor(endpoint, CREATOR_TOOLS, opts);
+  if (at.kind === "no-portal") {
+    throw new PublisherError("UNAVAILABLE", "no portal answers for this endpoint, so this can only be done in the chat or the portal");
+  }
+  if (at.kind === "no-route") {
+    throw new PublisherError("UNAVAILABLE", `this portal cannot do this from the terminal yet; do it in the chat or at ${at.portal}`);
+  }
+  const result = await p.runCreatorTool({ portal: at.portal, tool, args });
+  switch (result.kind) {
+    case "answer":
+      return result.answer;
+    case "unauthorized":
+      throw new PublisherError("UNAUTHORIZED", "the portal did not accept this sign-in; run publisher login");
+    case "forbidden":
+      throw new PublisherError("FORBIDDEN", "the portal will not let this sign-in do that in this organisation");
+    case "unavailable":
+      throw new PublisherError("UNAVAILABLE", `the portal could not be asked: ${result.detail}`, { retryable: true });
+    case "malformed":
+      throw new PublisherError("UNAVAILABLE", `the portal's answer could not be read: ${result.detail}`);
+  }
+}
+function printed(answer2) {
+  return { say: answer2.say, next: answer2.next, refused: answer2.isError, ...answer2.fields };
+}
+
+// src/commands/creator.ts
+async function run(inv, dir, tool, args) {
+  const { p, endpoint } = await inv.client(dir);
+  const answer2 = await creatorTool(p, endpoint, tool, args);
+  inv.out(printed(answer2));
+  return answer2.isError ? 1 : 0;
+}
+async function folderApp(inv) {
+  const dir = (0, import_node_path10.resolve)(".");
+  return { dir, app: await inv.repoId(dir) };
+}
+function listFlag(inv, name) {
+  const value = inv.flags[name];
+  const parts = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  return parts.flatMap((v) => v.split(",")).map((v) => v.trim()).filter((v) => v !== "");
+}
+var starters = {
+  git: false,
+  run: (inv) => run(inv, void 0, "list_starters", { need: inv.cmd.slice(1).join(" ") })
+};
+var start = {
+  git: false,
+  async run(inv) {
+    const starter = inv.cmd[1];
+    if (starter === void 0) {
+      throw new PublisherError("INVALID_REQUEST", "start takes a starter id; publisher starters lists them");
+    }
+    return run(inv, void 0, "use_starter", { starter, ...inv.optStr("name"), ...inv.optStr("replaces") });
+  }
+};
+var history = {
+  git: false,
+  async run(inv) {
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "app_history", { app });
+  }
+};
+var goBack = {
+  git: false,
+  async run(inv) {
+    const version2 = Number(inv.cmd[1]);
+    if (!Number.isSafeInteger(version2) || version2 < 1) {
+      throw new PublisherError("INVALID_REQUEST", "go-back takes a version number; publisher history lists them");
+    }
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "go_back", { app, version: version2 });
+  }
+};
+var suggestions = {
+  git: false,
+  async run(inv) {
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "app_suggestions", { app });
+  }
+};
+var suggestion = {
+  git: false,
+  async run(inv) {
+    const [, verb, id] = inv.cmd;
+    if (verb !== "done" && verb !== "decline" || id === void 0) {
+      throw new PublisherError("INVALID_REQUEST", "suggestion takes done or decline, and a suggestion id from publisher suggestions");
+    }
+    const { dir, app } = await folderApp(inv);
+    const status2 = verb === "done" ? "done" : "declined";
+    const runId = inv.str("run");
+    return run(inv, dir, "resolve_suggestion", { app, suggestion: id, status: status2, ...runId === void 0 ? {} : { runId } });
+  }
+};
+var share = {
+  git: false,
+  async run(inv) {
+    const access2 = inv.cmd[1];
+    if (access2 === void 0) {
+      throw new PublisherError("INVALID_REQUEST", "share takes organisation, invited or anyone-with-link");
+    }
+    const { dir, app } = await folderApp(inv);
+    return run(inv, dir, "share_app", { app, access: access2, add: listFlag(inv, "add"), remove: listFlag(inv, "remove") });
+  }
+};
+
 // src/commands/sync.ts
 var sync = {
   git: true,
@@ -7861,6 +8090,7 @@ var sync = {
     const acceptedAt = sending.done();
     const o = r.published;
     const followed = o !== null && o.state === "accepted" && inv.flags["no-wait"] !== true ? await followPublication(p, endpoint, o, { ...inv.following, timeoutMs, dir }) : null;
+    const answered = await answerSuggestion(inv, p, endpoint, linked?.repoId ?? (await readAssociation(dir))?.repoId, o);
     const syncTimings = clock.read(followed !== null && "stages" in followed ? runTimings(followed.stages, acceptedAt) : {});
     inv.log(timingsLine(syncTimings));
     inv.out({
@@ -7869,11 +8099,26 @@ var sync = {
       linked: linked === null ? null : { repoId: linked.repoId, appId: linked.appId, created: linked.created },
       ...outcome(r),
       progress: followed,
+      ...answered === null ? {} : { answered },
       timings: syncTimings
     });
     return r.state === "published" || r.state === "up_to_date" ? 0 : r.state === "unknown" ? 3 : 2;
   }
 };
+async function answerSuggestion(inv, p, endpoint, repoId, o) {
+  const id = inv.str("answers");
+  if (id === void 0 || repoId === void 0 || o === null || o.state !== "accepted" || o.publicationId === null) {
+    return null;
+  }
+  const moved = publishedRef(o);
+  if (moved === null) {
+    return null;
+  }
+  const { ref, commit } = moved;
+  return printed(
+    await creatorTool(p, endpoint, "resolve_suggestion", { app: repoId, suggestion: id, status: "done", publication: { publicationId: o.publicationId, ref, commit } })
+  );
+}
 function outcome(r) {
   const o = r.published;
   return {
@@ -7985,6 +8230,9 @@ var EXIT_CODE = {
   REPOSITORY_ARCHIVED: 1,
   ACCESS_CONFLICT: 1,
   PUBLICATION_NOT_FOUND: 1,
+  NOTHING_CHANGED: 1,
+  COMMIT_NOT_FOUND: 1,
+  PATH_NOT_FOUND: 1,
   PUBLICATION_CONFLICT: 1,
   PUBLICATION_EXPIRED: 1,
   UPLOAD_MISSING: 1,
@@ -8009,7 +8257,7 @@ function exitCodeFor(code) {
 }
 
 // src/invocation.ts
-var import_node_path10 = require("node:path");
+var import_node_path11 = require("node:path");
 var Invocation = class {
   cmd;
   flags;
@@ -8052,7 +8300,7 @@ var Invocation = class {
   };
   /** The folder named at position `i` of the command path, or the current one. */
   dirArg(i) {
-    return (0, import_node_path10.resolve)(this.cmd[i] ?? ".");
+    return (0, import_node_path11.resolve)(this.cmd[i] ?? ".");
   }
   /** A flag's value when it is a string, else undefined. */
   str(key) {
@@ -8109,15 +8357,15 @@ async function demand(r, input) {
   }
   const next = nextStep(credentialStatus(input));
   const details = { profiles: r.kind === "none" ? [] : r.profiles, next };
-  const run = next.command === null ? "" : ` Run: ${next.command}`;
+  const run2 = next.command === null ? "" : ` Run: ${next.command}`;
   switch (r.kind) {
     case "unknown-profile":
-      throw new PublisherError("LOCAL_STATE", `no such profile: ${r.name}.${run}`, { details });
+      throw new PublisherError("LOCAL_STATE", `no such profile: ${r.name}.${run2}`, { details });
     case "ambiguous":
-      throw new PublisherError("LOCAL_STATE", `several connections and none is the default: pass --profile <name>, or choose one once.${run}`, { details });
+      throw new PublisherError("LOCAL_STATE", `several connections and none is the default: pass --profile <name>, or choose one once.${run2}`, { details });
     case "none": {
       const where = await whereCredentialsWere();
-      throw new PublisherError("LOCAL_STATE", `not connected to a publishing service yet: ${where.sentence}${run}`, { details: { ...details, credentialsFile: where.details } });
+      throw new PublisherError("LOCAL_STATE", `not connected to a publishing service yet: ${where.sentence}${run2}`, { details: { ...details, credentialsFile: where.details } });
     }
   }
 }
@@ -8164,12 +8412,22 @@ Usage:
                                                         checked -> going live -> live, up to 15 minutes)
       [--timeout <seconds>]                             follow for at most this long; if it is still going, the
                                                         result's next.command picks it up
+      [--answers <suggestion>]                          the publication answers that suggestion: close it as done
   publisher follow [dir] --publication <id>             follow an accepted publication's run where a sync left it
       [--timeout <seconds>] [--until-change]            --until-change (sync too): return at the next step, to tell it
   publisher question [dir] [--repo <id>]                the question the app's preparation waits on, if any,
                                                         with each option's value (answering needs owner or admin)
   publisher answer <question>=<value>... [--repo <id>]  answer it from this folder; a value that is not one of
                                                         the question's options is refused before anything is sent
+  publisher starters [what you want to stop doing]      working apps to start from, the ones that fit first
+  publisher start <starter> [--name <n>] [--replaces <what>]   a new app made from a starter, live in about a minute
+  publisher history                                     this folder's app: the versions that went live, newest first
+  publisher go-back <version>                           put the code of an earlier version back, as the next version
+                                                        (the data and who can open the app stay as they are)
+  publisher suggestions                                 what colleagues suggested for this folder's app, still open
+  publisher suggestion done|decline <id> [--run <id>]   close one; sync --answers <id> closes it with that publication
+  publisher share organisation|invited|anyone-with-link [--add <emails>] [--remove <emails>]
+                                                        who can open this folder's app; new invitees get the link by mail
   publisher merge-check [dir] --ours <ref> --theirs <ref> [--apply]
   publisher info [dir]                                   repository state as seen by the server
   publisher doctor                                       environment check (node, git, credentials, association)
@@ -8213,7 +8471,14 @@ var COMMANDS = /* @__PURE__ */ new Map([
   ["answer", answer],
   ["skills", skills],
   ["merge-check", mergeCheck2],
-  ["info", info]
+  ["info", info],
+  ["starters", starters],
+  ["start", start],
+  ["history", history],
+  ["go-back", goBack],
+  ["suggestions", suggestions],
+  ["suggestion", suggestion],
+  ["share", share]
 ]);
 async function main(argv) {
   const inv = new Invocation(parseArgs(argv));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnovate/shadow-publisher",
-  "version": "0.11.11",
+  "version": "0.12.2",
   "description": "publisher: publish an app's Git history to the serverless Git backend",
   "license": "Apache-2.0",
   "type": "module",