@mulmoclaude/core 5.4.0 → 5.5.1

package/assets/helps/custom-view-remote.md

@@ -60,7 +60,7 @@ window.__MC_VIEW = {
   getItems: (opts) => Promise, // the ONLY way to read records — see below
   updateItem: (id, patch) => Promise, // patch declared fields (see Writing records)
   deleteItem: (id) => Promise, // remove a record (requires allowDelete)
-  startChat: (prompt, role) => void, // start a new chat seeded with the prompt (sent, not drafted)
+  startChat: (prompt, role) => void, // start a new chat — draft, or sent when the view declares allowSendChat
   t: (key, named) => string, // vue-i18n-style dict lookup (same as desktop)
 };
 ```
@@ -220,16 +220,25 @@ only way a remote view "does" anything beyond display:
 window.__MC_VIEW.startChat("Mark task " + item.id + " as done.");
 ```
 
-**On the phone the prompt is sent, not drafted** — one press and the turn runs.
-A phone has no Enter key to press, so leaving the text sitting in an input box
-would simply strand the work. (The desktop custom view drafts by default and
-sends only when its `views[]` entry declares `allowSendChat: true`; the desktop
-phone-frame preview follows that same declaration, so declare it there too if
-you want the preview to behave the way the phone will.)
+**The phone follows the view's `allowSendChat` declaration**, exactly as the
+desktop does — it is read from the `views[]` entry, never from your code:
 
-So whatever you compose becomes an agent turn verbatim, with every tool
-available. Build the prompt from your own records, and don't paste text you
-fetched from somewhere else into it.
+- **Not declared** — the prompt opens as an **editable draft** in the chat sheet,
+  and the user presses Send.
+- **`"allowSendChat": true`** — **one press and the turn runs**.
+
+```jsonc
+{ "id": "tasks", "label": "Tasks", "file": "views/tasks.html", "target": "mobile", "allowSendChat": true }
+```
+
+Declare it whenever a button is meant to start work: an undeclared view makes
+the user open the sheet and send by hand on every press. The desktop
+phone-frame preview reads the same declaration, so it behaves the way the phone
+will.
+
+With it declared, whatever you compose becomes an agent turn verbatim, with
+every tool available. Build the prompt from your own records, and don't paste
+text you fetched from somewhere else into it.
 
 ### Translations — `t`
 

package/assets/helps/custom-view.md

@@ -442,8 +442,8 @@ to reword.
 - Whatever you compose becomes an agent turn verbatim, with every tool
   available. Build the prompt from your own records, and don't paste text you
   fetched from somewhere else into it.
-- **On the phone (`target: "mobile"`) the prompt is always sent**, declared or
-  not: there is no Enter key to press, so a draft would simply strand the work.
+- **The phone (`target: "mobile"`) follows the same declaration** — undeclared
+  drafts, declared sends. See `config/helps/custom-view-remote.md`.
 
 Use this — not a hidden flag the user has to reconcile later — whenever a button
 should _start backend work_: the user stays in the loop through trusted first-

package/assets/helps/error-recovery.md

@@ -152,6 +152,45 @@ checked**. Open the body with a line saying the answer came from this lookup and
 is awaiting maintainer review — it is a draft, not documentation. Never edit
 `bug-report-faq.md` yourself.
 
