@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/host-cli/status.js

@@ -6,6 +6,7 @@ import { z } from "zod";
 import { parseAntigravityModels } from "../adapters/llm/antigravity-models.js";
 import { cliLoginError } from "../adapters/llm/cli-login-error.js";
 import { cliCommand } from "../kernel/cli-command.js";
+import { errorText, hasErrnoCode } from "../kernel/errors.js";
 import { cliProbeTimeoutMs, readinessFromProbe, } from "../slices/settings/cli-status.js";
 export function hostCommandName(id) {
     if (id === "claude-code")
@@ -25,7 +26,9 @@ export async function resolveHostCommand(id, env) {
                 return path;
         }
         catch (error) {
-            if (!isCode(error, "ENOENT") && !isCode(error, "ENOTDIR") && !isCode(error, "EACCES"))
+            if (!hasErrnoCode(error, "ENOENT") &&
+                !hasErrnoCode(error, "ENOTDIR") &&
+                !hasErrnoCode(error, "EACCES"))
                 throw error;
         }
     }
@@ -89,10 +92,10 @@ export function createHostStatus(deps) {
                 command: hostCommandName(id),
                 installed: false,
                 login: "unknown",
-                issueKind: isCode(error, "ENOENT") ? "missing" : "bridge",
-                issue: isCode(error, "ENOENT")
+                issueKind: hasErrnoCode(error, "ENOENT") ? "missing" : "bridge",
+                issue: hasErrnoCode(error, "ENOENT")
                     ? `${hostCommandName(id)} was not found on this machine. Install it and sign in there, then run the launcher again: npx @gentbajko/slopify --docker`
-                    : `Slopify could not check for ${hostCommandName(id)} on this machine (${error instanceof Error ? error.message : String(error)}). Fix the problem, then run the launcher again: npx @gentbajko/slopify --docker`,
+                    : `Slopify could not check for ${hostCommandName(id)} on this machine (${errorText(error)}). Fix the problem, then run the launcher again: npx @gentbajko/slopify --docker`,
             };
         }
         const readiness = readinessFromProbe(await deps.probe(command, ["--version"], cliProbeTimeoutMs), {
@@ -149,6 +152,3 @@ export function createHostStatus(deps) {
         return { ...(await entry.value), id };
     };
 }
-function isCode(error, code) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}

package/dist/kernel/db/migrations/0063-model-checks.sql

@@ -0,0 +1,20 @@
+-- What Settings → Models and the pickers know about each model for the person's own key or
+-- CLI login (`slices/model-checks`): whether the key's live list names it, and the last check
+-- or real run's verdict. Only pickers read it; no run does. `account` is the key generation or
+-- the CLI's id, so a new key starts every row over.
+CREATE TABLE model_checks (
+ provider TEXT NOT NULL,
+ family TEXT NOT NULL CHECK (family IN ('llm','tts','image')),
+ model TEXT NOT NULL,
+ account TEXT NOT NULL,
+ listed INTEGER CHECK (listed IN (0,1)),
+ listed_at TEXT,
+ verdict TEXT CHECK (verdict IN ('works','no-access','failed')),
+ verdict_source TEXT CHECK (verdict_source IN ('check','run')),
+ sentence TEXT,
+ checked_at TEXT,
+ cost REAL NOT NULL DEFAULT 0,
+ first_works_at TEXT,
+ notice_seen INTEGER NOT NULL DEFAULT 0 CHECK (notice_seen IN (0,1)),
+ PRIMARY KEY(provider, family, model)
+);

package/dist/kernel/db/migrations/0064-template-studio.sql

