create-pmos 0.95.0 → 0.97.0

package/workspace/lib/kit-update.js

@@ -3,7 +3,8 @@
  *
  *   readKit(root)                           → { present:false } | { present:true, version, kernelSource, installed, mode }
  *   status({ root, appVersion, appDir })    → { app: { version, fromCheckout }, kit }       local only, no network
- *   latest({ exec })                        → Promise<{ ok, version } | { ok:false, error }>   npm view create-pmos version
+ *   source(env)                             → { kind:'npm' } | { kind:'local', path } | { kind:'local', path, error }
+ *   latest({ exec, source })                → Promise<{ ok, version } | { ok:false, error }>   npm view create-pmos version
  *   compare(st, latestVersion)              → { appBehind, kitBehind }
  *   updateKit(root, { version, exec })      → Promise<{ ok, output, kit } | { ok:false, error, output }>
  *   upgradeApp(root, { version, logFile, spawn, env }) → { ok, log } | { ok:false, error }
@@ -14,6 +15,10 @@
  *   check        npm view create-pmos version
  *   kit          npx -y create-pmos@<version> --update <repo>            (the kernel only; state/ and planning/ untouched)
  *   app          npx -y create-pmos@<version> workspace --reinstall <repo> (what `pmos upgrade` runs)
+ * LOCAL SOURCE. PMOS_UPDATE_SOURCE names a built create-pmos package on this computer: its folder (with package.json, bin/
+ * and payload/ or workspace/) or its .tgz from `npm pack`. The check then reads that package's version instead of asking
+ * the registry, and the update runs `npx -y <that path> ...` in place of `npx -y create-pmos@<version> ...`. Nothing
+ * reaches the network, so an update can be tried before it is published. Unset means npm (the default).
  * The version is the one the check found, so what is installed is what the PM was shown, not whatever `latest` is a
  * minute later. The app upgrade stops this server (create-pmos runs `pmos stop`), so it runs DETACHED, writes its output
  * to a log file, and the page waits for the server to come back.
@@ -81,8 +86,34 @@ function fromCheckout(appDir) {
   try { return fs.existsSync(path.join(String(appDir), '..', '.git')); } catch { return false; }
 }
 