+## "Failed to authenticate" — the Claude CLI's own login expired
+
+### Symptoms
+
+- `[Error] Failed to authenticate: OAuth session expired and could not be refreshed`
+- `[Error] Failed to authenticate. API Error: 401 …` / `Invalid API key`
+- Older versions: that text shown as a normal reply, then a separate `[Error] claude exited with code 1`
+- Every turn fails the same way until the user acts — failures come in bursts, not at random
+
+### Cause
+
+The `claude` CLI that MulmoClaude spawns could not authenticate with Anthropic, so it
+exited before running anything. This is the CLI's own login (`claude login`, stored in
+`~/.claude` / the macOS Keychain), not a MulmoClaude or Google account link. An OAuth
+(subscription) session goes stale when its silent refresh fails; nothing on the
+MulmoClaude side can refresh it.
+
+### Fix
+
+The user runs `claude /login` (or `claude login`) in a terminal **on the host**, then
+resends the message. If they authenticate with `ANTHROPIC_API_KEY` instead, check that
+key. Switching auth mode is not the fix — a fresh `/login` is.
+
+If `/login` succeeds and the error persists (typically `401 OAuth access token is
+invalid`), what to check depends on the sandbox:
+
+- **Sandbox off** — the spawned CLI inherits the server's environment, so a
+  `CLAUDE_CODE_OAUTH_TOKEN` set where MulmoClaude was started (shell profile or `.env`)
+  overrides the stored login. The user unsets or replaces it and **restarts
+  MulmoClaude**; a new terminal does not change the running server.
+- **Sandbox on** — the container gets only the variables MulmoClaude passes explicitly,
+  and that token is not one of them; it authenticates from the host's mounted
+  `~/.claude`. Do not chase the environment variable here — the host login is the one
+  that counts.
+
+You will usually be reading this AFTER the user re-logged in (a failing turn never
+reaches you); answer "why did that happen" with the cause above rather than
+investigating MulmoClaude's settings.
+
 ## gh / git / SSH errors inside the sandbox
 
 ### Symptoms

package/dist/google/collectionPush.d.ts

@@ -39,6 +39,13 @@ export interface CalendarCollectionPushResult {
     deletedInGoogle: number;
     /** Records that cannot be pushed as they stand, each with the reason. */
     skipped: string[];
+    /** Deletions the sweep left standing in Google, each with the reason.
+     *
+     *  NOT merged into `skipped`: that list means "this push did not do what you
+     *  asked", and a refused deletion is "it was deliberately not deleted" while
+     *  the rest of the run carried. Merging them made one refusal hide every
+     *  successful create and update from the caller (#3272). */
+    keptInGoogle: string[];
     errors: string[];
     /** Records whose local edit did NOT reach Google and would be destroyed by
      *  the pull that follows an automatic push (#2620).
@@ -108,9 +115,28 @@ type PushOutcome = {
     message: string;
 };
 export type PushOutcomeKind = PushOutcome["kind"];
+/** One record's push, kept with the id so the pull can be told which records to
+ *  leave alone. */
+export interface PushAttempt {
+    eventId: string;
+    outcome: PushOutcome;
+}
 /** Whether this outcome leaves a local edit that only exists locally, so the
  *  pull must not overwrite the record and the baseline must not advance. */
 export declare const isUnpushed: (kind: PushOutcomeKind) => boolean;
+/** The whole report one run produces, from what each record's push did and what
+ *  the delete sweep did.
+ *
+ *  A sweep's refusal goes to `keptInGoogle`, NEVER to `skipped`: that list means
+ *  "this push did not do what you asked", and a refusal means "the event was
+ *  deliberately left standing" while the rest of the run carried. Merged, one
+ *  refusal took the caller's problem branch and hid every create and update
+ *  (#3272).
+ *
+ *  Exported because it is pure — a list of attempts and a sweep, no workspace,
+ *  grant or clock — so the separation above is something a test drives rather
+ *  than argues. */
+export declare function pushResultFrom(slug: string, attempts: readonly PushAttempt[], deletes: DeleteSweep): CalendarCollectionPushResult;
 /** Record ids whose local value no longer matches the baseline — edits that have
  *  not reached Google.
  *
@@ -133,6 +159,9 @@ export declare function unsentLocalEdits(collection: LoadedCollection, workspace
 export interface DeleteSweep {
     seen: number;
     deleted: string[];
+    /** Deletions left standing in Google, each with the reason. Reported apart
+     *  from the push's own `skipped` on the result: that list means "could not be
+     *  sent", and a refusal means "deliberately left alone" (#3272). */
     skipped: string[];
     errors: string[];
 }

package/dist/google/index.cjs

@@ -2034,9 +2034,22 @@ var UNPUSHED_KINDS = ["conflict", "error"];
 /** Whether this outcome leaves a local edit that only exists locally, so the
 *  pull must not overwrite the record and the baseline must not advance. */
 var isUnpushed = (kind) => UNPUSHED_KINDS.includes(kind);