@@ -0,0 +1,46 @@
+-- Template studio (4.0, `slices/template-studio`). A version is runnable by schedules when its
+-- gate is ready, carried (a system writer copied a runnable gate) or legacy (saved before the
+-- studio). A version with no row was never checked.
+CREATE TABLE template_gates (
+ template_id TEXT NOT NULL,
+ version INTEGER NOT NULL CHECK(version >= 1),
+ state TEXT NOT NULL CHECK(state IN ('legacy','ready','carried')),
+ carried_from INTEGER CHECK(carried_from IS NULL OR carried_from >= 1),
+ checks_json TEXT CHECK(checks_json IS NULL OR json_valid(checks_json)),
+ marked_at TEXT,
+ PRIMARY KEY(template_id, version),
+ FOREIGN KEY(template_id, version) REFERENCES project_template_revisions(template_id, version) ON DELETE CASCADE
+);
+INSERT INTO template_gates (template_id, version, state)
+ SELECT template_id, version, 'legacy' FROM project_template_revisions;
+-- The hidden project each template's samples are made on. It never appears in a list the user
+-- sees (`notTemplateSample`), and its project may be gone: the next sample makes it again.
+CREATE TABLE template_samples (
+ template_id TEXT PRIMARY KEY REFERENCES project_templates(id) ON DELETE CASCADE,
+ project_id TEXT NOT NULL UNIQUE,
+ topic TEXT NOT NULL CHECK(length(trim(topic)) BETWEEN 1 AND 300),
+ topic_source TEXT NOT NULL CHECK(topic_source IN ('fixed','queued')),
+ full_script INTEGER NOT NULL DEFAULT 0 CHECK(full_script IN (0,1)),
+ created_at TEXT NOT NULL
+);
+CREATE TABLE template_sample_versions (
+ template_id TEXT NOT NULL REFERENCES project_templates(id) ON DELETE CASCADE,
+ template_version INTEGER NOT NULL CHECK(template_version >= 1),
+ revision_id TEXT,
+ state TEXT NOT NULL CHECK(state IN ('queued','making','done','failed','skipped','held')),
+ quoted_high REAL,
+ held_reason TEXT,
+ updated_at TEXT NOT NULL,
+ PRIMARY KEY(template_id, template_version)
+);
+-- At most one queued and one running sample job per template: a newer Save replaces the queued
+-- one and waits behind the running one, which is never stopped.
+CREATE TABLE template_sample_jobs (
+ template_id TEXT NOT NULL REFERENCES project_templates(id) ON DELETE CASCADE,
+ template_version INTEGER NOT NULL CHECK(template_version >= 1),
+ ack_high REAL NOT NULL DEFAULT 0 CHECK(ack_high >= 0),
+ kind TEXT NOT NULL CHECK(kind IN ('save','topic','full-script','bakeoff','free')),
+ requested_at TEXT NOT NULL,
+ state TEXT NOT NULL CHECK(state IN ('queued','running')),
+ PRIMARY KEY(template_id, state)
+);

package/dist/kernel/db/migrations/0065-promise-and-assistant-reviews.sql

@@ -0,0 +1,58 @@
+-- The promise check is a review stage of its own (`reviews/model.ts`), and the in-app assistant
+-- acts on and answers reviews as itself rather than as an agent. SQLite cannot change a CHECK in
+-- place, so both tables are copied, as 0055 and 0059 did.
+CREATE TABLE review_verdicts_promise_upgrade (
+ id TEXT PRIMARY KEY,
+ project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+ revision_id TEXT NOT NULL,
+ item_key TEXT NOT NULL,
+ stage TEXT NOT NULL CHECK(stage IN ('article','images','narration','thumbnail','shorts','promise')),
+ item_fingerprint TEXT NOT NULL,
+ review_fingerprint TEXT NOT NULL,
+ passed INTEGER NOT NULL CHECK(passed IN (0,1)),
+ reasons TEXT NOT NULL,
+ outcome TEXT NOT NULL CHECK(outcome IN ('passed','flagged','redo','auto-passed')),
+ attempt INTEGER NOT NULL CHECK(attempt >= 1),
+ action TEXT CHECK(action IN ('overruled','redone')),
+ action_at TEXT,
+ action_by TEXT CHECK(action_by IN ('person','agent','assistant')),
+ redo_state TEXT CHECK(redo_state IN ('pending','started','failed')),
+ redo_error TEXT,
+ answered_by TEXT NOT NULL DEFAULT 'model' CHECK(answered_by IN ('model','agent','person','nobody')),
+ created_at TEXT NOT NULL,
+ UNIQUE(project_id,review_fingerprint)
+);
+INSERT INTO review_verdicts_promise_upgrade (id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,action_by,redo_state,redo_error,answered_by,created_at)
+  SELECT id,project_id,revision_id,item_key,stage,item_fingerprint,review_fingerprint,passed,reasons,outcome,attempt,action,action_at,action_by,redo_state,redo_error,answered_by,created_at
+  FROM review_verdicts ORDER BY rowid;
+DROP TABLE review_verdicts;
+ALTER TABLE review_verdicts_promise_upgrade RENAME TO review_verdicts;
+CREATE INDEX review_verdicts_item ON review_verdicts(project_id,item_key);
+CREATE INDEX review_verdicts_redo ON review_verdicts(redo_state);
+
+CREATE TABLE external_reviews_promise_upgrade (
+ id TEXT PRIMARY KEY,
+ project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+ revision_id TEXT NOT NULL,
+ work_id TEXT NOT NULL,
+ piece_id TEXT NOT NULL,
+ work_key TEXT NOT NULL,
+ item_key TEXT NOT NULL,
+ stage TEXT NOT NULL CHECK(stage IN ('article','images','narration','thumbnail','shorts','promise')),
+ item_fingerprint TEXT NOT NULL,
+ review_fingerprint TEXT NOT NULL,
+ material TEXT NOT NULL CHECK(json_valid(material)),
+ state TEXT NOT NULL CHECK(state IN ('waiting','answered','auto-passed','superseded','canceled')),
+ waiting_since TEXT NOT NULL,
+ deadline_at TEXT NOT NULL,
+ verdict TEXT CHECK(verdict IS NULL OR json_valid(verdict)),
+ answered_by TEXT CHECK(answered_by IN ('person','agent','assistant')),
+ answered_at TEXT,
+ UNIQUE(project_id,review_fingerprint)
+);
+INSERT INTO external_reviews_promise_upgrade (id,project_id,revision_id,work_id,piece_id,work_key,item_key,stage,item_fingerprint,review_fingerprint,material,state,waiting_since,deadline_at,verdict,answered_by,answered_at)
+  SELECT id,project_id,revision_id,work_id,piece_id,work_key,item_key,stage,item_fingerprint,review_fingerprint,material,state,waiting_since,deadline_at,verdict,answered_by,answered_at
+  FROM external_reviews ORDER BY rowid;
+DROP TABLE external_reviews;
+ALTER TABLE external_reviews_promise_upgrade RENAME TO external_reviews;
+CREATE INDEX external_reviews_waiting ON external_reviews(state, deadline_at);

