create-pmos 0.96.0 → 0.97.0

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.96.0",
+  "version": "0.97.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.96.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.96.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) {
@@ -410,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.',

package/workspace/public/pm/panel-newsess.js

@@ -34,6 +34,9 @@ import { state, setState, FIXTURE } from './state.js';
 import * as FX from './fixture.js';
 import { openTerm as openTermTab } from './panel-initiatives.js';
 import { startHere } from './panel-trees.js';
+import { sessionDefaults } from './dock.js';
+import { button } from './primitives.js';
+import { flagPicker, flagsLine, flagsMissingValue, flagsWire } from './flag-picker.js';
 
 /* Both are another module's file, loaded lazily for the reason panel-tabs.js gives: a static import
  * of a file that fails to load takes this whole module down with it, and a panel that cannot draw
@@ -124,6 +127,8 @@ export function openNewSession(slug, seed) {
     // Cleared on the way IN as well as on the way out: a form that opened still showing the profile
     // a previous, abandoned question had chosen would be proposing an answer nobody gave.
     preflightProfile: s.profile === undefined ? null : s.profile,
+    // the Settings defaults, for a Claude session (workspace-launch-flags)
+    newSessFlags: (s.agent || 'shell') === 'claude' ? sessionDefaults().flags.map((x) => ({ ...x })) : [], newSessFlagFilter: '',
   });
   refreshReads();
 }
@@ -139,7 +144,7 @@ export function openNewSession(slug, seed) {
  * other half is that `＋ session` no longer reads this at all (panel-tabs.js).
  */
 export function closeNewSession() {
-  setState({ newSess: null, newSessError: null, newSessBusy: false, preflightProfile: null });
+  setState({ newSess: null, newSessError: null, newSessBusy: false, preflightProfile: null, newSessFlags: [], newSessFlagFilter: '' });
 }
 
 export const isNewSessionOpen = () => !!state.newSess;
@@ -174,14 +179,18 @@ function refreshReads() {
   if (typeof dataMod.loadBranches === 'function') {
     dataMod.loadBranches(ws).then((r) => setState({ newSessBranches: r || null })).catch(() => {});
   }
+  if (typeof dataMod.loadClaudeFlags === 'function') {
+    dataMod.loadClaudeFlags().then((r) => setState({ claudeFlags: r || null })).catch(() => {});
+  }
   if (typeof dataMod.loadProfiles === 'function') {
     dataMod.loadProfiles().then((r) => {
       setState({ profiles: r || null });
       // Preselect from the server's remembered preference — never from a hardcoded name. A
       // preference naming a descriptor that no longer reads preselects NOTHING rather than
       // substituting another, which is the same rule the server applies to the preference itself.
-      const pref = r && r.prefs ? r.prefs[state.newSessAgent] : null;
       const live = (r && Array.isArray(r.profiles) ? r.profiles : []).map((p) => p && p.id);
+      const own = state.newSessAgent === 'claude' ? sessionDefaults().profile : null;
+      const pref = own && live.includes(own) ? own : (r && r.prefs ? r.prefs[state.newSessAgent] : null);
       if (pref && live.includes(pref) && !state.preflightProfile) setState({ preflightProfile: pref });
     }).catch(() => {});
   }
@@ -377,6 +386,59 @@ function modelSection() {
         : 'a ' + cur + ' tier — the model and effort it maps to are in your models policy')));
 }
 
