Fulcra is a context store that belongs to you, not to your apps.

Gives a group of agents one place to work that you own. Team files live in your Fulcra file store under team/<team-name>/, so the work, the progress and the outputs outlast any single agent or session.

• Creates or joins a team, and asks you to define each agent's role instead of assuming one.
• Keeps a fixed structure per team: role, progress, completed work, sessions, tasks, a shared knowledge base, and artifacts.
• Runs an inbox per member. Agents leave each other timestamped messages and archive them once processed, and file versioning gives you an audit trail of when each message arrived and when it was handled.
• Requires an agent to update its progress files before it finishes, so the next agent, or the same one waking on a cron run, starts from accurate state.
• Warns before any cross-agent data transfer, because moving context between agents can expose it to a principal you never authorized.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-workspaces.

Gives your agent the habit of checking what changed before it starts work, so a new session opens from current state and you are not asked to recap.

• Asks your permission first, then records the habit in its own memory so the scan runs at the start of each session.
• Runs fulcra data-updates for the window since its last check, which summarizes recent ingestion and file changes across your datastore in one call.
• Notices which team and memory files moved without downloading them, and fetches only the ones the current task needs.
• Checks its team inbox for coordination messages left by other agents or by you.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-situational-awareness.

A pipeline for taking an idea to a working prototype without skipping the parts that get skipped. Seven phases in order, each ending in a git commit, with the repository bundled to your Fulcra account so the work is portable instead of stuck on one machine.

• Intake, Interview, Architecture, Plan, Prototype, Build, Retro. Architecture and Prototype are gates: the agent stops and waits for you to approve the written artifact.
• Maps requirements onto Fulcra data types before any code, and defines custom types where nothing existing fits.
• Bans mock data. Spikes run against real records, because prototyping against simulated data proves nothing.
• Keeps a decision journal of trade-offs and dead ends, then bundles it with the repository so the context travels with the code.

This is a community skill, aimed at complex ideas, architectural exploration and third-party integrations rather than everyday work. Open the source before your agent starts a pipeline.

The connection step on its own. It covers both entry points, the CLI for agents with a shell and the hosted MCP server for chat agents, plus the device authorization flow that puts your agent on your account.

• CLI path: uvx fulcra-api runs the client without installing it, and uvx fulcra-api auth login starts the authorization flow.
• MCP path: point any MCP-capable agent at https://mcp.fulcradynamics.com.
• Credentials persist to disk and access tokens refresh on their own, so the login is a one-time step.
• Tells the agent what to do when its shell has no outbound network access: move you to the MCP connector instead of trying to debug the network.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-connect.

The reference an agent reads when it needs the mechanics instead of a guided flow. Three primitives cover most of what Fulcra stores: events for things that happened, metrics for values measured over time, and files that version themselves on every upload to the same path.

• Installs and runs the CLI, and completes device authorization in two steps so the command does not hang waiting on a browser.
• Creates custom data types from the base annotation shapes: moment, boolean, numeric and scale.
• Uploads, lists, inspects and downloads files, including earlier versions of a path.
• Covers the Open Knowledge Format conventions the file store expects, and where artifacts belong.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-primitives.

A pipeline for taking an idea to a working prototype without skipping the parts that get skipped. Seven phases in order, each ending in a git commit, with the repository bundled to your Fulcra account so the work is portable instead of stuck on one machine.

• Intake, Interview, Architecture, Plan, Prototype, Build, Retro. Architecture and Prototype are gates: the agent stops and waits for you to approve the written artifact.
• Maps requirements onto Fulcra data types before any code, and defines custom types where nothing existing fits.
• Bans mock data. Spikes run against real records, because prototyping against simulated data proves nothing.
• Keeps a decision journal of trade-offs and dead ends, then bundles it with the repository so the context travels with the code.

This is a community skill, aimed at complex ideas, architectural exploration and third-party integrations rather than everyday work. Open the source before your agent starts a pipeline.