package/dist/kernel/db/migrations/0066-assistant.sql

@@ -0,0 +1,44 @@
+-- The in-app assistant acts through the same API as an agent but is told apart: its changes
+-- show "by assistant", and it can start a project's work. Its chat is kept per session, each
+-- turn replayed to a fresh CLI, and what it asked the person first ("Ask first") is kept with
+-- the person's answer, which a later call may use once. SQLite cannot change a CHECK in place,
+-- so project_starts is copied, as 0055 did.
+ALTER TABLE agent_actions ADD COLUMN actor TEXT NOT NULL DEFAULT 'agent' CHECK(actor IN ('agent','assistant'));
+
+CREATE TABLE project_starts_assistant_upgrade (
+ project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+ actor TEXT NOT NULL CHECK(actor IN ('person','agent','assistant')),
+ started_at TEXT NOT NULL
+);
+INSERT INTO project_starts_assistant_upgrade (project_id,actor,started_at)
+  SELECT project_id,actor,started_at FROM project_starts ORDER BY rowid;
+DROP TABLE project_starts;
+ALTER TABLE project_starts_assistant_upgrade RENAME TO project_starts;
+
+CREATE TABLE assistant_sessions (
+ id TEXT PRIMARY KEY,
+ cli TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL
+);
+CREATE TABLE assistant_messages (
+ id TEXT PRIMARY KEY,
+ session_id TEXT NOT NULL REFERENCES assistant_sessions(id) ON DELETE CASCADE,
+ turn_id TEXT NOT NULL,
+ role TEXT NOT NULL CHECK(role IN ('person','assistant','tool','ask','error')),
+ text TEXT NOT NULL,
+ meta TEXT NOT NULL DEFAULT '{}' CHECK(json_valid(meta)),
+ created_at TEXT NOT NULL
+);
+CREATE INDEX assistant_messages_session ON assistant_messages(session_id, created_at);
+CREATE TABLE assistant_asks (
+ id TEXT PRIMARY KEY,
+ session_id TEXT NOT NULL REFERENCES assistant_sessions(id) ON DELETE CASCADE,
+ tool TEXT NOT NULL,
+ args_hash TEXT NOT NULL,
+ text TEXT NOT NULL,
+ state TEXT NOT NULL CHECK(state IN ('asked','allowed','denied','used','expired')),
+ created_at TEXT NOT NULL,
+ decided_at TEXT
+);
+CREATE INDEX assistant_asks_session ON assistant_asks(session_id, state);

package/dist/kernel/db/migrations/0067-autopilot.sql