-function status({ root, appVersion, appDir }) {
-  return { app: { version: appVersion || null, fromCheckout: fromCheckout(appDir) }, kit: readKit(root) };
+/**
+ * Where "latest" comes from. Unset or "npm" is the registry. Anything else is a path to a built create-pmos package: a
+ * folder or a .tgz. `error` names what is wrong with it, so the page can say so instead of silently using npm.
+ */
+function source(env = process.env) {
+  const raw = String((env && env.PMOS_UPDATE_SOURCE) || '').trim();
+  if (!raw || raw.toLowerCase() === 'npm') return { kind: 'npm' };
+  const p = path.resolve(raw);
+  let st;
+  try { st = fs.statSync(p); } catch { return { kind: 'local', path: p, error: `PMOS_UPDATE_SOURCE points to ${p}, which does not exist` }; }
+  if (st.isDirectory()) {
+    let pkg;
+    try { pkg = JSON.parse(fs.readFileSync(path.join(p, 'package.json'), 'utf8')); } catch { pkg = null; }
+    if (!pkg || pkg.name !== PKG_NAME) return { kind: 'local', path: p, error: `${p} is not a ${PKG_NAME} package folder (no package.json named ${PKG_NAME})` };
+    if (!fs.existsSync(path.join(p, 'payload')) && !fs.existsSync(path.join(p, 'workspace'))) return { kind: 'local', path: p, error: `${p} is not a built package: it has no payload/ or workspace/ folder. Point PMOS_UPDATE_SOURCE at the .tgz from \`npm pack\` instead` };
+    return { kind: 'local', path: p, version: validVersion(pkg.version) ? pkg.version : null };
+  }
+  const m = /^create-pmos-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\.tgz$/.exec(path.basename(p));
+  if (!m) return { kind: 'local', path: p, error: `${p} is not a create-pmos-<version>.tgz file` };
+  return { kind: 'local', path: p, version: m[1] };
+}
+
+/** What npx installs: the registry package at a version, or the local path. */
+const specOf = (src, version) => (src && src.kind === 'local' ? src.path : `${PKG_NAME}@${version}`);
+
+function status({ root, appVersion, appDir, env }) {
+  const src = source(env);
+  return { app: { version: appVersion || null, fromCheckout: fromCheckout(appDir) }, kit: readKit(root), source: src.kind === 'local' ? { kind: 'local', path: src.path, error: src.error || null } : { kind: 'npm' } };
 }
 
 function compare(st, latestVersion) {
@@ -115,7 +146,12 @@ function why(r, what) {
   return `${what} did not finish${said ? ': ' + said : ''}`;
 }
 
-async function latest({ exec = cp.execFile } = {}) {
+async function latest({ exec = cp.execFile, source: src = source() } = {}) {
+  if (src.kind === 'local') {
+    if (src.error) return { ok: false, error: src.error };
+    if (!src.version) return { ok: false, error: `${src.path} has no version number` };
+    return { ok: true, version: src.version, source: 'local' };
+  }
   const r = await run(exec, NPM, ['view', PKG_NAME, 'version', '--json'], { timeout: CHECK_TIMEOUT_MS });
   const bad = why(r, 'The check');
   if (bad) return { ok: false, error: bad };
@@ -135,10 +171,11 @@ function notServedYet(text, version) {
 }
 const notServedYetError = (version) => `npm lists ${PKG_NAME} ${version}, but its download is not available yet. A version this new can take up to five minutes to reach every npm server. Press Update again in five minutes`;
 
-async function updateKit(root, { version, exec = cp.execFile } = {}) {
+async function updateKit(root, { version, exec = cp.execFile, source: src = source() } = {}) {
   if (!validVersion(version)) return { ok: false, error: 'Check for updates first' };
+  if (src.kind === 'local' && src.error) return { ok: false, error: src.error };
   if (!readKit(root).present) return { ok: false, error: 'This repository has no PMOS kit folder (pmos/KIT-VERSION)' };
-  const r = await run(exec, NPX, ['-y', `${PKG_NAME}@${version}`, '--update', String(root)], { timeout: UPDATE_TIMEOUT_MS, cwd: String(root) });
+  const r = await run(exec, NPX, ['-y', specOf(src, version), '--update', String(root)], { timeout: UPDATE_TIMEOUT_MS, cwd: String(root) });
   const output = tail(r.stdout + (r.stderr ? '\n' + r.stderr : ''));
   if (r.err && notServedYet(r.stdout + r.stderr, version)) return { ok: false, error: notServedYetError(version), output };
   const bad = why(r, 'The kit update');
@@ -175,15 +212,16 @@ function updateEnv(env = process.env, nodePath = process.execPath) {
   return parts.includes(dir) ? { ...env } : { ...env, [key]: [...parts, dir].join(path.delimiter) };
 }
 
-function upgradeApp(root, { version, logFile, spawn = cp.spawn, env = updateEnv() } = {}) {
+function upgradeApp(root, { version, logFile, spawn = cp.spawn, env = updateEnv(), source: src = source() } = {}) {
   if (!validVersion(version)) return { ok: false, error: 'Check for updates first' };
+  if (src.kind === 'local' && src.error) return { ok: false, error: src.error };
   let fd;
   try {
     fs.mkdirSync(path.dirname(logFile), { recursive: true });
     fd = fs.openSync(logFile, 'w');
     fs.writeSync(fd, `${new Date().toISOString()} clearing npm cache…\n`);
     fs.writeSync(fd, `${new Date().toISOString()} ${NPM} cache clean --force\n`);
-    fs.writeSync(fd, `${new Date().toISOString()} ${NPX} -y ${PKG_NAME}@${version} workspace --reinstall ${root}\n`);
+    fs.writeSync(fd, `${new Date().toISOString()} ${NPX} -y ${specOf(src, version)} workspace --reinstall ${root}\n`);
   } catch (e) { return { ok: false, error: `Could not write the log file: ${e.message}` }; }
   try {
     // Clear npm cache synchronously before spawning the update, so npx downloads the fresh version
@@ -192,7 +230,7 @@ function upgradeApp(root, { version, logFile, spawn = cp.spawn, env = updateEnv(
     try { fs.appendFileSync(logFile, `Note: cache clear had an issue, but continuing: ${e.message}\n`); } catch { /* silent */ }
   }
   try {
-    const child = spawn(NPX, ['-y', `${PKG_NAME}@${version}`, 'workspace', '--reinstall', String(root)],
+    const child = spawn(NPX, ['-y', specOf(src, version), 'workspace', '--reinstall', String(root)],
       { cwd: String(root), env, detached: true, stdio: ['ignore', fd, fd], windowsHide: true, shell: IS_WIN });
     // A child that could not start writes nothing itself: say why in the log, which the page names when it gives up.
     if (child && typeof child.on === 'function') {
@@ -207,4 +245,4 @@ function upgradeApp(root, { version, logFile, spawn = cp.spawn, env = updateEnv(
   }
 }
 
-module.exports = { PKG_NAME, cmpVer, notServedYet, validVersion, readKit, fromCheckout, status, compare, latest, updateKit, updateEnv, upgradeApp, whereFrom };
+module.exports = { PKG_NAME, cmpVer, notServedYet, validVersion, source, specOf, readKit, fromCheckout, status, compare, latest, updateKit, updateEnv, upgradeApp, whereFrom };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.95.0",
+  "version": "0.97.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.95.0",
+      "version": "0.97.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.95.0",
+  "version": "0.97.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/components.css

@@ -3381,6 +3381,28 @@
   margin-left: -8px;
 }
 
+/* launch-flag picker (flag-picker.js) and the profile form: new-session defaults on Settings, the flag list on the New session form */
+.fr-fp { display: flex; flex-direction: column; gap: 8px; min-width: 0; width: 100%; }
+.fr-fp-chips { display: flex; flex-wrap: wrap; gap: 6px; }
+.fr-fp-chips .fr-fp-chip { font-family: var(--mono); font-weight: 400; }
+.fr-fp-chips .fr-fp-chip[aria-pressed="true"] { background: var(--accent); border-color: var(--foreground); }
+.fr-fp-list { max-height: 320px; overflow: auto; border: 1px solid var(--border); border-radius: 8px; background: var(--background); }
+.fr-fp-row { display: flex; flex-direction: column; gap: 2px; padding: 8px 10px; border-bottom: 1px solid var(--border); min-width: 0; }
+.fr-fp-row:last-child { border-bottom: 0; }
+.fr-fp-row--off { opacity: 0.55; }
+.fr-fp-head { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; font-family: var(--mono); font-size: 12px; }
+.fr-fp-val { display: flex; flex-direction: column; gap: 6px; padding-left: 24px; max-width: 420px; }
+.fr-fp-stack { display: flex; flex-direction: column; gap: 8px; }
+.fr-fp-sub { font-size: 12px; color: var(--muted-foreground); line-height: 1.5; }
+.fr-fp-label { font-family: var(--mono); font-size: 11px; font-weight: 500; letter-spacing: 0.1em; text-transform: uppercase; color: var(--muted-foreground); }
+.fr-fp-warn { font-size: 12px; line-height: 1.5; color: var(--warning); overflow-wrap: anywhere; }
+.fr-fp-defrow { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; }
+.fr-fp-note { margin: 0; color: var(--muted-foreground); font-size: 12px; line-height: 1.5; overflow-wrap: anywhere; }
+.fr-fp-bad { color: var(--destructive); }
+.fr-set__form { display: flex; flex-direction: column; gap: 10px; padding: 10px; border: 1px solid var(--border); border-radius: 8px; background: var(--background); }
+.fr-set__envrows { display: flex; flex-direction: column; gap: 6px; }
+.fr-set__flags { display: flex; flex-direction: column; gap: 8px; align-items: flex-start; min-width: 0; width: 100%; }
+
 /* -- layouts · .td- Today (Run 3, slice 3B) -- */
 .td-board {
   display: flex;

package/workspace/public/pm/data.js

@@ -1237,6 +1237,12 @@ export async function loadProfiles() {
   return getJson('/api/profiles');
 }
 
+/** Every flag `claude --help` lists, each marked `offered` or not with the reason. A static file on the server. */
+export async function loadClaudeFlags() {
+  if (FIXTURE) return { ok: false, error: 'fixture mode reads no flag list', flags: [] };
+  return getJson('/api/claude-flags');
+}
+
 /** Remember the profile this agent should preselect next time. The server refuses a preference for
  * a descriptor it cannot read, so a stored id always resolves to a chip that is on screen. */
 export async function preferProfile(agent, profile) {

package/workspace/public/pm/dest-settings.js

@@ -32,6 +32,7 @@ import { sessionDefaults, setSessionDefaults } from './dock.js';
 import { COPY } from './frame-copy.js';
 import { askConfirm } from './dialogs.js';
 import { icon } from './icons.js';
+import { flagPicker, flagsLine, flagsMissingValue } from './flag-picker.js';
 
 const P = COPY.page;
 const roots = new WeakMap();      // host -> { root, sig }
@@ -178,13 +179,84 @@ function profilesSection() {
     icon: 'ellipsis', ariaLabel: P.more(P.profilesRow), attrs: { 'data-fr': 'profiles-more' },
     onClick: () => menu({ anchor: more, ariaLabel: P.more(P.profilesRow), items: [{ label: P.profilesOpen, onSelect: open }] }),
   });
-  return section('profiles', P.profiles, [row({
+  loadSessionReads();
+  const found = sess.profiles && Array.isArray(sess.profiles.profiles) ? sess.profiles.profiles : [];
+  const kids = [row({
     title: P.profilesRow, meta: [P.profilesMeta], onOpen: open, openLabel: P.profilesOpen, trail: [more],
     attrs: { 'data-fr-row': 'profiles' },
-  })], null, 'bot');
+  })];
+  if (sess.formOpen) kids.push(profileForm());
+  if (sess.msg) kids.push(el('p', { class: 'fr-set__note', role: 'status', 'data-fr': 'profiles-msg' }, sess.msg));
+  kids.push(el('p', { class: 'fr-set__note', 'data-fr': 'profiles-found' }, !sess.profiles ? P.profilesReading
+    : sess.profiles.ok === false ? P.profilesUnread(sess.profiles.error)
+      : found.length ? P.profilesFound(found.map((x) => x.id)) : P.profilesNone(sess.profiles.dir)));
+  const add = button({ label: P.profileNew, variant: 'outline', size: 'sm', icon: 'plus', attrs: { 'data-fr': 'profile-new', 'aria-expanded': sess.formOpen ? 'true' : 'false' },
+    onClick: () => { sess.formOpen = !sess.formOpen; sess.msg = ''; setState({}); } });
+  return section('profiles', P.profiles, kids, add, 'bot');
+}
+
+/* ── the Claude profile and launch flags a new session starts with (workspace-launch-flags) ───────────────────────── */
+const sess = { profiles: null, flags: null, asked: false, flagsOpen: false, filter: '', formOpen: false, msg: '' };
+
+/** Both reads once per page load; a created profile asks for the profile read again. */
+function loadSessionReads() {
+  if (FIXTURE) return;
+  if (!sess.asked) {
+    sess.asked = true;
+    pmGet('/api/claude-flags').then((j) => { sess.flags = j || { ok: false, error: 'no answer', flags: [] }; setState({}); });
+  }
+  if (!sess.profiles && !sess.reading) {
+    sess.reading = true;
+    pmGet('/api/profiles').then((j) => { sess.reading = false; sess.profiles = j || { ok: false, error: 'no answer', profiles: [] }; setState({}); });
+  }
+}
+
+let profFormNode = null;
+/** Built once per opening and handed back on every render, so typing is never lost to a rebuild. */
+function profileForm() {
+  if (profFormNode) return profFormNode;
+  const idF = field({ label: P.pfId, placeholder: 'client-acme', attrs: { 'data-fr': 'pf-id' } });
+  const labelF = field({ label: P.pfLabel, placeholder: 'Client Acme', attrs: { 'data-fr': 'pf-label' } });
+  const acctF = field({ label: P.pfAccount, placeholder: 'you@company.com', attrs: { 'data-fr': 'pf-account' } });
+  const mcpF = field({ label: P.pfMcp, placeholder: 'jira confluence slack', attrs: { 'data-fr': 'pf-mcp' } });
+  const envHost = el('div', { class: 'fr-set__envrows', 'data-fr': 'pf-env' });
+  const rows = [];
+  const addEnv = (name) => {
+    const n = field({ label: P.pfEnvName, hideLabel: true, placeholder: 'NAME', value: name || '', attrs: { 'data-fr': 'pf-env-name' } });
+    const v = field({ label: P.pfEnvValue, hideLabel: true, placeholder: P.pfEnvValuePh, attrs: { 'data-fr': 'pf-env-value', type: 'password', autocomplete: 'new-password' } });
+    rows.push({ n, v });
+    envHost.append(el('div', { class: 'fr-set__fields fr-set__fields--grid' }, n, v));
+    return v;
+  };
+  addEnv('CLAUDE_CONFIG_DIR');
+  const err = el('p', { class: 'fr-set__note fr-set__error', role: 'alert', 'data-fr': 'pf-error' });
+  const reset = () => { profFormNode = null; sess.formOpen = false; };
+  const submit = async () => {
+    err.textContent = '';
+    const env = {};
+    for (const r of rows) { const k = r.n.control.value.trim(); if (k) env[k] = r.v.control.value; }
+    const body = { id: idF.control.value.trim(), label: labelF.control.value.trim(), account: acctF.control.value.trim(),
+      mcp: mcpF.control.value.split(/[\s,]+/).filter(Boolean), env };
+    const j = await pmPost('/api/profiles/create', body);
+    if (!j || j.ok === false) { err.textContent = (j && j.error) || P.pfFailed; return; }
+    reset(); sess.profiles = null; sess.msg = P.pfCreated(j.profile.id, j.profile.env_count);
+    setState({});
+  };
+  profFormNode = el('form', { class: 'fr-set__form', 'data-fr': 'profile-form', onSubmit: (e) => { e.preventDefault(); submit(); } },
+    el('div', { class: 'fr-set__fields fr-set__fields--grid' }, idF, labelF, acctF, mcpF),
+    el('p', { class: 'fr-set__note' }, P.pfEnvHead), envHost,
+    el('div', { class: 'fr-set__fields' },
+      button({ label: P.pfAddVar, variant: 'ghost', size: 'sm', icon: 'plus', attrs: { type: 'button', 'data-fr': 'pf-add-var' }, onClick: () => { addEnv('').control.focus(); } }),
+      ...['CLAUDE_CONFIG_DIR', 'ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL'].map((nm) => button({ label: nm, variant: 'ghost', size: 'sm', attrs: { type: 'button' }, onClick: () => { addEnv(nm).control.focus(); } }))),
+    el('p', { class: 'fr-set__note' }, P.pfNote), err,
+    el('div', { class: 'fr-set__fields' },
+      button({ label: P.cancel, variant: 'outline', attrs: { type: 'button' }, onClick: () => { reset(); setState({}); } }),
+      button({ label: P.pfCreate, variant: 'primary', attrs: { type: 'submit', 'data-fr': 'pf-create' } })));
+  return profFormNode;
 }
 
 function sessionsSection() {
+  loadSessionReads();
   const d = sessionDefaults();
   const cli = field({
     label: P.cli, kind: 'select', value: d.cli,
@@ -198,7 +270,32 @@ function sessionsSection() {
     onCommit: (v) => { setSessionDefaults({ tier: v }); setState({}); },
     attrs: { 'data-fr': 'default-model' },
   });
-  return section('sessions', P.sessions, [el('div', { class: 'fr-set__fields fr-set__fields--grid' }, cli, model), el('p', { class: 'fr-set__note' }, P.sessionsNote)], null, 'square-terminal');
+  // Only descriptors the reader accepted are offered; a saved default that no longer reads stays shown, marked, so it is not silently swapped
+  const live = sess.profiles && Array.isArray(sess.profiles.profiles) ? sess.profiles.profiles : [];
+  const stale = d.profile && !live.some((x) => x.id === d.profile);
+  const profile = field({
+    label: P.profileDefault, kind: 'select', value: d.profile || '',
+    options: [{ value: '', label: P.noProfile }, ...(stale ? [{ value: d.profile, label: P.profileMissing(d.profile) }] : []),
+      ...live.map((x) => ({ value: x.id, label: (x.label && x.label !== x.id ? x.label + ' (' + x.id + ')' : x.id) }))],
+    onCommit: (v) => {
+      setSessionDefaults({ profile: v || null });
+      // the form's own per-agent memory follows, so both starts agree; a refusal is shown by the form itself
+      pmPost('/api/profiles/prefer', { agent: 'claude', profile: v || null });
+      setState({});
+    },
+    attrs: { 'data-fr': 'default-profile' },
+  });
+  const flags = d.flags;
+  const flagsBox = el('div', { class: 'fr-set__flags', 'data-fr': 'default-flags' },
+    el('span', { class: 'fr-fp-label' }, P.flagsDefault),
+    el('p', { class: 'fr-set__note', 'data-fr': 'flags-summary' }, flags.length ? 'claude ' + flagsLine(flags) : P.flagsNone),
+    sess.flags && flagsMissingValue(sess.flags, flags).length ? el('p', { class: 'fr-set__note fr-set__error', role: 'alert', 'data-fr': 'flags-missing' }, P.flagsMissing(flagsMissingValue(sess.flags, flags)[0])) : null,
+    flagPicker({ list: sess.flags, chosen: flags, filter: sess.filter, compact: !sess.flagsOpen,
+      onChange: (next) => { setSessionDefaults({ flags: next }); setState({}); },
+      onFilter: (q) => { sess.filter = q; setState({}); } }),
+    button({ label: sess.flagsOpen ? P.flagsHide : P.flagsAll, variant: 'outline', size: 'sm', attrs: { 'data-fr': 'flags-all', 'aria-expanded': sess.flagsOpen ? 'true' : 'false' },
+      onClick: () => { sess.flagsOpen = !sess.flagsOpen; setState({}); } }));
+  return section('sessions', P.sessions, [el('div', { class: 'fr-set__fields fr-set__fields--grid' }, cli, model, profile), flagsBox, el('p', { class: 'fr-set__note' }, P.sessionsNote)], null, 'square-terminal');
 }
 
 function validateSection(scope) {
@@ -341,7 +438,9 @@ async function waitForRestart(from, log) {
  * server, installs the new version, starts it again, and this page reloads on it. A kit update alone changes no page.
  */
 async function updateAll(ws, app, cmp) {
-  const appToo = !!cmp.appBehind && !app.fromCheckout;
+  const cur = kitByWs.get(ws);
+  const local = !!(cur && cur.st && cur.st.source && cur.st.source.kind === 'local');
+  const appToo = !!cmp.appBehind && (!app.fromCheckout || local);
   if (appToo) {
     const yes = await askConfirm({ title: P.updateAppTitle, body: P.updateAppBody(app.version || '?', upd.latest), confirmLabel: P.updateAll });
     if (!yes) return;
@@ -368,9 +467,11 @@ function updatesSection(scope) {
   const cmp = upd.compare || {};
   const kids = [];
   const kitPresent = !!(kit && kit.present);
-  const canUpdate = (cmp.appBehind && !app.fromCheckout) || (cmp.kitBehind && kitPresent);
+  const canUpdate = (cmp.appBehind && (!app.fromCheckout || (st && st.source && st.source.kind === 'local'))) || (cmp.kitBehind && kitPresent);
   kids.push(el('div', { class: 'fr-set__line fr-set__line--box' }, icon('panel-top'), el('span', { 'data-fr': 'app-version' }, P.updatesApp(app.version))));
-  if (cmp.appBehind && app.fromCheckout) kids.push(el('p', { class: 'fr-set__note', 'data-fr': 'app-checkout' }, P.updatesCheckout));
+  const src = st && st.source;
+  if (src && src.kind === 'local') kids.push(el('p', { class: 'fr-set__note' + (src.error ? ' fr-set__error' : ''), 'data-fr': 'update-source' }, src.error ? P.updatesLocalBad(src.error) : P.updatesLocal(src.path)));
+  if (cmp.appBehind && app.fromCheckout && !(src && src.kind === 'local')) kids.push(el('p', { class: 'fr-set__note', 'data-fr': 'app-checkout' }, P.updatesCheckout));
   const kitText = scope === 'all' || !ws ? P.updatesNoRepo : !kit ? '' : kit.present ? P.updatesKit(kit.version) : P.updatesNoKit;
   kids.push(el('div', { class: 'fr-set__line fr-set__line--box' }, icon('cloud'), el('span', { 'data-fr': 'kit-version' }, kitText)));
   if (canUpdate) {
@@ -406,7 +507,7 @@ function signature(scope) {
   let add = '';
   try { add = JSON.stringify(addKeys); } catch { add = String(Date.now()); }
   const kit = ws ? kitByWs.get(ws) : null;
-  return JSON.stringify([repoTuples(), activeProduct(), scope, state.theme, sessionDefaults(), ws, consentByWs.get(ws) || null, peopleByWs.get(ws) || null, addOpen, !!addMod, online.data, online.error, online.note,
+  return JSON.stringify([repoTuples(), activeProduct(), scope, state.theme, sessionDefaults(), sess.profiles, sess.flags, sess.flagsOpen, sess.filter, sess.formOpen, sess.msg, ws, consentByWs.get(ws) || null, peopleByWs.get(ws) || null, addOpen, !!addMod, online.data, online.error, online.note,
     kit ? kit.st : null, upd]) + add;
 }
 

package/workspace/public/pm/dock-sessions.js

@@ -299,7 +299,10 @@ export function openNewSessionSheet(repo, preset) {
     const base = (sk ? (sk.label || sk.skill || sk.id) : (d.cli === 'claude' ? 'Claude' : 'Shell')) + (m.initiative ? ' · ' + m.initiative : '');
     const name = typed || uniqueName(base);
     const common = {
-      name, agent: sk ? 'claude' : d.cli, initiative: m.initiative || null, profile: null,
+      name, agent: sk ? 'claude' : d.cli, initiative: m.initiative || null,
+      // the Settings defaults for a Claude session (workspace-launch-flags); a shell takes neither
+      profile: (sk || d.cli === 'claude') ? d.profile : null,
+      flags: !sk && d.cli === 'claude' && d.flags.length ? d.flags.map((x) => ({ flag: x.flag, ...(x.value ? { value: x.value } : {}) })) : undefined,
       skill: sk ? sk.id : null, workType: sk ? typeOfSkill(sk) : 'general',
       tier: !sk && d.cli === 'claude' && d.tier !== 'auto' ? d.tier : null,
     };

package/workspace/public/pm/dock.js

@@ -33,17 +33,23 @@ const DEFAULTS_KEY = 'pmos.workspace.pm.session-defaults';
 export const CLIS = Object.freeze(['shell', 'claude']);
 export const TIERS = Object.freeze(['auto', 'fast', 'balanced', 'deep']);
 
-/** { cli: 'shell'|'claude', tier: 'auto'|'fast'|'balanced'|'deep' }. An unreadable or unknown value is the default. */
+/* The Claude profile and launch flags a new Claude session starts with (workspace-launch-flags). Stored beside the CLI and
+ * tier. A malformed entry is dropped, never repaired: the server checks every flag again against its own list. */
+const cleanProfile = (v) => (typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(v) ? v : null);
+const cleanFlags = (v) => (Array.isArray(v) ? v.filter((x) => x && typeof x.flag === 'string' && /^-{1,2}[A-Za-z][\w-]*$/.test(x.flag))
+  .map((x) => ({ flag: x.flag, value: typeof x.value === 'string' ? x.value.slice(0, 500) : '' })) : []);
+
+/** { cli: 'shell'|'claude', tier: 'auto'|'fast'|'balanced'|'deep', profile: id|null, flags: [{flag,value}] }. An unreadable or unknown value is the default. */
 export function sessionDefaults() {
   let raw = null;
   if (!FIXTURE) { try { raw = JSON.parse(localStorage.getItem(DEFAULTS_KEY) || 'null'); } catch { raw = null; } }
   const r = raw && typeof raw === 'object' ? raw : {};
-  return { cli: CLIS.includes(r.cli) ? r.cli : 'shell', tier: TIERS.includes(r.tier) ? r.tier : 'auto' };
+  return { cli: CLIS.includes(r.cli) ? r.cli : 'shell', tier: TIERS.includes(r.tier) ? r.tier : 'auto', profile: cleanProfile(r.profile), flags: cleanFlags(r.flags) };
 }
 
 export function setSessionDefaults(patch) {
   const next = { ...sessionDefaults(), ...(patch || {}) };
-  const clean = { cli: CLIS.includes(next.cli) ? next.cli : 'shell', tier: TIERS.includes(next.tier) ? next.tier : 'auto' };
+  const clean = { cli: CLIS.includes(next.cli) ? next.cli : 'shell', tier: TIERS.includes(next.tier) ? next.tier : 'auto', profile: cleanProfile(next.profile), flags: cleanFlags(next.flags) };
   if (!FIXTURE) { try { localStorage.setItem(DEFAULTS_KEY, JSON.stringify(clean)); } catch { /* private mode: the default stands */ } }
   return clean;
 }

package/workspace/public/pm/flag-picker.js

@@ -0,0 +1,104 @@
+/* pm/flag-picker.js — choose launch flags for a Claude session (initiative workspace-launch-flags).
+ *
+ * One picker, two places: Settings (the defaults every new session starts with) and the New session form (this
+ * session only). It draws the list the server serves at /api/claude-flags — every flag `claude --help` names — and
+ * holds NO state of its own: the caller keeps `chosen` ([{flag, value}]) and `filter`, passes them in, and redraws
+ * when `onChange` / `onFilter` fire. Text inputs commit on Enter or blur (the `field` primitive), so a redraw never
+ * lands between keystrokes and takes the caret with it.
+ *
+ * What a flag that takes a value offers, in order:
+ *   choices      `claude --help` states the complete set → a select, nothing else can be sent
+ *   suggestions  common values → chips to pick from, and the field still accepts another
+ *   example      free text, a path or JSON → the placeholder says what shape it is
+ * A flag PMOS answers itself (--model, --worktree …) or one that needs --print is listed, greyed, with the reason, and
+ * cannot be switched on. The server refuses the same flags, so this is a courtesy, not the guard.
+ */
+import { el } from './dom.js';
+import { button, field, badge } from './primitives.js';
+
+/** The flags worth one tap. Not a limit: every offered flag is in the list below them. */
+export const QUICK_FLAGS = Object.freeze(['--chrome', '--continue', '--permission-mode', '--add-dir', '--verbose', '--bare']);
+
+const find = (chosen, f) => (chosen || []).find((x) => x.flag === f);
+
+/** `--chrome --permission-mode=plan`, or '' when nothing is chosen. */
+export function flagsLine(chosen) {
+  return (chosen || []).map((x) => (x.value && String(x.value).trim() ? x.flag + '=' + String(x.value).trim() : x.flag)).join(' ');
+}
+
+/** The flags that need a value and have none yet: [flagName]. The session cannot start with these. */
+export function flagsMissingValue(list, chosen) {
+  const by = new Map(((list && list.flags) || []).map((f) => [f.flag, f]));
+  return (chosen || []).filter((x) => by.get(x.flag) && by.get(x.flag).value === 'required' && !String(x.value || '').trim()).map((x) => x.flag);
+}
+
+/** What goes on the wire: [{flag, value?}], or undefined for none. */
+export function flagsWire(chosen) {
+  const out = (chosen || []).map((x) => ({ flag: x.flag, ...(x.value && String(x.value).trim() ? { value: String(x.value).trim() } : {}) }));
+  return out.length ? out : undefined;
+}
+
+function valueEditor(f, cur, set) {
+  const label = 'Value for ' + f.flag;
+  if (Array.isArray(f.choices) && f.choices.length) {
+    return el('div', { class: 'fr-fp-val' },
+      field({ label, hideLabel: true, kind: 'select', value: cur.value || '', attrs: { 'data-fp-value': f.flag },
+        options: [{ value: '', label: 'Choose a value…' }, ...f.choices.map((c) => ({ value: c, label: c }))], onCommit: (v) => set(v) }),
+      el('span', { class: 'fr-fp-note' }, 'One of ' + f.choices.length + ', as `claude --help` lists them.'));
+  }
+  const sg = Array.isArray(f.suggestions) ? f.suggestions : [];
+  return el('div', { class: 'fr-fp-val' },
+    field({ label, hideLabel: true, value: cur.value || '', placeholder: f.example || f.arg || 'value', attrs: { 'data-fp-value': f.flag }, onCommit: (v) => set(v.trim()) }),
+    sg.length ? el('div', { class: 'fr-fp-chips', role: 'group', 'aria-label': 'Suggested values for ' + f.flag },
+      sg.map((v) => button({ label: v, variant: 'outline', size: 'sm', attrs: { class: 'fr-fp-chip', 'aria-pressed': v === cur.value ? 'true' : 'false', 'data-fp-suggest': f.flag }, onClick: () => set(v) }))) : null,
+    el('span', { class: 'fr-fp-note' }, sg.length ? 'Suggestions. You can type another value.' : 'Free text' + (f.arg ? ' ' + f.arg : '') + '.'));
+}
+
+/**
+ * @param {{list:{ok:boolean,error?:string,flags:object[]}|null, chosen:Array, filter:string, onChange:(next:Array)=>void,
+ *          onFilter:(q:string)=>void, quick?:boolean}} o
+ */
+export function flagPicker({ list, chosen, filter, onChange, onFilter, quick = true, compact = false }) {
+  const root = el('div', { class: 'fr-fp', 'data-fp': 'root' });
+  if (!list) { root.append(el('p', { class: 'fr-fp-note' }, 'Reading the flag list…')); return root; }
+  if (list.ok === false) {
+    root.append(el('p', { class: 'fr-fp-note fp-bad', role: 'alert' }, 'The flag list could not be read — ' + (list.error || 'no reason given') + '. No flag can be added.'));
+    return root;
+  }
+  const all = list.flags || [];
+  const toggle = (f, on) => {
+    const cur = (chosen || []).filter((x) => x.flag !== f.flag);
+    onChange(on ? [...cur, { flag: f.flag, value: '' }] : cur);
+  };
+  const setValue = (f, v) => onChange((chosen || []).map((x) => (x.flag === f.flag ? { ...x, value: v } : x)));
+
+  if (quick) {
+    const qs = QUICK_FLAGS.map((n) => all.find((f) => f.flag === n)).filter((f) => f && f.offered);
+    root.append(el('div', { class: 'fr-fp-chips', role: 'group', 'aria-label': 'Common flags' },
+      qs.map((f) => button({ label: f.flag, variant: 'outline', size: 'sm', attrs: { class: 'fr-fp-chip', 'aria-pressed': find(chosen, f.flag) ? 'true' : 'false', 'data-fp-quick': f.flag }, onClick: () => toggle(f, !find(chosen, f.flag)) }))));
+  }
+  if (compact) {
+    // only what is switched on gets an editor; the full list opens on request
+    for (const f of all.filter((x) => find(chosen, x.flag) && x.value !== 'none')) root.append(el('div', { class: 'fr-fp-row', 'data-fp-row': f.flag }, el('code', { class: 'fr-fp-head' }, f.flag + (f.arg ? ' ' + f.arg : '')), valueEditor(f, find(chosen, f.flag), (v) => setValue(f, v))));
+    return root;
+  }
+  root.append(field({ label: 'Search flags', hideLabel: true, value: filter || '', placeholder: 'Search flags, e.g. chrome, permission, mcp (Enter)', attrs: { 'data-fp-filter': '1' }, onCommit: (v) => onFilter(v) }));
+
+  const q = String(filter || '').trim().toLowerCase();
+  const rows = all.filter((f) => !q || (f.flag + ' ' + (f.aliases || []).join(' ') + ' ' + f.description).toLowerCase().includes(q))
+    // what is switched on comes first, so its value editor is not buried in a list of 64
+    .sort((a, b) => (find(chosen, b.flag) ? 1 : 0) - (find(chosen, a.flag) ? 1 : 0));
+  root.append(el('div', { class: 'fr-fp-list', 'data-fp': 'list' },
+    rows.length ? rows.map((f) => {
+      const cur = find(chosen, f.flag);
+      const box = field({ kind: 'check', label: f.flag + (f.arg ? ' ' + f.arg : ''), value: !!cur, attrs: { 'data-fp-flag': f.flag, ...(f.offered ? {} : { disabled: true }) }, onCommit: (on) => toggle(f, on) });
+      return el('div', { class: 'fr-fp-row' + (f.offered ? '' : ' fr-fp-row--off'), 'data-fp-row': f.flag },
+        el('div', { class: 'fr-fp-head' }, box,
+          (f.aliases || []).length ? el('span', { class: 'fr-fp-note' }, f.aliases.join(' ')) : null,
+          f.caution ? badge({ text: 'Skips safety checks', tone: 'warning' }) : null,
+          f.offered ? null : badge({ text: 'Not offered' })),
+        el('p', { class: 'fr-fp-note' }, f.offered ? f.description : f.why_not),
+        cur && f.value !== 'none' ? valueEditor(f, cur, (v) => setValue(f, v)) : null);
+    }) : el('p', { class: 'fr-fp-note' }, 'No flag matches “' + (filter || '') + '”.')));
+  return root;
+}

package/workspace/public/pm/frame-copy.js

@@ -164,7 +164,26 @@ export const COPY = {
     modelFast: 'Fast',
     modelBalanced: 'Balanced',
     modelDeep: 'Deep',
-    sessionsNote: 'The dock starts new sessions with these defaults. A model applies only to a Claude session.',
+    sessionsNote: 'The dock starts new sessions with these defaults. A model, a profile and launch flags apply only to a Claude session. The New session form can change them for one session.',
+    profileDefault: 'Default Claude profile',
+    noProfile: 'No profile',
+    profileMissing: (id) => id + ' (not found now)',
+    flagsDefault: 'Default launch flags',
+    flagsNone: 'None. Claude starts with its own defaults.',
+    flagsAll: 'All flags…',
+    flagsMissing: (f) => f + ' needs a value, or switch it off. A new session cannot start with it empty.',
+    flagsHide: 'Hide the flag list',
+    profileNew: 'New profile',
+    profilesReading: 'Reading ~/.claude/profiles…',
+    profilesUnread: (e) => 'The profiles could not be read — ' + (e || 'no reason given'),
+    profilesFound: (ids) => 'Found ' + ids.length + ': ' + ids.join(', ') + '.',
+    profilesNone: (dir) => 'No profile in ' + (dir || '~/.claude/profiles') + ' yet.',
+    pfId: 'Id (the file name)', pfLabel: 'Label', pfAccount: 'Account, shown as written and not checked', pfMcp: 'MCP server names, declared only',
+    pfEnvHead: 'Environment variables applied to the session',
+    pfEnvName: 'Variable name', pfEnvValue: 'Value', pfEnvValuePh: 'value (hidden)', pfAddVar: 'Add variable',
+    pfNote: 'The values are written to ~/.claude/profiles/<id>.json on this machine, are never shown again and are never sent to the browser. CLAUDE_CONFIG_DIR gives the profile its own Claude login and settings.',
+    pfCreate: 'Create profile', pfFailed: 'The profile was not created.', cancel: 'Cancel',
+    pfCreated: (id, n) => 'Created ~/.claude/profiles/' + id + '.json with ' + n + ' environment variable' + (n === 1 ? '' : 's') + '.',
     validate: 'Validate consent',
     validateOn: 'Validation is on for this repository.',
     validateOff: 'Validation is off. Nothing from this repository is sent.',
@@ -223,6 +242,8 @@ export const COPY = {
     updatesNever: 'Press Check for updates to compare with the latest published version.',
     updatesLatest: (v) => 'Latest published version: ' + v + '.',
     updatesCurrent: (v) => 'Up to date. The latest published version is ' + v + '.',
+    updatesLocal: (p) => 'Checking against the local package ' + p + ', not npm. Set PMOS_UPDATE_SOURCE to change this.',
+    updatesLocalBad: (e) => e,
     updatesCheckout: 'This workspace runs from a PMOS checkout. Update it with git pull.',
     updatesNote: 'Updating the kit changes only its own files (skills, scripts, templates and guides). Your records in state/, planning/ and okf/product/ do not change.',
     updateKitBusy: 'Updating the kit…',