Extends fulcra-ingest for the case where you want one dimension of an export as its own queryable type: your streams by artist, your viewing history by genre, your orders by category.

• Asks which dimension you want, inspects the shape of your raw files, and creates the matching annotation type if it does not exist yet.
• Generates the parser from a template that already handles deterministic ids, batch tag creation and case-insensitive tag matching.
• Runs the script, batch-ingests the records, and registers the new type in your source map and ingest log so the next run knows about it.

This is a community skill, and an extension rather than a starting point: it loads fulcra-ingest for the CLI syntax and the source-mapping rules. Open the source to read the full pipeline.

A sibling of fulcra-rapid-prototype for ideas that aren't fully formed yet. The engagement starts with a Grill Me intake, exactly one clarifying question at a time, and ends in working software with Fulcra as the backend.

• Six phases in order: Intake and Interview, Architecture, Plan, Prototype, Build, Retro, each ending in a git commit. Architecture and Prototype are gates that wait for your sign-off.
• No mock data: prototypes map to real Fulcra primitives, or create custom data types and write real records.
• State lives in a local git repository, backed up to your Fulcra account with git bundle, and a decision journal keeps the trade-offs and dead ends portable too.

Keeps one agent's working record in your account instead of inside the agent. Its progress, role, session summaries and long-running tasks go to agent/<agent-name>/ in your file store, in a structure you and other agents can read.

• Writes a progress.md you can actually review: recent work and next steps, not a dump of internal state.
• Keeps role.md current, so it stays clear what this agent is for and how it operates.
• Records session summaries carrying the decisions, links and preferences that came out of each spate of work, and tracks longer objectives in task files it updates as work progresses.
• Finds what changed across its own and shared namespaces with fulcra data-updates rather than listing directories.
• Checks progress reports for personal data and credentials before uploading them.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-memory.

Gives your agent the habit of checking what changed before it starts work, so a new session opens from current state and you are not asked to recap.

• Asks your permission first, then records the habit in its own memory so the scan runs at the start of each session.
• Runs fulcra data-updates for the window since its last check, which summarizes recent ingestion and file changes across your datastore in one call.
• Notices which team and memory files moved without downloading them, and fetches only the ones the current task needs.
• Checks its team inbox for coordination messages left by other agents or by you.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-situational-awareness.

Stores your preferences as records in your account rather than in one agent's memory, so every agent you connect starts from the same set. The agent loads them at the start of a session, applies them, and adds new ones as you state them.

• Creates a "User Preference" custom annotation type on first run and reuses it after that.
• Loads every recorded preference at session start, and where two conflict it honors the most recent one.
• Captures what you actually said: explicit asks, corrections, and patterns you confirmed when asked.
• Will not capture silent inferences, one-off task context, credentials, health details you did not ask it to store, or another person's preferences.
• Records aversions as well as preferences, so an agent also knows what not to suggest.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-prefs.

Snapshots an agent's identity and memory into your account so you can rewind it. The archive goes to one path in your file store, and because Fulcra versions files by path, repeated uploads build a timeline of that agent's states.

• Bundles SOUL.md, IDENTITY.md, MEMORY.md and the memory/ directory into memory.tar.gz, with generated restore instructions inside the archive.
• Runs on a schedule, from a heartbeat or alongside a memory sync.
• Takes a fresh backup before any rollback, so you can undo the rollback too.
• Clones an agent: the source agent backs up and reports its path, and the destination agent restores from it, then proves the clone worked by recalling specifics it has just learned.
• Requires your explicit confirmation before overwriting memory and identity, and checks for sensitive data before it uploads.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-agent-backup.

A community skill from an outside repository, kubla/a-particular-set-of-skills. It takes the Computer History summaries Codex already writes on your Mac and keeps them flowing into your account, so the record is not stranded in one tool.