@@ -0,0 +1,6 @@
+-- Autopilot warnings the person hid on Home (`slices/autopilot/repo.ts`), each until its week is
+-- up; a warning that changes has a new key and shows again.
+CREATE TABLE autopilot_snoozes (
+ warning_key TEXT PRIMARY KEY,
+ until TEXT NOT NULL
+);

package/dist/kernel/db/migrations/0068-topic-scores.sql

@@ -0,0 +1,17 @@
+-- Topic scoring (`slices/schedules/score.ts`): off for every schedule saved before it, which
+-- then finds and orders topics exactly as it did. A topic's score is kept beside the queue, by
+-- its normalised title, so the queue's own rows keep their strict shape; `pinned` is a topic the
+-- person moved, which scoring then leaves where it was put.
+ALTER TABLE schedules ADD COLUMN topic_scoring TEXT NOT NULL DEFAULT 'off' CHECK(topic_scoring IN ('off','library','search'));
+CREATE TABLE topic_scores (
+ schedule_id TEXT NOT NULL REFERENCES schedules(id) ON DELETE CASCADE,
+ topic_key TEXT NOT NULL,
+ title TEXT NOT NULL,
+ score INTEGER NOT NULL CHECK(score BETWEEN 0 AND 100),
+ interest REAL,
+ novelty REAL NOT NULL,
+ reasons TEXT NOT NULL CHECK(json_valid(reasons)),
+ pinned INTEGER NOT NULL DEFAULT 0 CHECK(pinned IN (0,1)),
+ scored_at TEXT NOT NULL,
+ PRIMARY KEY(schedule_id, topic_key)
+);

package/dist/kernel/db/migrations/0070-designs.sql