+/* ── agent change ──────────────────────────────────────────────────────────────────────────────
+ * The remembered default is per agent, so a different agent preselects its own — but only when the PM has
+ * not chosen something else since the form opened. Launch flags belong to a claude session; leaving
+ * claude clears them rather than carrying them silently to a binary that may not know them. */
+function defaultFor(agent) {
+  const p = state.profiles;
+  const live = (p && Array.isArray(p.profiles) ? p.profiles : []).map((x) => x && x.id);
+  // Settings holds the Claude default; the server's per-agent memory covers every other agent
+  const fromSettings = agent === 'claude' ? sessionDefaults().profile : null;
+  if (fromSettings && live.includes(fromSettings)) return fromSettings;
+  const pref = p && p.prefs ? p.prefs[agent] : null;
+  return pref && live.includes(pref) ? pref : null;
+}
+function pickAgent(a) {
+  const before = state.newSessAgent;
+  const untouched = !state.preflightProfile || state.preflightProfile === defaultFor(before);
+  setState({
+    newSessAgent: a, newSessError: null,
+    ...(untouched ? { preflightProfile: defaultFor(a) } : {}),
+    ...(a !== 'claude' ? { newSessFlags: [] } : (before !== 'claude' && !(state.newSessFlags || []).length ? { newSessFlags: sessionDefaults().flags.map((x) => ({ ...x })) } : {})),
+  });
+}
+
+/** Remember the chosen profile (or “no profile”) as this agent's default for the next form. */
+async function setDefault() {
+  if (!dataMod || typeof dataMod.preferProfile !== 'function') return;
+  const r = await dataMod.preferProfile(state.newSessAgent || 'shell', state.preflightProfile === undefined ? null : state.preflightProfile);
+  if (!r || !r.ok) { setState({ newSessError: (r && r.error) || 'the default could not be saved' }); return; }
+  setState((s) => ({ newSessError: null, profiles: s.profiles ? { ...s.profiles, prefs: r.prefs || {} } : s.profiles }));
+}
+
+/* ── the launch flags ───────────────────────────────────────────────────────────────────────────
+ * Every flag `claude --help` lists, from the server's generated file. A flag PMOS answers itself
+ * (--model, --worktree, --name …) or one that needs --print is shown, greyed, with the reason — never
+ * silently missing and never sendable. A flag that takes a value gets an input once it is switched on. */
+function flagsSection() {
+  if (state.newSessAgent !== 'claude') {
+    return el('div', { 'data-flags': 'note', class: 'fr-fp-sub' }, iv('launch flags: only a Claude session takes flags — a shell, or any other CLI, starts as it is'));
+  }
+  const chosen = state.newSessFlags || [];
+  const r = state.claudeFlags;
+  const missing = r ? flagsMissingValue(r, chosen) : [];
+  return el('div', { class: 'fr-fp-stack', 'data-flags': 'section' },
+    el('div', { class: 'fr-fp-label' }, 'launch flags'),
+    el('div', { class: 'fr-fp-sub', 'data-flags': 'summary' }, iv(chosen.length
+      ? 'will start with: claude ' + flagsLine(chosen)
+      : 'none chosen — claude starts with its own defaults' + (r && r.cli_version ? '. From claude ' + r.cli_version + ' --help.' : ''))),
+    missing.length ? el('div', { class: 'fr-fp-warn', 'data-flags': 'missing' }, iv(missing[0] + ' needs a value before the session can start.')) : null,
+    flagPicker({ list: r, chosen, filter: state.newSessFlagFilter,
+      onChange: (next) => setState({ newSessFlags: next, newSessError: null }),
+      onFilter: (q) => setState({ newSessFlagFilter: q }) }));
+}
+
 /* ── the profile chips ─────────────────────────────────────────────────────────────────────── */
 
 /**
@@ -426,6 +488,21 @@ function profileSection() {
       iv((b.file || '?').replace(/\.json$/, '') + ' — unusable'))),
   ));
 
+  {
+    const agent = state.newSessAgent || 'shell';
+    const def = defaultFor(agent);
+    const chosen = state.preflightProfile || null;
+    out.push(el('div', { class: 'fr-fp-defrow', 'data-profile': 'default' },
+      button({
+        label: chosen === def ? 'default for ' + agent : 'make ' + (chosen || 'no profile') + ' the default for ' + agent,
+        icon: chosen === def ? 'check' : undefined, size: 'sm', onClick: () => setDefault(), disabled: chosen === def,
+        attrs: { 'data-profile-default': 'set' },
+      }),
+      el('span', { class: 'fr-fp-sub' }, iv(def
+        ? 'new ' + agent + ' sessions start with “' + def + '” unless you pick another here'
+        : 'no default is set — new ' + agent + ' sessions start with no profile'))));
+  }
+
   if (p.absent) {
     out.push(el('div', { style: SUB }, iv('no profile directory at ' + (p.dir || '?')
       + ' — nothing was read, so nothing is offered but “no profile”')));
@@ -490,6 +567,9 @@ async function onStart() {
     return;
   }
 
+  const missingVal = state.newSessAgent === 'claude' && state.claudeFlags ? flagsMissingValue(state.claudeFlags, state.newSessFlags) : [];
+  if (missingVal.length) { setState({ newSessError: missingVal[0] + ' needs a value, or switch it off — nothing was started' }); return; }
+
   setState({ newSessBusy: true, newSessError: null });
   const res = await termMod.requestSpawn({
     name,
@@ -503,6 +583,7 @@ async function onStart() {
     isolate: branch ? isolateNow() : null,
     profile: state.preflightProfile === undefined ? null : state.preflightProfile,
     // D75 — only for a Claude session; 'auto' sends nothing and lets the policy route.
+    flags: state.newSessAgent === 'claude' ? flagsWire(state.newSessFlags) : undefined,
     tier: (state.newSessAgent === 'claude' && state.newSessTier && state.newSessTier !== 'auto') ? state.newSessTier : undefined,
   });
 
@@ -584,13 +665,14 @@ export function newSessionBlock() {
       el('div', { style: LABEL }, 'agent'),
       el('div', { style: ROW },
         ['shell', 'claude'].map((a) => el('button', {
-          onClick: () => setState({ newSessAgent: a, newSessError: null }),
+          onClick: () => pickAgent(a),
           style: state.newSessAgent === a ? CHIP_ON : CHIP, hover: HOVER,
         }, iv(a))),
         el('span', { style: SUB }, 'a CLI that is not on PATH is refused by the server, and says so'),
       ),
 
       modelSection(),
+      el('div', { class: 'fr-fp-stack', 'data-r29': 'newsess-flags' }, flagsSection()),
       el('div', { style: 'display:flex;flex-direction:column;gap:8px', 'data-r29': 'newsess-where' }, branchSection()),
       el('div', { style: 'display:flex;flex-direction:column;gap:8px', 'data-r29': 'newsess-profile' }, profileSection()),
 

package/workspace/public/pm/tab-term.js

@@ -252,6 +252,7 @@ export function requestSpawn(opts) {
         ...(o.skill ? { skill: o.skill } : {}),
         ...(o.workType ? { workType: o.workType } : {}),
         ...(o.tier ? { tier: o.tier } : {}),
+        ...(Array.isArray(o.flags) && o.flags.length ? { flags: o.flags } : {}),
       } : {
         t: 'new',
         ...(o.skill ? { skill: o.skill } : {}),
@@ -272,6 +273,8 @@ export function requestSpawn(opts) {
         profile: o.profile === undefined ? null : o.profile,
         // D75 — a tier the PM picked (fast | balanced | deep). Absent = "auto": the server routes by policy, or asks for nothing.
         ...(o.tier ? { tier: o.tier } : {}),
+        // workspace-launch-flags — `[{flag, value?}]`, checked by the server against the generated claude flag list.
+        ...(Array.isArray(o.flags) && o.flags.length ? { flags: o.flags } : {}),
       },
     };
     SOCK.spawnQueue.push(req);