• Previews the projected note, interval, tags, sources, data type and remote path before it authenticates or writes anything, so you can see exactly what would land in your account first.
• Sets up a token-free macOS LaunchAgent that sweeps roughly every ten minutes, and reports the authenticated owner, the computer name and the initial sweep counts when it is done.
• Keeps the projected note faithful to the summary Markdown, minus its trailing Citations section, and leaves the uploaded source file unchanged.
• Setup is convergent: it preserves your local configuration, projection map and projection status while refreshing the managed runtime.
• Uninstall removes only the local runtime and LaunchAgent. Everything already projected, and every source-file snapshot, stays in your account.

Requires macOS, Codex Computer History, uv, and network access. Open the source and read its spec before your agent runs it.

Durable prose memory your agents maintain like a wiki. Notes live as markdown files in your Fulcra file store using Open Knowledge Format, so the vault belongs to your account, not to any one agent or machine.

• Notes for projects, people, decisions, and domains, interconnected with [[wikilinks]] and mapped from a single index.md.
• Agents edit only the sections they own, record provenance for every conclusion, and append to logs instead of rewriting history, so an audit trail comes built in.
• Because the store is Fulcra, the same vault is readable and writable by every agent you authorize, on any platform.

A Cookbook recipe run as a workflow. It moves what your agent knows about your ongoing threads out of the current chat window and into your own account, so the next session opens already knowing where things stood.

• Triages the skill library against how you actually work rather than adopting everything at once, which surfaced fulcra-memory and fulcra-situational-awareness as the two with the highest immediate payoff.
• Creates a working namespace in your Fulcra file store: a role file describing what the agent is and how it operates, a progress file for recent work and next steps, and the index and log files the format requires.
• Puts the drafts in front of you before anything uploads, so you see exactly what the agent is about to write down about you.
• Records your consent in the role file, then runs the first awareness scan on the spot, so you watch the habit work once before trusting it to run unsupervised.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

A Cookbook recipe run as a workflow. Every fresh VM hands your agent a clean environment and no understanding of the work that came before it; this puts the explanation somewhere that outlives the machine.

• Audits a year of agent-driven activity, commits, pull requests and reviews, to find which work actually recurs and which repositories matter.
• Writes a work map into a shared vault: what the account is for, how the projects relate, and where a new agent should start reading.
• Adds an index so an authorized agent can find that map without being told where it lives.
• Points the agent's local memory at the shared copy rather than keeping its own, then verifies the round trip by downloading the files again and comparing them.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

A Cookbook recipe run as a workflow. It fixes an agent that keeps writing against deprecated APIs and obsolete house rules by scheduling its own reading rather than correcting it by hand.

• Starts by asking the agent to analyze its own history by request type, so the gaps are located from evidence rather than guessed at.
• Sets up two daily background jobs: one that fetches and summarizes the official documentation, one that mines the agent-skills and community-skills repositories for emerging patterns.
• Routes both jobs through the fulcra-vault skill, so the synthesized knowledge lands in a shared knowledge base instead of being stranded in local chat logs.
• Rewrites the agent's long-term memory to drop rigid constraints it had outgrown, and adds a standing directive to check the vault before starting new work.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

A Cookbook recipe run as a workflow. It replaces the re-briefing at the top of every conversation with one small tracker the agent reads before it answers.

• Begins by asking the agent what you actually use it for, by category, so the projects that need files are the ones that keep recurring.
• Writes one status file per project holding only what is established — current stage, the usual ask, who is involved — instead of a full project archive.
• Builds the index last, linking out to each file rather than repeating their contents, so there is one place the agent checks first.
• Moves the tracker out of the agent's private memory and into your Fulcra account, with the memory copy kept as a pointer, so every agent sees the same source of truth.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

A Cookbook recipe run as a workflow. Months of meeting recaps sit unread in an inbox; this turns them into one connected dataset an agent reasons over, without generating any new data.