-function tally(slug, attempts, deletes) {
+/** The whole report one run produces, from what each record's push did and what
+*  the delete sweep did.
+*
+*  A sweep's refusal goes to `keptInGoogle`, NEVER to `skipped`: that list means
+*  "this push did not do what you asked", and a refusal means "the event was
+*  deliberately left standing" while the rest of the run carried. Merged, one
+*  refusal took the caller's problem branch and hid every create and update
+*  (#3272).
+*
+*  Exported because it is pure — a list of attempts and a sweep, no workspace,
+*  grant or clock — so the separation above is something a test drives rather
+*  than argues. */
+function pushResultFrom(slug, attempts, deletes) {
 	const outcomes = attempts.map((attempt) => attempt.outcome);
 	const count = (kind) => outcomes.filter((outcome) => outcome.kind === kind).length;
+	const messagesOf = (kind) => outcomes.flatMap((outcome) => outcome.kind === kind ? [outcome.message] : []);
 	return {
 		slug,
 		created: count("created"),
@@ -2044,8 +2057,9 @@ function tally(slug, attempts, deletes) {
 		conflicts: count("conflict"),
 		localDeletes: deletes.seen,
 		deletedInGoogle: deletes.deleted.length,
-		skipped: [...outcomes.flatMap((outcome) => outcome.kind === "skipped" ? [outcome.message] : []), ...deletes.skipped],
-		errors: [...outcomes.flatMap((outcome) => outcome.kind === "error" ? [outcome.message] : []), ...deletes.errors],
+		skipped: messagesOf("skipped"),
+		keptInGoogle: [...deletes.skipped],
+		errors: [...messagesOf("error"), ...deletes.errors],
 		unpushedIds: attempts.filter((attempt) => isUnpushed(attempt.outcome.kind)).map((attempt) => attempt.eventId)
 	};
 }
@@ -2175,7 +2189,7 @@ async function pushCollectionNow(collection, workspaceRoot, deps = liveDeps) {
 		});
 		await saveCalendarShadow(calendarId, pushedShadow([outcome]), workspaceRoot);
 	}
-	const result = tally(slug, attempts, await sweepDeletes(locallyDeletedIds(shadow, records.map((record) => fieldText(record[schema.primaryKey]))), schema.googleCalendar?.propagateDeletes === true, {
+	const result = pushResultFrom(slug, attempts, await sweepDeletes(locallyDeletedIds(shadow, records.map((record) => fieldText(record[schema.primaryKey]))), schema.googleCalendar?.propagateDeletes === true, {
 		fetchEvent: (eventId) => (deps.fetchEvent ?? getCalendarEvent)(accessToken, {
 			calendarId,
 			eventId
@@ -2315,7 +2329,7 @@ function pullableEvents(events, unpushed) {
 *  A conflict or an error means that record now diverges from Google until
 *  someone resolves it, which must not be silent. */
 function reportAutoPush(slug, result) {
-	const { created, updated, conflicts, skipped, errors, unpushedIds } = result;
+	const { created, updated, conflicts, skipped, keptInGoogle, errors, unpushedIds } = result;
 	if (created + updated > 0) log.info("google", "auto-pushed local calendar edits", {
 		slug,
 		created,
@@ -2330,6 +2344,10 @@ function reportAutoPush(slug, result) {
 		slug,
 		skipped
 	});
+	if (keptInGoogle.length > 0) log.warn("google", "deletions the auto push left standing in Google", {
+		slug,
+		keptInGoogle
+	});
 	if (errors.length > 0) log.warn("google", "auto push errors", {
 		slug,
 		errors
@@ -3264,6 +3282,7 @@ exports.pullableEvents = pullableEvents;
 exports.pushAndProtect = pushAndProtect;
 exports.pushCalendarForCollection = pushCalendarForCollection;
 exports.pushCollectionNow = pushCollectionNow;
+exports.pushResultFrom = pushResultFrom;
 exports.pushableMap = pushableMap;
 exports.readDriveFile = readDriveFile;
 exports.releaseOrphanedCalendarToken = releaseOrphanedCalendarToken;