@mulmoclaude/core 5.4.0 → 5.5.0

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/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;