• Centralizes recaps from many separate meetings into one place, so the agent reads them as a single body of work rather than as isolated documents.
• Asks for open action items across the whole set, which surfaces who is carrying unresolved work across meetings that never referenced each other.
• Verifies the reasoning by asking the agent to show where a specific claim came from, which is also what catches recaps that exist only as share links with no retrievable text.
• Writes the review step in as a standing instruction stored with the data, so the habit survives a new session and follows you between agents.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

A Cookbook recipe run as a workflow. Real creative thinking captured as audio and photographs is format-locked and unusable; this converts it into material an agent can reason over.

• Routes voice notes and photographed pages through a conversion step, so what arrives is text files rather than audio and images the agent cannot parse.
• Lands everything in one named folder, which is what lets the agent read the captures as a single document instead of a pile of fragments.
• Asks the agent to reflect back the throughline rather than summarize, which is what surfaces the question underneath several separate ideas.
• Keeps only the text-ified form in your context store — the originals stay where they are, since it is the text that makes them readable at all.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

Gives a group of agents one place to work that you own. Team files live in your Fulcra file store under team/<team-name>/, so the work, the progress and the outputs outlast any single agent or session.

• Creates or joins a team, and asks you to define each agent's role instead of assuming one.
• Keeps a fixed structure per team: role, progress, completed work, sessions, tasks, a shared knowledge base, and artifacts.
• Runs an inbox per member. Agents leave each other timestamped messages and archive them once processed, and file versioning gives you an audit trail of when each message arrived and when it was handled.
• Requires an agent to update its progress files before it finishes, so the next agent, or the same one waking on a cron run, starts from accurate state.
• Warns before any cross-agent data transfer, because moving context between agents can expose it to a principal you never authorized.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-workspaces.

Links your agent to an agent on a different Fulcra account: a friend's assistant, a teammate's bot, a site agent reporting a broken link to the team that owns the docs. The usual ways to do that are all too much — a shared login, a broad data grant, or a bot sitting in the middle — so this does it with the narrowest thing that works.

• One dedicated outbox channel per peer relationship, shared with a datashare naming exactly that channel. Never share_all_data, never a general-purpose channel your other workflows already write to.
• Nobody gets write access to anybody: a peer cannot post into your account and you cannot post into theirs. Each side publishes to its own channel and the other reads it.
• Asks for your explicit say-so before creating the share, and again before installing the scheduled sweep that reads incoming traffic. Asked for the broad version, the skill's answer is to stop and show you the narrow one.
• Treats a send as undelivered until it reads the message back by that send's own id, because an upload receipt only proves the request was accepted.
• Reads forward from a durable per-peer cursor, so a sweep that was down for a day picks up the day it missed instead of quietly skipping it.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-mesh.

Sits on top of fulcra-workspaces and adds the parts a shared file store leaves open. A team gives agents shared memory and inboxes; this adds who is alive, who holds which role, how work is handed off, and whether anything is actually running.

• Six layers over one team namespace: presence, roles held by lease instead of by session, continuity checkpoints with a deterministic resume brief, an N-reviewer verdict tally, directed work with acknowledgements, and fleet health.
• Anything two agents must agree on is computed by a shared engine as a fold over stored state, so two agents reading the same state reach the same answer instead of each interpreting timestamps for itself.
• Ships a stdlib-only Python engine inside the skill, with no install step and nothing to resolve.
• Reads an inbox once per wake rather than running a resident listener, which keeps retry policy visible to you and stops a slow read from wedging a long-running process.

This is a community skill. Open the source before your agent runs it: the repository records exactly which upstream modules the vendored engine includes and excludes.

A manager's view of what an agent team has been doing, built over a fulcra-workspaces team namespace. It reads the team's own progress files, so nobody has to file a separate report.