@@ -0,0 +1,53 @@
+-- Designs (4.0): an uploaded or generated picture edited step by step, and a designed piece
+-- (poster, flyer, brochure, social image) whose text Slopify lays out on the AI's artwork.
+-- A design is its own record, not a project; `project_id` only links it to one ("Keep in
+-- project") and is cleared when that project is deleted. `channel_id` is the channel its paid
+-- calls count under on Home. `sample_of` marks the hidden sample a design template's editor
+-- redraws; every list leaves those out. Each step is one version of the picture, kept in
+-- image_blobs (backed up), chained by `parent_id`; `head_step_id` is the version the design
+-- shows and continues from.
+CREATE TABLE designs (
+ id TEXT PRIMARY KEY,
+ kind TEXT NOT NULL CHECK(kind IN ('edit','design')),
+ name TEXT NOT NULL CHECK(length(trim(name)) BETWEEN 1 AND 200),
+ channel_id TEXT NOT NULL,
+ project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+ template_id TEXT,
+ template_version INTEGER CHECK(template_version IS NULL OR template_version >= 1),
+ schedule_id TEXT,
+ schedule_run_id TEXT,
+ document_json TEXT CHECK(document_json IS NULL OR json_valid(document_json)),
+ values_json TEXT NOT NULL DEFAULT '{}' CHECK(json_valid(values_json)),
+ head_step_id TEXT,
+ sample_of TEXT,
+ mutation_id TEXT UNIQUE,
+ mutation_hash TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ deleted_at TEXT
+);
+CREATE INDEX designs_project ON designs(project_id) WHERE project_id IS NOT NULL;
+CREATE INDEX designs_schedule ON designs(schedule_id) WHERE schedule_id IS NOT NULL;
+CREATE INDEX designs_sample_of ON designs(sample_of) WHERE sample_of IS NOT NULL;
+CREATE TABLE design_steps (
+ id TEXT PRIMARY KEY,
+ design_id TEXT NOT NULL REFERENCES designs(id) ON DELETE CASCADE,
+ n INTEGER NOT NULL CHECK(n >= 1),
+ parent_id TEXT REFERENCES design_steps(id) ON DELETE CASCADE,
+ kind TEXT NOT NULL CHECK(kind IN ('upload','edit','generate')),
+ instruction TEXT CHECK(instruction IS NULL OR length(instruction) <= 4000),
+ provider TEXT,
+ model TEXT,
+ inputs_json TEXT NOT NULL DEFAULT '{}' CHECK(json_valid(inputs_json)),
+ state TEXT NOT NULL CHECK(state IN ('making','ready','failed')),
+ error TEXT,
+ sha256 TEXT REFERENCES image_blobs(sha256),
+ width INTEGER CHECK(width IS NULL OR width > 0),
+ height INTEGER CHECK(height IS NULL OR height > 0),
+ mutation_id TEXT UNIQUE,
+ mutation_hash TEXT,
+ created_at TEXT NOT NULL,
+ settled_at TEXT,
+ UNIQUE(design_id, n),
+ CHECK(state <> 'ready' OR sha256 IS NOT NULL)
+);

package/dist/kernel/db/migrations/0071-design-usage.sql

@@ -0,0 +1,33 @@
+-- A design's picture edits and artwork are paid calls made outside a project, metered like a
+-- schedule's or a channel's (0040). Every row is copied as it was; only the owner kinds widen.
+CREATE TABLE standalone_usage_next (
+ id TEXT PRIMARY KEY,
+ owner_kind TEXT NOT NULL CHECK(owner_kind IN ('schedule','channel','design')),
+ owner_id TEXT NOT NULL,
+ channel_id TEXT NOT NULL,
+ purpose TEXT NOT NULL,
+ kind TEXT NOT NULL CHECK(kind IN ('llm','tts','image','video')),
+ provider TEXT NOT NULL,
+ model TEXT NOT NULL,
+ tokens_in INTEGER,
+ tokens_out INTEGER,
+ tokens_cached INTEGER,
+ characters INTEGER,
+ images INTEGER,
+ seconds REAL,
+ size TEXT,
+ quality TEXT,
+ wall_ms INTEGER NOT NULL,
+ on_plan INTEGER NOT NULL DEFAULT 0 CHECK(on_plan IN (0,1)),
+ cost REAL,
+ api_model TEXT,
+ api_cost REAL,
+ price_json TEXT CHECK(price_json IS NULL OR json_valid(price_json)),
+ account TEXT,
+ reading_json TEXT CHECK(reading_json IS NULL OR json_valid(reading_json)),
+ created_at TEXT NOT NULL
+);
+INSERT INTO standalone_usage_next SELECT id, owner_kind, owner_id, channel_id, purpose, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, size, quality, wall_ms, on_plan, cost, api_model, api_cost, price_json, account, reading_json, created_at FROM standalone_usage ORDER BY rowid;
+DROP TABLE standalone_usage;
+ALTER TABLE standalone_usage_next RENAME TO standalone_usage;
+CREATE INDEX standalone_usage_created ON standalone_usage(created_at);

package/dist/kernel/db/migrations/0072-design-templates.sql

@@ -0,0 +1,33 @@
+-- Design templates: a designed piece saved with fields ({{Event}}, {{Date}}…) to make again by
+-- hand or from a schedule. Every Save is a new revision; schedules only make from a revision
+-- marked ready. `design_template_samples` is the one sample job per template its editor
+-- redraws after a Save (the sample itself is a hidden design, `designs.sample_of`).
+CREATE TABLE design_templates (
+ id TEXT PRIMARY KEY,
+ channel_id TEXT,
+ head_version INTEGER NOT NULL CHECK(head_version >= 1),
+ created_at TEXT NOT NULL,
+ deleted_at TEXT,
+ mutation_id TEXT UNIQUE,
+ mutation_hash TEXT
+);
+CREATE TABLE design_template_revisions (
+ template_id TEXT NOT NULL REFERENCES design_templates(id) ON DELETE CASCADE,
+ version INTEGER NOT NULL CHECK(version >= 1),
+ name TEXT NOT NULL CHECK(length(trim(name)) BETWEEN 1 AND 200),
+ document_json TEXT NOT NULL CHECK(json_valid(document_json)),
+ gate TEXT NOT NULL DEFAULT 'unchecked' CHECK(gate IN ('unchecked','ready')),
+ checks_json TEXT CHECK(checks_json IS NULL OR json_valid(checks_json)),
+ marked_at TEXT,
+ created_at TEXT NOT NULL,
+ PRIMARY KEY(template_id, version)
+);
+CREATE TABLE design_template_samples (
+ template_id TEXT PRIMARY KEY REFERENCES design_templates(id) ON DELETE CASCADE,
+ design_id TEXT UNIQUE,
+ version INTEGER NOT NULL CHECK(version >= 1),
+ state TEXT NOT NULL CHECK(state IN ('queued','making','done','failed','held')),
+ held_reason TEXT,
+ quoted_high REAL,
+ updated_at TEXT NOT NULL
+);

package/dist/kernel/db/migrations/0073-schedule-design-kind.sql

@@ -0,0 +1,5 @@
+-- A schedule makes either projects from a project template (every schedule so far) or
+-- designed pieces from a design template, one per row of its table ahead of that row's date.
+-- `design_ids_json` lists the designs a run made, as `project_ids_json` lists projects.
+ALTER TABLE schedules ADD COLUMN template_kind TEXT NOT NULL DEFAULT 'project' CHECK(template_kind IN ('project','design'));
+ALTER TABLE schedule_runs ADD COLUMN design_ids_json TEXT NOT NULL DEFAULT '[]' CHECK(json_valid(design_ids_json));

package/dist/kernel/db/migrations/0074-template-bakeoffs.sql

@@ -0,0 +1,44 @@
+-- Template studio's model bake-off (4.0, `slices/template-studio/bakeoff.ts`): one section's
+-- sample made again on two or three models, each on a hidden copy of the template's sample
+-- project, compared by cost and speed, then discarded. One bake-off per template at a time.
+CREATE TABLE template_bakeoffs (
+ id TEXT PRIMARY KEY,
+ template_id TEXT NOT NULL UNIQUE REFERENCES project_templates(id) ON DELETE CASCADE,
+ template_version INTEGER NOT NULL CHECK(template_version >= 1),
+ section TEXT NOT NULL CHECK(section IN ('script','voice','pictures')),
+ ack_high REAL NOT NULL CHECK(ack_high >= 0),
+ ack_unknown INTEGER NOT NULL DEFAULT 0 CHECK(ack_unknown IN (0,1)),
+ state TEXT NOT NULL CHECK(state IN ('queued','making','done','held','failed')),
+ sentence TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL
+);
+-- Each model's copy. Its project is hidden like the sample's (`template_hidden_projects`) and
+-- removed with the bake-off.
+CREATE TABLE template_bakeoff_clones (
+ bakeoff_id TEXT NOT NULL REFERENCES template_bakeoffs(id) ON DELETE CASCADE,
+ slot INTEGER NOT NULL CHECK(slot BETWEEN 0 AND 2),
+ provider TEXT NOT NULL CHECK(length(provider) BETWEEN 1 AND 100),
+ model TEXT NOT NULL CHECK(length(model) BETWEEN 1 AND 200),
+ project_id TEXT UNIQUE,
+ state TEXT NOT NULL CHECK(state IN ('queued','making','done','failed')),
+ quoted_high REAL,
+ failure TEXT,
+ started_at TEXT,
+ finished_at TEXT,
+ PRIMARY KEY(bakeoff_id, slot)
+);
+-- Every project the studio keeps out of the lists the person sees: each template's sample and
+-- each bake-off copy (`notTemplateSample`).
+CREATE VIEW template_hidden_projects AS
+ SELECT project_id FROM template_samples
+ UNION ALL
+ SELECT project_id FROM template_bakeoff_clones WHERE project_id IS NOT NULL;
+-- What a hidden project spent, kept when the project is removed (a bake-off discarded, a sample
+-- made again on a new topic), so today's sample budget still counts it.
+CREATE TABLE template_studio_spend (
+ project_id TEXT NOT NULL,
+ cost REAL NOT NULL CHECK(cost >= 0),
+ created_at TEXT NOT NULL
+);
+CREATE INDEX template_studio_spend_at ON template_studio_spend(created_at);

package/dist/kernel/db/migrations/0075-social-posts.sql

@@ -0,0 +1,25 @@
+-- Posting to other sites (`slices/social`). One row per project, site and item (0 is the
+-- project's one post per site): the project's own pick (`choice_json`, NULL is the template's),
+-- the person's hand edit of the text and the generated text it was made from, Reddit's own
+-- fields, and where the post stands after the extension filled it or the person posted it.
+-- A project with no row posts as its settings say; nothing here is generated.
+CREATE TABLE social_posts (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  platform TEXT NOT NULL CHECK (platform IN ('x','linkedin','instagram','tiktok','reddit','bluesky')),
+  item INTEGER NOT NULL DEFAULT 0 CHECK (item >= 0),
+  choice_json TEXT CHECK (choice_json IS NULL OR json_valid(choice_json)),
+  text_edit TEXT,
+  text_base TEXT,
+  reddit_json TEXT CHECK (reddit_json IS NULL OR json_valid(reddit_json)),
+  state TEXT NOT NULL DEFAULT 'none' CHECK (state IN ('none','waiting','filling','filled','scheduled','posted','failed')),
+  waiting_at TEXT,
+  filled_at TEXT,
+  scheduled_at TEXT,
+  posted_at TEXT,
+  url TEXT,
+  message TEXT,
+  by TEXT CHECK (by IN ('extension','person')),
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, platform, item)
+);
+CREATE INDEX social_posts_waiting ON social_posts(platform, waiting_at) WHERE state = 'waiting';

package/dist/kernel/db/migrations/0076-channel-social.sql

@@ -0,0 +1,5 @@
+-- A channel's accounts on other sites (`slices/social`): the X subscription, which only changes
+-- a post's warnings, and the account names the extension reads a published post's link from.
+-- Never a login.
+ALTER TABLE channels ADD COLUMN x_tier TEXT NOT NULL DEFAULT 'free' CHECK (x_tier IN ('free','premium','premium_plus'));
+ALTER TABLE channels ADD COLUMN social_accounts TEXT NOT NULL DEFAULT '{}' CHECK (json_valid(social_accounts));

package/dist/kernel/db/migrations/0077-post-prompts.sql

@@ -0,0 +1,17 @@
+-- Library prompts of the new "post" kind: what writes a project's post for another site
+-- (`slices/social`). SQLite cannot change a CHECK in place, so the table is copied into one
+-- whose CHECK lists the new kind, like 0034 did for "script".
+CREATE TABLE prompts_post_upgrade (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL CHECK (kind IN ('article','image','thumbnail','narration','description','shorts','review','script','post')),
+  name TEXT NOT NULL,
+  body TEXT NOT NULL,
+  slots TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  deleted_at TEXT
+);
+INSERT INTO prompts_post_upgrade (id,kind,name,body,slots,updated_at,deleted_at)
+  SELECT id,kind,name,body,slots,updated_at,deleted_at FROM prompts;
+DROP TABLE prompts;
+ALTER TABLE prompts_post_upgrade RENAME TO prompts;
+CREATE UNIQUE INDEX prompts_name ON prompts(kind,lower(name)) WHERE deleted_at IS NULL;

package/dist/kernel/db/tx.js

@@ -1,3 +1,4 @@
+import { errorText } from "../errors.js";
 // SQLite starts a transaction for a SAVEPOINT issued outside one and nests it inside one
 // already open, so a slice can wrap its own writes without knowing whether its caller did
 // too. The name is a constant, not a parameter: SQLite matches RELEASE and ROLLBACK TO
@@ -34,7 +35,7 @@ function unwind(db, error) {
         db.exec(`RELEASE ${savepoint}`);
     }
     catch (cleanup) {
-        throw new Error(`the transaction could not be unwound: ${messageOf(cleanup)}`, {
+        throw new Error(`the transaction could not be unwound: ${errorText(cleanup)}`, {
             cause: error,
         });
     }
@@ -45,6 +46,3 @@ function isThenable(value) {
         "then" in value &&
         typeof value.then === "function");
 }
-function messageOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/kernel/errors.js

@@ -1,8 +1,29 @@
+// The one sentence a failure carries: an Error's message, or whatever else was thrown as text.
+export function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// The Node file-system code (`ENOENT`, `EEXIST`) of a thrown value, if it carries one.
+export function errnoCode(error) {
+    return typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+export function hasErrnoCode(error, code) {
+    return errnoCode(error) === code;
+}
+// A path that is missing, not a directory, not readable or a link loop: nothing to read there.
+export function isUnreachablePath(error) {
+    const code = errnoCode(error);
+    return code !== undefined && ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(code);
+}
 // A failure's own sentence and every cause it wraps, for the log. The page shows only the
 // sentence; the chain is the only place a "download interrupted" says the server closed the
 // stream.
 export function causedBy(error) {
-    const chain = [error instanceof Error ? error.message : String(error)];
+    const chain = [errorText(error)];
     let cause = error instanceof Error ? error.cause : undefined;
     while (cause !== undefined && cause !== null && chain.length < 6) {
         chain.push(cause instanceof Error ? `${cause.name}: ${cause.message}` : String(cause));
@@ -10,3 +31,8 @@ export function causedBy(error) {
     }
     return chain.join(" <- ");
 }
+// The sentence for a check that can only fail through a bug. `what` says which check, in words a
+// person can report; `retry` names the button that is right on the screen the message appears on.
+export function internalError(what, retry = "Try again") {
+    return `Slopify hit an internal error (${what}). ${retry}; if it happens again, use Download diagnostics in Settings and report it.`;
+}

package/dist/kernel/json-answer.js

@@ -0,0 +1,15 @@
+// The JSON an AI model's answer carries, wherever the model put it: bare, in a ```json fence, or
+// after a sentence of its own. Everything from the first `open` to the last `close` is parsed;
+// undefined when there is none or it is not JSON.
+export function jsonBetween(text, open, close) {
+    const start = text.indexOf(open);
+    const end = text.lastIndexOf(close);
+    if (start === -1 || end <= start)
+        return undefined;
+    try {
+        return JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/kernel/lock.js

@@ -1,4 +1,5 @@
 import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { errnoCode } from "./errors.js";
 // Seconds since the epoch at which this process started, stable for its whole life.
 const startedAt = Math.round(Date.now() / 1000 - process.uptime());
 export function acquireInstanceLock(lockPath) {
@@ -32,7 +33,7 @@ function claim(lockPath, pid) {
         return true;
     }
     catch (error) {
-        if (errnoOf(error) === "EEXIST") {
+        if (errnoCode(error) === "EEXIST") {
             return false;
         }
         throw error;
@@ -65,7 +66,7 @@ function discard(lockPath) {
         unlinkSync(lockPath);
     }
     catch (error) {
-        if (errnoOf(error) !== "ENOENT") {
+        if (errnoCode(error) !== "ENOENT") {
             throw error;
         }
     }
@@ -77,12 +78,6 @@ function isAlive(pid) {
     }
     catch (error) {
         // EPERM means the process exists and belongs to someone else.
-        return errnoOf(error) === "EPERM";
+        return errnoCode(error) === "EPERM";
     }
 }
-function errnoOf(error) {
-    if (error instanceof Error && "code" in error && typeof error.code === "string") {
-        return error.code;
-    }
-    return undefined;
-}

package/dist/kernel/paths.js

@@ -18,6 +18,14 @@ export function layout(dataDir, files) {
 export function attachPlaces(paths, places) {
     Object.assign(paths, { places });
 }
+// Tells a running install's Paths which projects are studio samples.
+export function attachSamples(paths, samples) {
+    Object.assign(paths, { samples });
+}
+// Where the studio samples' project folders are: inside the data dir, beside the database.
+export function templateSamplesDir(paths) {
+    return join(paths.dataDir, "template-studio", "samples");
+}
 // Points a running install's Paths at moved files. The one object every slice was handed is
 // changed in place, so the next file each one reads or writes is in the new place.
 export function repoint(paths, files) {

package/dist/kernel/ports/assistant-cli.js

@@ -0,0 +1,4 @@
+// The in-app assistant's turn on a CLI on this computer (`adapters/llm/assistant-cli.ts`). The
+// slice hands in the turn's prompt and token and reads back what the chat shows; how the CLI
+// is started, isolated and read stays in the adapter.
+export const assistantCliIds = ["claude-code", "codex"];

package/dist/kernel/ports/host-cli.js

@@ -91,6 +91,9 @@ export const hostImageSchema = z
         .strict())
         .max(4)
         .optional(),
+    // A design's picture to change (`ImageRequest.edit`). A helper from before it refuses the
+    // whole request as invalid rather than drawing a new picture in its place.
+    edit: z.object({ source: bridgedImage }).strict().optional(),
 })
     .strict();
 export const hostOpenFolderSchema = z

package/dist/kernel/ports/interest.js

@@ -0,0 +1,4 @@
+// Public search interest in a topic: the search suggestions offered for it and how often its
+// Wikipedia article is read. Used only by schedules the person set to rank topics by search
+// interest; it sends the topic's title and nothing else. Never a channel's own analytics.
+export {};

package/dist/kernel/ports/languages.js

@@ -61,9 +61,6 @@ export function languageInfo(code) {
 export function projectLanguage(config) {
     return config.language ?? defaultLanguage;
 }
-export function isEnglish(config) {
-    return projectLanguage(config) === defaultLanguage;
-}
 // The line added to every prompt that writes for the audience, when the project is not in
 // English. It is the app's own sentence, added after the user's prompt rather than written
 // into it, so the prompt library stays as the user wrote it; an English project gets nothing,

package/dist/kernel/ports/model.js

@@ -22,12 +22,14 @@ export const providerErrorKinds = [
     "dropped",
     "other",
 ];
+export const modelAccesses = ["no-access", "not-found"];
 export function providerError(init) {
     return Object.assign(new Error(init.message), {
         fault: {
             kind: init.kind,
             ...(init.retryAfterMs === undefined ? {} : { retryAfterMs: init.retryAfterMs }),
             ...(init.planLimit === undefined ? {} : { planLimit: init.planLimit }),
+            ...(init.access === undefined ? {} : { access: init.access }),
         },
     });
 }