pelican-cc 0.3.1 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,394 @@
 # Changelog
 
+## 0.4.1
+
+Pinned sessions and the files Claude sends you, as in Claude Desktop; approvals that show what a
+command hides; and what the reviews of 0.4.0 left.
+
+### Highlights
+
+- **Pinned sessions, as in Claude Desktop.** On a phone, a short swipe left on a row shows Pin
+  (Unpin on a pinned row) beside Archive, Archive at the edge as in Mail; a swipe all the way across
+  archives, with Undo, as before. On a computer the pin sits beside Archive when you point at a row,
+  and Pin is in the session menu; in the list, Undo shows for five seconds. A row takes no swipe
+  right, which is Safari's Back, nor one that starts at the very edge of the screen. Pinned sessions
+  lead the list under Pinned, grouped by time or by project, and under their project's filter, each
+  with its status (Working, Needs you, tasks) and its earlier runs. Pins are Pelican's own, kept on
+  the computer for all your browsers: a session pinned in Claude Desktop is not pinned here, and
+  Desktop's pins are left alone. Archiving a session unpins it.
+- **Files Claude sends you, as in Claude Desktop.** In the sessions Pelican runs, Claude can send
+  you files (Claude Code's SendUserFile): Pelican now tells Claude Code it shows them, the way
+  Claude Code expects of an app that does, which turns that tool on and nothing else. Before, the
+  call failed with "SendUserFile is still listed for this conversation but is switched off in this
+  session right now". A file shows where Claude sent it, as it is sent and after a reload, read
+  from where Claude Code delivered it, under the words Claude sends with it, which read as a reply
+  does, Markdown and all: pictures in place, side by side at their own size when they come alone and
+  as small squares beside other files, larger on a tap; a video or a sound in a player, a part at a
+  time, so it plays in Safari too; a page or an SVG as the still preview, with Run; text to read,
+  Markdown as it reads, folded when long; a PDF in your browser's own viewer, in a tab of its own;
+  anything else as a card to download, with its type, name and size. A file Claude meant you to
+  save stays a card until you open it. While the call runs its step says "Sending file", and
+  "Failed to send" if it fails, in Claude Desktop's words, and sent files are never folded away
+  among steps. Asked to send one from outside the session's folder, the approval says "Claude wants
+  to send you a file" and lists it, instead of the call's raw input.
+
+### Fixes
+
+- `npm install -g pelican-cc` installs Claude Code for this computer alone, about 150 MB to
+  download: from the package's npm-shrinkwrap.json, npm installed it for all eight platforms, 1.2 GB
+  to download and 2.6 GB on disk, and in a project Pelican's own build and test tools too. The
+  packages Pelican's server uses are built into it instead, as CI tested them, and the Agent SDK,
+  with the Claude Code it brings, stays pinned to one version. The package now ships
+  `THIRD_PARTY_NOTICES`: each package built into the server and the web app, with its version and
+  license in full, and, for web-push, which is under the MPL 2.0, that its source is its npm
+  package. It credits esbuild for the helper code it writes into the server, gives what rolldown's
+  runtime takes from others, and quotes the notices of others that files built in carry at their
+  top, such as path-browserify's in code of vfile's, which minifying leaves out. The build writes it
+  from what it puts in the bundles, and fails if one is missing.
+- A file Claude sent that is no longer there, as many are in older sessions, says "No longer on
+  this computer" before you tap anything, the same for every type, with its name and size and
+  nothing to tap; one past 200 MB says it is larger than Pelican serves, and a text file that large
+  still shows its start. A browser tab that opens one anyway says so in a page, not in JSON.
+- A character in a sent file's name that hides or turns text around shows as ⟨U+202E⟩, with the
+  approval's warning, on its card, in the step that sends it and in the name it is saved under: a
+  script named to read as a picture no longer does. A screenshot keeps the name macOS gave it.
+- Files Claude sent in Claude Desktop show from Claude Code's record of what it delivered, so one
+  Claude named by a relative path shows too; a file Claude Code did not deliver never shows.
+- An SVG file Claude writes shows in its own colors and fonts, as a browser shows it: the visuals'
+  styles repainted its text and boxes (a yellow box near-white, a white label near-black). A sent
+  picture too small for the download button in its corner has the button beside it.
+- A download, of a file Claude sent or from Changes and files, stops at the size the file had when
+  you asked for it: one that grew meanwhile, such as a log still being written, went on past the
+  size it had announced, and past the 200 MB limit. One cut short meanwhile breaks the download off.
+- A file whose extension names what every JavaScript object has, such as `.constructor`, opens as a
+  file: sent by Claude it failed with a server error, in Changes and files it showed as a broken
+  picture, and as an upload it would not open.
+- On a computer, a row's buttons cut none of its words: the words under them fade out, and in a
+  compact row the project and time make room for them. From the keyboard, Pin, Unpin and Archive
+  leave focus on the session's row where it went, or on the next row when it leaves the list, and
+  Undo brings focus back to it; Archive used to drop it to the page.
+- A compact row keeps a date on one line ("Oct 25", not "Oct" over "25"), and grouped by time the
+  list's headings say what they hold, Previous 7 days and Previous 30 days: "This month" held
+  October's sessions on 6 November.
+- A session archived in 0.4.0 while pinned in 0.4.1 comes back unpinned when you unarchive it.
+- A step Claude is still writing keeps its icon and its verb at their size beside a long command.
+- A conversation shows its day above its first message too, and above the first prompt of each new
+  day, as Claude Desktop does: Today, Yesterday, or the weekday and date.
+- A `!` command that is a command in backquotes, such as `` `grep x f` ``, takes exit code 1 as
+  an answer, as Claude Code does, not as a failure: where a command would start, Pelican reads a
+  backquote as Claude Code's parser does, after `;`, `|`, `if` or an assignment too.
+- Beside the conversation on a computer, a file's Quote and Copy row ends level with Send now and
+  the message boxes; it sat 2px lower.
+- An Agent call's steps come a page at a time, the newest first, with Show earlier, as a workflow
+  agent's do: a long subagent's transcript, tens of megabytes, no longer reaches the phone whole. A
+  page with no step in it, such as a long answer at the end, is read past, so the card counts the
+  steps it shows, never "Last 0 steps", and Show earlier always brings at least one more; a page
+  that cannot be read says why, and Show earlier asks again. A step too large to show says what was
+  left out of it, and the transcript is read only from the session's own folder.
+- Behind a tunnel or a proxy that cannot reach Pelican, a 502, 503 or 504 shows the quiet "Can't
+  reach" line, which keeps trying, instead of the error; a conversation that could not load then
+  loads once the computer is in reach again, also while the live connection stayed up.
+- Export as Markdown reads as the conversation does, but for a reply's single line breaks, which a
+  Markdown file joins, as GitHub does. A prompt is text, as you typed it: none of its Markdown takes
+  effect, so a ``` it opens no longer swallows the rest of the file, nor makes a line of `:--` a
+  table, and its quotes are quotes, a quote from a file its lines as code. A reply keeps to itself
+  in any reader (GitHub, VS Code's preview, the spec's own): a heading in it sits under the
+  speakers' (`##` becomes `####`), so none passes for "You" or "Claude"; its HTML is text, as the
+  conversation shows it, so none hides the turns after it; a picture is a link that names its site,
+  never loaded when the file is read; its links by reference are written with their addresses and
+  its footnotes under labels of its own, so two replies' `[^1]` are two footnotes and no reply
+  changes where another's links lead or what its footnotes say; and a code block it leaves open ends
+  with it. Where readers part ways on a reply (an autolink with a character one of them takes, an
+  address with a control character, `ftp://`, a table VS Code's preview finds under a fence or a
+  heading), it is written so that they read it alike. The files Claude sent are named under their
+  step, with the words Claude sent with them. An address that starts with http://, https://, ftp://
+  or www., and an email, in prompts and Claude Code's notes stay text, as code, where a reader would
+  link them. A text past 60,000 characters ends with "…", as the conversation shows it. The folder
+  is named as the app names it, from your home folder (`~/code/acme-web`), and a file a step reads,
+  edits or writes from the session's folder (`src/styles/theme.css`).
+
+### Security
+
+- An approval shows the characters that show as nothing or turn text around, as `⟨U+E0078⟩`, and
+  warns of them: besides the zero-width and direction-changing ones, tags, a variation selector
+  after a letter or a run of them, fillers, soft hyphens, a carriage return, a code point not
+  assigned yet and the others Chrome draws as nothing or as a blank, so a command can no longer read
+  as `./build.sh` and run another file. The trust sheet, the line saying why Claude Code asks and a
+  sent file's name show them the same way.
+- A space other than a plain one in a command shows as `⟨U+00A0⟩`, with the warning, unless Pelican
+  finds it in quotes, a heredoc's body or a comment: a shell takes it as part of a word, so `echo
+  done⟨U+00A0⟩# ; curl … | sh` read as a comment and ran curl, and `LC_ALL=C⟨U+00A0⟩cat ./setup.sh`
+  ran ./setup.sh. Pelican reads the command as bash, zsh, dash and macOS's bash 3.2 do, and the
+  scripts it hands a new shell: after `bash -c` or `ssh`, in a heredoc or pipe into `sh`, a script
+  it writes with a redirection or `tee` and then runs by its path, or by its name once it makes it a
+  program, or that runs on its own as a git hook or as a file a shell reads as it starts (what
+  BASH_ENV, ENV or `--rcfile` names, a .zshenv). A command that uses what can run text later in its
+  own shell has every such space show, however the text is made (split across quotes, by a variable
+  or an escape): `eval`, `source`, `trap`, an alias in any form (after `command` or `builtin`, or
+  named by a variable), `read`, `declare`, `let`, `unset`, zsh's `set -A` and its functions array,
+  bash's `BASH_ALIASES`, a parameter flag such as zsh's `(e)` and `$~x` or bash's `@P`, `setopt` or
+  `set -o` with an option that changes how text reads, `test` or `[` with an operator a variable may
+  give (`-v`), `at` and `crontab`, a command whose name Pelican does not know, arithmetic on a
+  variable the command sets to anything but a number, and the like, each by its name in any case (a
+  Mac runs `READ` as /usr/bin/read); so does a ksh script with a `<<#` heredoc, a script or a
+  program run by a path that is not plain text (`bash "$t"`) or from a folder the command writes
+  into but for a file it wrote there, and one run by its path where the command unpacks, patches or
+  copies a folder. Quoted text with a substitution's start in it counts as in a word. Where it
+  cannot tell, every such space shows. The same goes for a Monitor's command and, in the trust
+  sheet, for a hook, a helper, a skill's command and a git filter; between the arguments of an MCP
+  server, or of a hook run without a shell, every such space shows. A script another program writes
+  by itself, as `sed`'s `w`, `sort -o`, `split`, perl, python or awk can, is not followed, nor a
+  string another program runs in a shell of its own, such as python's `os.system` or a Makefile's
+  recipe. A long command shows at once, read once, and reading one takes at most a fixed time and
+  memory: a command longer than 64 KB, or that would take more to read than a fixed budget, has
+  every such space show, as a tool's input with many commands and a trust sheet's items share one
+  such budget (`x=…; bash -c "$x $x …"` of 24 KB took gigabytes, and crashed the page with the
+  approval on it again after each reload).
+- In a PowerShell command such a space shows as it is, as PowerShell takes it for a space, unless
+  the command hands a script to bash, sh, wsl or ssh, which read it otherwise: then every one shows,
+  with the warning; in the trust sheet too, for a hook PowerShell runs.
+- Ordinary text on an approval shows as it is, with no warning, as in Claude Code and Claude
+  Desktop: an emoji whole, in a command too, with its style, keycap, skin tone, flag and the joiners
+  between its pictures (a joined emoji such as a technologist warned in 0.4.0); a space other than a
+  plain one in a path, in words or in a command's quotes, such as the narrow one macOS puts in a
+  screenshot's name or a full-width one between Chinese words in a commit message; Apple's logo.
+  Words keep the joiners Persian and the Indic scripts are written with: what Claude says a command
+  does, a web search, what an agent is to do, a task, a tool's message and the caption of a file it
+  asks to send (a web search in Sinhala or Persian warned).
+- The trust sheet lists a hook's arguments: a hook run without a shell (with `args`) showed only its
+  program.
+- The trust sheet reads a folder's files as Claude Code reads them. A `.mcp.json` in a folder that
+  holds the repository was not read, though Claude Code reads one from every folder up to the file
+  system's top and starts its servers with the session: with `outer/.mcp.json` above the repository
+  `outer/repo`, a session there started with nothing asked, and the server ran. The folders above
+  the repository's top are now read for their `.mcp.json`, short of your home folder, whose files
+  are your own. A skill saved as `SKILL.MD`, which Claude Code opens on a Mac as `SKILL.md`, listed
+  nothing, nor did a command or an agent more than ten folders down, which Claude Code finds at any
+  depth: such a folder is now named above the list. A `.claude/settings.json` or `.mcp.json` saved
+  with a byte-order mark, as Windows' Notepad saves it, or as UTF-16, listed nothing, so the folder
+  was not asked about and Claude Code started with its hooks and servers; one Pelican cannot read as
+  JSON is listed by its name. A skill's, command's or agent's frontmatter whose lines end with a
+  carriage return alone, which Claude Code's YAML breaks at, hid its allowed-tools and hooks, and a
+  line separator (U+2028) on a key's line, which it reads as text, the key. A hook's or a server's
+  YAML shows with its lines as written, so a second line that runs curl no longer reads as part of a
+  `#` comment on the first, and the sheet says where an escape such as `\n` reads otherwise than it
+  is written. A folder's files are read in time that grows with their size, not with its square: in
+  0.4.0, a skill whose frontmatter was 480 KB of list items naming a power held the server for half
+  a minute, a command of a megabyte whose ```! block of blank lines never ends for four minutes, and
+  a skill of 1.1 MB with a line separator after a line of keys for a minute, after which the folder
+  counted as bringing nothing. The sheet lists from a file up to 200 items and 256 KB of them as it
+  shows them, and from a folder up to 1,000 and 1 MB, reading up to 32 MB of its files, more than
+  any project brings. An item it warns of, and Pelican's own word on what it could not read, are
+  always kept, so no number of harmless items leaves one out, and what the repository's git config
+  runs is read and listed whatever the folder's other files bring. Past that the sheet names, above
+  the list and in red, the first three files it shows part of and how many more, and the folder is
+  asked about as before, also where it lists nothing. A hook whose type or arguments are nested too
+  deep to read shows as one Pelican cannot read, where the request failed and nothing started.
+- A notification keeps a flag made of tags only for England, Scotland and Wales, the three Unicode
+  recommends; other tags after a black flag, which can spell anything unseen, are left out. The
+  repository's check for hidden characters holds the docs to the same three.
+
+### Site, docs and project
+
+- The demo, and the live demo on the website, have a pinned session and a file Claude sent: in "Try
+  the dark theme on my phone", a screenshot of the settings page in dark. Export as Markdown
+  downloads the session in the live demo too, where it fetched nothing, its folder named
+  `~/code/acme-web` as the demo shows it, not by where the site was built.
+- The docs say what the install takes: about 150 MB to download, about 400 MB on disk.
+- The tests pass in any order, at any time of day, and hold on a busy computer: each starts from a
+  state of its own, a page's tests wait up to 3 seconds for what they look for, and those that
+  start a shell or Pelican give it time to start and leave nothing running when they fail. CI checks
+  that an install brings one Claude Code, and the smoke test that Export as Markdown downloads.
+
+## 0.4.0
+
+Files, changes and side chats as in Claude Desktop, workflows and `!` commands you can watch, and
+your usage from every app.
+
+### Highlights
+
+- **Changes and files.** See what each turn changed (T1, T2…, numbered and counted as Claude
+  Code's `/diff` does until a compaction, from its own record, so also outside git), what is
+  uncommitted, or everything since your branch split from main, with diffs, and Rewind code where
+  Claude Code kept a checkpoint. Search the folder by name or in the text, and read a file with
+  line numbers, Markdown and HTML previewed. A file a step names, or a `path:line` in a reply,
+  opens at its line, and under a turn that edited files "3 files changed" opens them. On a phone
+  it is a view of its own that the back gesture steps through; on a computer it sits beside the
+  conversation from 1024px wide.
+- **Side chats.** `/btw`, Cmd/Ctrl+; or Side chat in the session menu asks something on the side,
+  as in Claude Desktop. Claude answers from a read-only copy of the session (Read, Grep and Glob,
+  no MCP servers, never Bypass), and is told so with each question, as in Desktop. Nothing goes
+  back to the session, which keeps working. It sits beside the conversation from 1024px wide,
+  taking turns with Changes and files, and is a sheet on a phone. Side chats are Claude Code
+  sessions titled "Side chat", kept out of the session list (List options > Side chats shows them),
+  and continue in the CLI and Desktop; opened from the list, one keeps its box for questions only.
+- **Quote.** Select text in a reply, a step's output or a file and tap Quote. The quote waits
+  above the message box with your draft and goes above your words as a `>` quote; lines of a file
+  carry where they are, as `src/app.ts:7-8`.
+- **Live `!` commands.** Output as it comes, with Stop, for up to 30 minutes. When a command ends,
+  Claude answers it, as in the CLI, unless `respondToBashCommands` is false. Commands are written
+  the way Claude Code writes them, so the terminal and Desktop show Pelican's, and Pelican shows
+  theirs.
+- **Usage and activity.** Settings > Usage and activity shows your Claude Code usage on this
+  computer, from every app: tokens of each kind over 7 days, 30 days or all time, per day,
+  sessions, active days and streaks, and where they went by project, model, app and session, with
+  a few highlights. On a plan its limits are at the top; on an API key or a provider, the cost
+  Claude Code estimates. Each reply counts once, also when it was copied into a side chat or a
+  branch; Claude Code's `/stats` counts each content block, so its totals are higher. The session
+  menu shows what that session used.
+- **Workflows.** A workflow (Claude Code's Workflow tool) shows as a card, as Claude Code shows
+  one, instead of its script's first line: its name, Running or how it ended with its agents and
+  tokens, its phases one a line (Review · 3 of 5 done) opening into their agents and each agent's
+  steps, the script and the result. It is live, with Stop, in sessions Pelican runs, and read from
+  the run's folder for other apps'; its end, also one that came while Claude worked (those were
+  lost), leads back to the card. Asked to run one, the approval shows its phases, the args its
+  script runs with and the file it runs.
+
+### Changes in behavior
+
+- Line comments go with your next message in the session they were written in, before your words,
+  as in Claude Desktop, or on their own with Cmd/Ctrl+Enter, instead of Add to message. They are
+  kept across reloads and forgotten on sign-out.
+- Transcript views are Claude Desktop's: Normal, Thinking and Verbose, and Ctrl+O steps through
+  them. Thinking shows in a session's menu once Claude has thought there. A session set to Summary
+  opens in Normal.
+- A `!` command may run 30 minutes instead of two, and Claude answers it when it ends, which is a
+  turn like a prompt. A command you stop gets no answer, and one still running when Pelican stops
+  gets up to 15 seconds to tidy up, then ends with it; Ctrl+C again ends it at once. Under launchd
+  it gets what the login item leaves: `pelican service install` now asks launchd for 20 seconds,
+  where it gave 5.
+- Claude gets a `!` command's output as Claude Code's bash mode gives it, in the record Claude
+  Code writes for the same output: stdout and stderr together in the order they were written, as
+  much as Claude Code reads back of it, 30,000 bytes or what `bashOutputMaxChars` sets (where that
+  is unset, BASH_MAX_OUTPUT_LENGTH, 1 to 150,000), instead of up to 200,000 characters of each. A
+  failed one is cut there. One that went well and printed more is saved in the session's
+  `tool-results` folder, where Claude Code saves one, up to 64MB, and Claude gets its start and
+  where it is; so is one whose text is longer than Claude gets inline (30,000 characters, or what
+  `bashOutputMaxChars` sets). Exit code 1 from grep, diff, test or find is an answer, not a
+  failure, when that command is the line's last statement as Claude Code's parser reads it (not
+  in a subshell or a `{ }` group; a comment is none). The record no longer adds the exit code, or
+  that something runs on in the background, as Claude Code's adds neither.
+- What Claude changes in answer to a `!` command is that command's turn in Changes, as in `/diff`;
+  a message of files alone starts a turn, a picture sent without words none, and a new file's
+  lines count as `/diff` counts them. After a compaction `/diff` numbers from 1 again, and it reads
+  only the last 4,096 messages, so in a longer stretch its T1 is a later turn; Pelican, which shows
+  every turn, counts on from the first.
+- A renamed file's diff shows the rename and what changed in it, instead of the whole file as new;
+  one renamed whole says "Renamed from …, unchanged".
+- Push and Create PR, on the branch line, show only where the repository has a remote with an
+  address, not one that only a system or managed git config names (a fetch line for every
+  repository).
+- Changes and files docks from 1024px wide instead of 1440px; below 1280px the session list folds
+  away while it is open, and Cmd/Ctrl+K brings it back.
+- Cmd/Ctrl+\ closes Changes and files when pressed in it, as it closes the side chat and as Close
+  pane does in Claude Desktop; closed, the pane gives the keys to the button that opens it.
+- The keyboard shortcuts (Cmd/Ctrl+/) list Changes and files (Cmd/Ctrl+Shift+D), Close pane
+  (Cmd/Ctrl+\) and Send comments (Cmd/Ctrl+Enter), and call Ctrl+O Transcript view.
+- Commit, Push and Create PR, on the branch line, put a request to Claude in the message box, so
+  your rules, hooks and attribution apply. Pelican runs no git that changes anything.
+
+### Sessions and the list
+
+- Claude Desktop's side chats stay out of the list also once Claude Code has given them the
+  session's title again, as it does when their Claude exits; most showed as more sessions with
+  that title.
+
+### The conversation
+
+- An approval says Claude's few words on a command once, also when Claude Code passes them as its
+  own line too.
+- A failed request at the end of the conversation offers Retry, which sends the prompt again with
+  its files, or Compact when the conversation is too long.
+- Scheduled check-ins have Cancel, which asks Claude to cancel them.
+- An MCP server that needs you to sign in says where: `claude mcp login <name>` in a terminal on
+  the computer, or claude.ai's connectors page.
+- Approval notifications have Allow and Deny where the device shows buttons on notifications
+  (Chrome on a computer or Android), for a command a notification shows whole: printable ASCII with
+  one space between words, on one line, short enough for two lines of the narrowest notification
+  (about 50 characters, fewer when they are wide), and on Android, whose pop-up shows one line
+  beside the buttons, for that one line (about 20). A notification shows the command itself, not
+  Claude's description of it; edits, other tools, other commands, questions and plans open the
+  session.
+- Notifications and check-ins keep emoji whole, also those made of several pictures, and still
+  leave out characters that hide text or turn it around, now also from a notification's title, the
+  session's. Their text is cut between characters as they show, and sooner where those hold many
+  code points (one letter can carry any number of accents), so a notification stays within the
+  4 KB a push service carries.
+- Export as Markdown has the conversation as it shows here: `!` and `/` commands as typed, as
+  code, with their output; the files and pictures sent with a prompt; Claude Code's own lines,
+  such as a background task's note, Interrupted, a failed request (naming the computer, as the
+  conversation does) or a hook's word, and a command that failed marked so; and none of
+  the tags, notes and summaries Claude Code and Pelican add for Claude, such as a side chat's note
+  with each question.
+- The session menu shows the session's tokens, the share from the cache, its models and
+  compactions, and its cost where Claude Code counts one.
+- A finished `!` command shows the end of its output, as it did while it ran; Show all shows the
+  start, and for one too long for the conversation what Claude Code saved of it (up to 64MB), from
+  that file, a page at a time, also in a branch that copied it. One that printed nothing shows the
+  command alone, and one that failed says Failed, or Stopped, where its live card said how it
+  ended; a record from before (Claude Code before 2.1.80, Pelican before 0.4) says so only where
+  it noted it. A running one's Stop is named for it.
+- Claude's answer to a background task's note shows after the note, not in the reply before it.
+- A message that does not go comes back to the message box, files and all, above anything typed
+  since. A `!` or `/` command comes back only into an empty box; with words or files there, it
+  waits above the box, Not sent, with Put back, as does a message, files and all, that comes back
+  while a command is typed. A `/` command goes with its words alone: files in the box wait for the
+  next message, as quotes do. What waits stays across reloads, and in a new session goes on with
+  the session once it starts, line comments too. Put back brings words and files back together, or, where they cannot
+  share the box, swaps them with what is there, which waits in its place, Set aside. One sent for
+  you (Send now, Compact, Retry, Cancel) leaves the box as it is.
+- A path or "files changed" tapped while the side chat is open puts it away and opens Changes and
+  files.
+- Side chat in the session menu leaves the keys in the side chat's box, which, beside the
+  conversation on a tablet, keeps clear of the home indicator, level with the conversation's.
+  Quotes that do not fit above the message box fade at its edge, and removing one with the
+  keyboard moves on to the next.
+- A conversation opens without the code of Changes and files, which follows once it is up, and
+  Settings without the usage page.
+
+### Changes and files
+
+- Search in files shows each hit where it is on its line, after a "…" when it is far along,
+  marked in amber.
+- A file's Quote and Copy sit in a row of their own under the file, so nothing scrolls beneath
+  them.
+- On a touch screen, search results and a step's file name are a finger tall, and the lowest row
+  of Changes and files (Quote and Copy, Send now, or the bar saying Claude needs you) keeps clear
+  of the home indicator, on a phone and beside the conversation on a tablet.
+- Esc in a comment on a file gives the keys back to the file, as on a diff, so the next Esc closes
+  the view.
+
+### Security
+
+- In a folder kept to your settings only, a `!` command runs git as Claude Code does there, with
+  none of the repository's own programs (its file-system monitor, filters or hooks folder).
+- Changes and files reads only regular files inside the folder it is asked about (the session's),
+  links followed and checked. Downloads come as inert attachments. Search runs the ripgrep inside
+  Claude Code with no config, an empty environment, no git and no links followed.
+- Show all on a long `!` command reads the file Claude Code saved its output in by that file's
+  name alone, from the session's own `tool-results` folder, or, for a record a branch copied, from
+  that of the session its row says it came from, when the record's path names that session: a
+  regular file reached through no link and with no other name.
+- A page in Files runs its scripts only after Run, and again only after another Run once it has
+  been rewritten; a page opened straight from another file never starts running.
+- A side chat only reads, asks for nothing, and takes no `/` or `!` commands. A side chat branched
+  from one of its questions is one too.
+- Notification buttons go through the same checks as the page, and Allow is offered only for a
+  command a notification shows in full: printable ASCII with one space between words, on one line,
+  that fits two lines of the narrowest notification in its widest letters, and on Android, whose
+  pop-up shows one line beside the buttons, that one line.
+
+### Site, docs and project
+
+- The demo's files have their text, and the files its conversations name open at the lines they
+  name.
+- The docs cover Changes and files, side chats, quotes, live `!` commands, the views and the
+  usage page, and the coverage table moves side questions, views, quotes and Create PR to Yes.
+- On a phone, the website leads with the two buttons and the install command, then shows the app
+  in the same phone frame as on a computer, whole when you scroll, instead of a cropped card.
+- The browser smoke test checks the docked pane at 1024, 1280 and 1440px and the side chat pane at
+  1024px, where it asks a question, and opens older sessions at one size only, to keep CI quick.
+
 ## 0.3.1
 
 - New sessions start at High effort until you pick another in Settings (New sessions start with >

package/README.md

@@ -44,9 +44,9 @@ pelican
 ```
 
 On the computer where you use Claude Code, with Node 22.12 or newer and Claude Code signed in, on
-macOS or Linux. `pelican` prints the link that signs this browser in. The install is about 150 MB,
-most of it the copy of Claude Code that the Agent SDK brings. The command is also called
-`pelican-cc`, for computers where Python's Pelican has `pelican`.
+macOS or Linux. `pelican` prints the link that signs this browser in. The install is about 150 MB
+to download and about 400 MB on disk, most of it the copy of Claude Code that the Agent SDK brings.
+The command is also called `pelican-cc`, for computers where Python's Pelican has `pelican`.
 
 ## On your phone
 
@@ -66,18 +66,23 @@ The docs cover [an SSH tunnel or your own proxy](https://ki-seki.github.io/pelic
   every compaction. When another app is working on one, or waits for you there, Pelican says which
   app; once it is idle, continue it here.
 - **All of Claude Code.** Approvals with the diff, plans and questions, steer or queue while Claude
-  works, `!` commands, `/` commands and skills, `@` files, every model and permission mode, rewind
-  and branch, subagents and background tasks, MCP servers and usage limits.
-- **What Claude makes, in place.** Charts and diagrams Claude draws and pages it writes show in the
-  conversation, as still pictures until you tap Run.
-- **The changes beside the chat.** Every changed file with its diff. Tap a line to comment, and
-  your comments go into the next message.
+  works, side chats, `!` commands with their output live, `/` commands and skills, `@` files, every
+  model and permission mode, rewind and branch, subagents and background tasks, MCP servers.
+- **What Claude makes, in place.** Charts and diagrams Claude draws, pages it writes and files it
+  sends you show in the conversation, as in Claude Desktop: pages as still pictures until you tap
+  Run, pictures side by side, videos and sounds in a player, a PDF in your browser's viewer,
+  anything else to download.
+- **Changes and files, as in Claude Desktop.** What each turn changed, what is uncommitted, or
+  everything since your branch split, with diffs. Search and read the folder; a path in a reply
+  opens the file at its line. Comment on a line or quote it, and Create PR asks Claude.
+- **Your usage, from every app.** Tokens, sessions and streaks by project, model and app, with your
+  plan's limits, or the cost Claude Code estimates on an API key.
 - **Made for a phone, good on a computer.** One hand, dictation, a notification when Claude needs
   you or finishes, and a Home Screen icon. On a wide screen, the list, the conversation and the
   changes sit side by side.
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/Ki-Seki/pelican/main/docs/shots/tour.gif" width="320" alt="A tour of Pelican on a phone: a chart and a page Claude made, rendered in place; an edit waiting for approval with its diff; a session another app is running">
+  <img src="https://raw.githubusercontent.com/Ki-Seki/pelican/main/docs/shots/tour.gif" width="320" alt="A tour of Pelican on a phone: the list with a pinned session; a chart Claude drew, in place, and a page it wrote, run; an edit waiting for approval, and what changed; a screenshot Claude sent; a session Claude Desktop is running">
 </p>
 
 ## Compared with
@@ -101,8 +106,7 @@ Remote Control can answer a prompt waiting in your terminal; Pelican cannot. Mor
 Pelican runs Claude Code itself, so your settings, `CLAUDE.md`, hooks, skills, subagents and MCP
 servers work as they do in the terminal, and so does any login: a Claude plan, an API key, Bedrock,
 Google Cloud or Microsoft Foundry. What Pelican does not do: Remote Control, cloud sessions, a
-worktree for each new session, side questions (`/btw`), a terminal of its own, or editing files by
-hand. [The full table](https://ki-seki.github.io/pelican/docs.html#coverage) goes through Claude
+worktree for each new session, a terminal of its own, or editing files by hand. [The full table](https://ki-seki.github.io/pelican/docs.html#coverage) goes through Claude
 Code's features one by one.
 
 ## Security
@@ -161,4 +165,6 @@ through [SECURITY.md](SECURITY.md).
 
 ## License
 
-[MIT](LICENSE). Pelican is an independent project, not made by or affiliated with Anthropic.
+[MIT](LICENSE). Pelican is an independent project, not made by or affiliated with Anthropic. The
+packages built into its server and web app are under their own licenses: `THIRD_PARTY_NOTICES`,
+in the npm package, gives each with its license in full.