• Distills the team role, the team progress and each member's progress into an executive summary written into the dashboard's data.
• Shows recent work logs, completion against outstanding work, and a timeline or Gantt view of milestones.
• Renders a word map over recent agent actions and task descriptions, so the team's actual focus is visible rather than asserted.
• Builds on fulcra-dashboard's static triad, and falls back to a simpler page, a rendered chart or an inline Markdown summary when that is not viable.

This is a community skill. Open the source to read the full component list before your agent builds one.

An adaptation of fulcra-project-dashboard for task-specific control harnesses, where agents work through gated milestones and every run leaves evidence. It reads only the harness's durable workspace artifacts, never transient chat or scheduler state.

• A flight plan showing each milestone as passed, current, blocked, or queued, refreshed from the team's own progress files so stale state can't masquerade as current.
• A run timeline: each terminal run as a dated marker with its PASS, escalation, or decision-required verdict and a short evidence summary.
• Separates what needs a user decision from genuine escalations and transient provider capacity, and can publish a curated view for people outside the loop.

A Cookbook recipe run as a workflow. One agent is good at ideating and a different one is good at making images; this is the handoff between them, through context you own.

• Assembles the brief from two real sources — the exact language the positioning document uses, and the specific ask from the conversation — so nothing in it is guessed.
• Reuses an in tray and out tray already set up in the context store, so a new idea does not need a new system built around it.
• Connects the image tool to that same tray, so it turns a written request into a first draft without the request being re-typed into it.
• Files the finished picture in the out tray attached to the original request, so the ask and the result stay together instead of living in one chat.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

A Cookbook recipe run as a workflow. An idea stuck in a conversation with one assistant that cannot draw it, plus related notes in another, becomes a picture worth showing a builder.

• Merges renovation notes from separate conversations into one file, so nothing about the project lives in two places any more.
• Sets up a plain in tray and out tray in your context store — one place for requests, one for finished results — that any assistant can check.
• Connects an image tool to the tray so it can fulfill the request, and works around a real upload snag on the first attempt rather than pretending it did not happen.
• Downloads the actual finished file rather than a link, and verifies it is the file it claims to be before filing it against the original request.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com/mcp. Then open the write-up for the full walkthrough.

Takes a raw export you dropped into your file store and turns it into typed, queryable records. You upload a ZIP, JSON or CSV to ingest/; the agent profiles it, resolves or creates the schema, and writes the records.

• Triages the ingest/ directory, downloads new files and profiles their shape without asking you to map fields by hand.
• Keeps a source map so the same export never produces a duplicate schema, and generates deterministic ids so a re-run does not duplicate records.
• Can enrich records before writing them, adding cast and genre to a viewing history for instance, and can compute new tracks derived from what you already have.
• Archives each processed file with a timestamp and verifies the archive exists before removing the original.
• Logs every ingest with its source, date range and record count, then points you at your timeline to see the new data.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-ingest.

Turns "I want to track this" into a real schema in your account. The agent proposes a custom data type, creates it, records your first entry, and can show you the shape of the data before anyone commits to a full dashboard.

• Asks what you want to track, then creates the schema with uvx fulcra-api data-type create and keeps the ids it returns.
• Offers the Agent Visibility package when what you want to see is what background agents and teams are getting done.
• Records your first data point with you, or explains how another skill or app will do it automatically.
• Can put up a quick single-file HTML preview so you see the layout before the real thing gets built.
• Hands off to fulcra-dashboard for the full view, and writes the data types into the team knowledge base when a team is using them.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-tracking.

A Python package for descriptive analysis of your own data, built so the raw records stay on your machine. It fetches records or metric time series through the CLI, normalizes them into DataFrames, and produces summaries you can read or publish.

• Pulls from uvx fulcra-api get-records and uvx fulcra-api metric-time-series, or reads a local JSON, JSONL or CSV export.
• Computes missingness, numeric summaries, categorical frequencies, boolean ratios, datetime ranges and grouped summaries.
• Emits auditable JSON, or an OKF-ready report carrying the question, the data used, the methods, the findings, the caveats and the next steps.
• Keeps raw personal data local by default and uploads only sanitized summaries or artifacts you approved.
• Stops at descriptive statistics on purpose. Modeling, forecasting and causal work are out of scope.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-analytics.

Scaffolds a build-less dashboard over your Fulcra data: Alpine.js for state, vanilla CSS for styling, no framework toolchain. It runs on localhost by default, and only an isolated public/ directory is ever meant to be deployed.

• Generates a static triad of page, state script and styles, divided by banner comments so an agent can edit one region without unpicking the rest.
• Adds interactive charts with D3 or Plotly, or renders them in Python when a static image is the better answer.
• Falls back deliberately when the full build is not viable: a simpler bespoke page, a rendered chart image, or Markdown and ASCII in the chat.
• Separates the working directory, which holds your full datasets, from the public/ directory that is the only thing you publish.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-dashboard.

A local administration interface for your Fulcra setup, kept separate from the dashboard on purpose. It can read your file store and send commands to your agent, so it binds to localhost and is never published to the web.

• Scaffolds an Alpine.js panel and a Python backend into a directory you name.
• Includes a Chat Envoy: the backend exposes unread messages, and a small background loop hands them to your agent, so you can talk to it from the panel.
• Includes a file store explorer for browsing what is actually in your account.
• Themes itself to whatever you ask for while keeping the layout intact, so it stays usable at any width.

Install it with npx skills add fulcradynamics/agent-skills/fulcra-control-panel.

A Cookbook recipe run as a workflow. It hands the weeknight dinner decision to an agent that knows tonight's specifics, instead of leaving it to a 7pm brain that has already spent its judgment.

• Starts with a standing dinner brief: your usual goal, your constraints and dislikes, your bedtime, and your fallbacks for a hard training day or a bad night's sleep.
• Adds the three facts that change daily: last night's sleep, whether you trained, and what you have eaten so far.
• Connected to Fulcra, your agent reads those signals itself instead of waiting for you to report them, so the context assembles without the nightly data entry.
• Closes the loop with a two-week alternation: some nights the agent picks, some nights you do, judged on one metric you already capture.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com. Then open the recipe and paste the prompt at the end of it.

A Cookbook recipe run as a workflow. It builds your agent's picture of your fitness from what you actually did, not from the plan you wrote, so next week's suggestions fit the week you really have.

• Reconstructs the last two weeks of movement day by day, including the sessions you skipped and why. The skips carry as much signal as the sessions.
• States your body's limits as operational facts rather than diagnoses, so nothing gets suggested that you already know hurts.
• Adds a thirty-second report after each session: how it felt, where it was uneven, how your energy ran afterwards.
• Asks for the next seven days rather than a twelve-week program, then corrects what comes back. The corrections are the teaching.

Connect your agent first at fulcradynamics.com/connect/claude or fulcradynamics.com/connect/chatgpt, or point any MCP-capable agent at https://mcp.fulcradynamics.com. Then open the recipe and paste the prompt at the end of it.

A worked example of sharing without merging ownership. Two people each keep their own viewing history in their own account, share a narrow slice of it, and get recommendations neither history would produce alone.

• Each participant ingests their own Netflix or Letterboxd export with fulcra-ingest, then creates a narrow, preferably time-bounded share. The agent shows you the exact command before it runs, and never shares everything.
• Enriches titles with genre, cast and other features, caching progress as it goes so a long run survives an interruption.
• Scores unseen candidates against both histories, applies explicit vetoes, then re-ranks for novelty, availability, runtime and franchise fatigue.
• Returns five to ten picks with a separate reason for each person, plus its confidence, its assumptions, and how to revoke the share.
• Keeps the session in a workspace so another agent can resume it, while raw histories and anything derived from a partner's data stay out of it.

This is a community skill. Open the source to read the scoring model and the consent rules before your agent runs it.