create-egregore 0.19.8 → 0.19.11

package/lib/local.js

@@ -47,7 +47,12 @@ const TEMPLATE_REPO = "egregore";
 async function getUser(token) {
   const { status, data } = await ghApi("GET", "/user", token);
   if (status !== 200) throw new Error("GitHub auth failed — could not fetch user");
-  return { login: data.login, name: data.name || data.login, email: data.email || null };
+  return {
+    login: data.login,
+    id: data.id || null,
+    name: data.name || data.login,
+    email: data.email || null,
+  };
 }
 
 async function listOrgs(token) {
@@ -1286,11 +1291,14 @@ async function localFounderFlow(ui, ctx = {}) {
   const slugifiedName = (displayName || user.login).toLowerCase().replace(/\s+/g, "-");
   const state = {
     github_username: user.login,
+    github_id: user.id,
+    person_id: user.id ? `github:${user.id}` : `github-login:${user.login.toLowerCase()}`,
     github_name: user.name,
     display_name: displayName || user.login,
     name: slugifiedName,
     member_role: memberRole,
     email: user.email,
+    emails: user.email ? [user.email.toLowerCase()] : [],
     onboarding_complete: false,
     usage_type: "founder_group",
     org_setup: true,
@@ -1430,6 +1438,7 @@ async function localFounderFlow(ui, ctx = {}) {
       const invPersonContent = [
         "---",
         `name: ${invUsername}`,
+        `person_id: github-login:${invUsername.toLowerCase()}`,
         `github: ${invUsername}`,
         `invited_by: ${user.login}`,
         `joined: ${today}`,
@@ -1755,6 +1764,7 @@ async function localJoinFlow(orgArg, ui, ctx = {}) {
     org_name: orgName,
     github_org: orgLogin,
     github_username: user.login,
+    github_id: user.id,
     github_name: user.name,
     github_email: user.email,
     slug: config.slug || orgLogin,

package/lib/setup.js

@@ -174,12 +174,24 @@ function mergeProfileFields(existing, additions = []) {
 function personProfileContent(state = {}, opts = {}) {
   const now = opts.onboardedAt || new Date().toISOString();
   const username = state.github_username || opts.githubUsername || "unknown";
+  const githubId = state.github_id || opts.githubId || "";
+  const personId = state.person_id || (githubId ? `github:${githubId}` : `github-login:${username.toLowerCase()}`);
   const displayName = state.display_name || state.github_name || username;
   const role = state.member_role || state.onboarding?.member_role || opts.memberRole || "Member";
+  const emails = [...new Set(
+    [state.email, ...(Array.isArray(state.emails) ? state.emails : [])]
+      .filter(Boolean)
+      .map((value) => String(value).trim().toLowerCase()),
+  )];
   return [
     `# ${displayName}`,
     "",
+    `Person-ID: ${personId}`,
     `GitHub: ${username}`,
+    `GitHub-ID: ${githubId}`,
+    "GitHub-Aliases: ",
+    `Email: ${emails[0] || ""}`,
+    `Emails: ${emails.join(", ")}`,
     `Role: ${role}`,
     `Joined: ${now.split("T")[0]}`,
     `Onboarded: ${now}`,
@@ -234,6 +246,7 @@ function buildOnboardingState(existing = {}, data = {}, opts = {}) {
   const state = { ...existing };
   const preferredRuntime = normalizeRuntime(opts.runtime);
   const githubUsername = data.github_username || state.github_username || "";
+  const githubId = data.github_id || state.github_id || null;
   const githubName = data.github_name || state.github_name || githubUsername;
   const displayName = data.display_name || state.display_name || githubName || githubUsername;
   const usageType = normalizeUsageType(data);
@@ -248,6 +261,12 @@ function buildOnboardingState(existing = {}, data = {}, opts = {}) {
   const shouldComplete = alreadyComplete || (requestedComplete && !!memberRole);
 
   if (githubUsername) state.github_username = githubUsername;
+  if (githubId) {
+    state.github_id = githubId;
+    state.person_id = `github:${githubId}`;
+  } else if (githubUsername && !state.person_id) {
+    state.person_id = `github-login:${githubUsername.toLowerCase()}`;
+  }
   if (githubName) state.github_name = githubName;
   if (displayName) {
     state.display_name = displayName;
@@ -457,6 +476,20 @@ async function install(data, ui, targetDir, opts = {}) {
     reportPiRuntimeSummary(piRuntime, ui);
   }
 
+  // Reconcile the installer-captured identity through the same portable writer
+  // used by /me and onboarding. Failure is recoverable: the state + person
+  // profile already exist and the next session retries `bin/person.sh sync`.
+  const personScript = path.join(egregoreDir, "bin", "person.sh");
+  if (fs.existsSync(personScript)) {
+    try {
+      spawnSync("bash", [personScript, "onboard"], {
+        cwd: egregoreDir,
+        stdio: "ignore",
+        timeout: 15000,
+      });
+    } catch {}
+  }
+
   // 5. Register instance + install launcher binary
   ui.step(5, totalSteps, "Registering instance...");
   registerInstance(forkDirName, org_name, egregoreDir, preferredRuntime);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.19.8",
+  "version": "0.19.11",
   "description": "Set up Egregore for your team in one command — installs the egregore launcher and your choice of Claude Code, Codex, or Pi.",
   "license": "MIT",
   "bin": {

package/runtime/codex/.codex/hooks/branch-guard.js

@@ -48,22 +48,86 @@ function inside(child, parent) {
   return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel));
 }
 
-function findProjectDir(input) {
-  // Tool payload cwd is the operation location. Codex launchers may keep
-  // EGREGORE_CODEX_PROJECT_DIR pointed at the main checkout even after the
-  // model continues in a task worktree, so using the env var first can make
-  // legitimate worktree writes look like writes on protected develop.
-  const cwd = input.cwd || process.cwd() || process.env.EGREGORE_CODEX_PROJECT_DIR;
-  const top = run("git", ["-C", cwd, "rev-parse", "--show-toplevel"], cwd);
-  if (top) return realish(top);
+function nearestExistingDirectory(candidate) {
+  let cursor = path.resolve(candidate);
+  try {
+    if (fs.existsSync(cursor) && !fs.statSync(cursor).isDirectory()) cursor = path.dirname(cursor);
+  } catch {}
+  while (!fs.existsSync(cursor)) {
+    const parent = path.dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+  return cursor;
+}
+
+function gitContext(candidate) {
+  if (!candidate) return null;
+  const probe = nearestExistingDirectory(candidate);
+  const top = run("git", ["-C", probe, "rev-parse", "--show-toplevel"], probe);
+  if (!top) return null;
+  const commonRaw = run("git", ["-C", top, "rev-parse", "--git-common-dir"], top);
+  const common = commonRaw
+    ? realish(path.isAbsolute(commonRaw) ? commonRaw : path.join(top, commonRaw))
+    : realish(path.join(top, ".git"));
+  return { top: realish(top), common };
+}
+
+function shellRetarget(command) {
+  // Only retarget a single operation. Mixed command chains are evaluated from
+  // the hub context so one external `git -C` cannot mask a later project write.
+  if (shellSegments(command).length !== 1) return "";
+  const gitC = String(command || "").match(/(?:^|[;&|]\s*)git\s+-C\s+("[^"]*"|'[^']*'|[^\s;&|]+)/);
+  const cdAnd = String(command || "").match(/^\s*cd\s+("[^"]*"|'[^']*'|[^\s;&|]+)\s*&&/);
+  const raw = (gitC && gitC[1]) || (cdAnd && cdAnd[1]) || "";
+  const target = raw.replace(/^['"]|['"]$/g, "");
+  return /[$`*?]/.test(target) ? "" : target;
+}
+
+function operationCandidate(input, baseDir) {
+  const toolName = input.tool_name || "";
+  const toolInput = input.tool_input || {};
+  const explicitWorkdir = toolInput.workdir || toolInput.cwd || "";
+  let candidate = explicitWorkdir
+    ? (path.isAbsolute(explicitWorkdir) ? explicitWorkdir : path.join(baseDir, explicitWorkdir))
+    : baseDir;
 
-  const envDir = process.env.EGREGORE_CODEX_PROJECT_DIR || "";
-  if (envDir) {
-    const envTop = run("git", ["-C", envDir, "rev-parse", "--show-toplevel"], envDir);
-    return realish(envTop || envDir);
+  if (toolName === "Edit" || toolName === "Write") {
+    const target = toolInput.file_path || toolInput.path || "";
+    if (target) candidate = path.isAbsolute(target) ? target : path.join(candidate, target);
+  } else if (toolName === "Bash") {
+    const target = shellRetarget(toolInput.command || "");
+    if (target) candidate = path.isAbsolute(target) ? target : path.join(candidate, target);
+  }
+
+  return candidate;
+}
+
+function findProjectContext(input) {
+  // The launcher keeps EGREGORE_CODEX_PROJECT_DIR on the hub checkout while
+  // individual tool calls can target a task worktree, memory, or a managed
+  // repo. Compare Git common dirs: a task worktree shares the hub common dir
+  // and must use its own branch; memory/managed repos are separate and exempt.
+  const fallback = input.cwd || process.cwd();
+  const hubSeed = process.env.EGREGORE_CODEX_PROJECT_DIR || fallback;
+  const hub = gitContext(hubSeed);
+  const baseDir = input.cwd || hub?.top || fallback;
+  const candidate = operationCandidate(input, baseDir);
+  const operation = gitContext(candidate);
+
+  if (!hub) return { projectDir: operation?.top || realish(baseDir), external: false };
+  if (operation && operation.common === hub.common) {
+    return { projectDir: operation.top, external: false };
+  }
+  if (operation && operation.common !== hub.common) {
+    return { projectDir: hub.top, external: true };
   }
 
-  return realish(cwd);
+  const resolvedCandidate = realish(candidate);
+  if (!inside(resolvedCandidate, hub.top)) {
+    return { projectDir: hub.top, external: true };
+  }
+  return { projectDir: hub.top, external: false };
 }
 
 function currentBranch(projectDir) {
@@ -95,7 +159,7 @@ function isExemptPath(rawPath, projectDir, memoryDir) {
     if (inside(resolved, target)) return true;
   }
 
-  for (const file of [".egregore-state.json", ".env"]) {
+  for (const file of [".egregore-state.json", ".egregore-branch-consent", ".env"]) {
     if (resolved === realish(path.join(projectDir, file))) return true;
   }
 
@@ -133,12 +197,13 @@ function commandTargetsOtherRepo(command, projectDir, memoryDir) {
 }
 
 function isBranchSetupCommand(command) {
+  if (shellSegments(command).length !== 1) return false;
   return (
-    /\bbin\/agent\.sh\s+branch\b/.test(command) ||
-    /\bgit\s+(checkout|switch)\s+(-b|-c)\b/.test(command) ||
-    /\bgit\s+branch\s+(dev|feature|bugfix)\//.test(command) ||
-    /\bgit\s+worktree\s+add\b/.test(command) ||
-    /\bbin\/worktree\.sh\s+setup\b/.test(command)
+    /^\s*bin\/agent\.sh\s+branch\b/.test(command) ||
+    /^\s*git\s+(checkout|switch)\s+(-b|-c)\b/.test(command) ||
+    /^\s*git\s+branch\s+(dev|feature|bugfix)\//.test(command) ||
+    /^\s*git\s+worktree\s+add\b/.test(command) ||
+    /^\s*bin\/worktree\.sh\s+setup\b/.test(command)
   );
 }
 
@@ -149,7 +214,134 @@ function stagedOnlyFrameworkPaths(projectDir) {
   return files.length > 0 && files.every((file) => /^(bin\/|\.claude\/|\.codex\/|CLAUDE\.md$|AGENTS\.md$|skills\/)/.test(file));
 }
 
+function stripQuotedSegments(command) {
+  let out = "";
+  let quote = null;
+  for (let i = 0; i < String(command || "").length; i++) {
+    const ch = command[i];
+    if (quote) {
+      if (quote === '"' && ch === "\\") i++;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      out += "x";
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+
+function maskQuotedOperators(command) {
+  let out = "";
+  let quote = null;
+  for (let i = 0; i < String(command || "").length; i++) {
+    const ch = command[i];
+    if (quote) {
+      if (quote === '"' && ch === "\\") {
+        out += ch;
+        if (i + 1 < command.length) out += command[++i];
+        continue;
+      }
+      if (ch === quote) quote = null;
+      out += /[><|;&]/.test(ch) ? " " : ch;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    out += ch;
+  }
+  return out;
+}
+
+function shellSegments(command) {
+  const segments = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < String(command || "").length; i++) {
+    const ch = command[i];
+    if (quote) {
+      current += ch;
+      if (quote === '"' && ch === "\\" && i + 1 < command.length) current += command[++i];
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ";" || ch === "|" || ch === "&" || ch === "\n") {
+      if (current.trim()) segments.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) segments.push(current.trim());
+  return segments;
+}
+
+function shellWords(segment) {
+  const words = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < String(segment || "").length; i++) {
+    const ch = segment[i];
+    if (quote) {
+      if (quote === '"' && ch === "\\" && i + 1 < segment.length) current += segment[++i];
+      else if (ch === quote) quote = null;
+      else current += ch;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current) words.push(current);
+      current = "";
+      continue;
+    }
+    if (ch === "\\") {
+      if (i + 1 < segment.length) current += segment[++i];
+      continue;
+    }
+    current += ch;
+  }
+  if (current) words.push(current);
+  return words;
+}
+
+function filesystemMutationStatus(command, projectDir, memoryDir) {
+  const commands = new Set(["rm", "mv", "cp", "mkdir", "rmdir", "touch", "chmod", "chown", "ln", "tee"]);
+  let unsafe = false;
+
+  for (const segment of shellSegments(command)) {
+    const words = shellWords(segment);
+    while (words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0])) words.shift();
+    while (words[0] === "sudo" || words[0] === "command" || words[0] === "env") words.shift();
+    if (!words.length) continue;
+
+    const name = path.basename(words.shift());
+    if (!commands.has(name)) continue;
+
+    const args = words.filter((word) => !word.startsWith("-"));
+    let targets = args;
+    if (name === "cp" || name === "ln") targets = args.length ? [args[args.length - 1]] : [];
+    if (name === "chmod" || name === "chown") targets = args.slice(1);
+
+    if (!targets.length || targets.some((target) =>
+      /[$`*?{}]/.test(target) || !isExemptPath(target, projectDir, memoryDir)
+    )) unsafe = true;
+  }
+
+  return { unsafe };
+}
+
 function redirectLooksMutating(command, projectDir, memoryDir) {
+  const visible = maskQuotedOperators(command);
   const redirectPatterns = [
     /(?:^|[\s;|&])(?:\d*)>>?\s*([^&\s;|]+)/g,
     /\|\s*tee\s+(?:-a\s+)?([^&\s;|]+)/g,
@@ -157,7 +349,7 @@ function redirectLooksMutating(command, projectDir, memoryDir) {
 
   for (const pattern of redirectPatterns) {
     let match;
-    while ((match = pattern.exec(command))) {
+    while ((match = pattern.exec(visible))) {
       const target = String(match[1] || "").replace(/^["']|["']$/g, "");
       if (!target || target === "/dev/null" || target.startsWith("$")) continue;
       if (!isExemptPath(target, projectDir, memoryDir)) return true;
@@ -168,18 +360,31 @@ function redirectLooksMutating(command, projectDir, memoryDir) {
 
 function shellLooksMutating(command, projectDir, memoryDir) {
   if (!command.trim()) return false;
-  if (isBranchSetupCommand(command)) return false;
+  const visible = stripQuotedSegments(command);
+  if (isBranchSetupCommand(visible)) return false;
 
   const mutatingPatterns = [
-    /\bgit\s+(add|commit|push|rm|mv|reset|restore|checkout\s+--|clean|rebase|merge|cherry-pick)\b/,
-    /\b(apply_patch|touch|mkdir|rm|mv|cp|chmod|chown|ln)\b/,
-    /\b(sed|perl)\b[^;&|]*\s-i(\s|$)/,
-    /\b(npm|pnpm|yarn|bun)\s+(install|add|remove|update|dedupe|ci)\b/,
-    /\b(go\s+mod\s+tidy|cargo\s+(fmt|fix|update)|rustfmt|prettier\s+--write|eslint\s+--fix)\b/,
+    /(?:^|[;&|(\n]\s*)(?:sudo\s+)?git(?:\s+-C\s+\S+)?\s+(add|commit|push|rm|mv|reset|restore|checkout\s+--|clean|rebase|merge|cherry-pick)\b/,
+    /(?:^|[;&|(\n]\s*)(?:sudo\s+)?apply_patch\b/,
+    /(?:^|[;&|(\n]\s*)(?:sudo\s+)?(sed|perl)\b[^;&|]*\s-i(\s|$)/,
+    /(?:^|[;&|(\n]\s*)(?:sudo\s+)?(npm|pnpm|yarn|bun)\s+(install|add|remove|update|dedupe|ci)\b/,
+    /(?:^|[;&|(\n]\s*)(?:sudo\s+)?(go\s+mod\s+tidy|cargo\s+(fmt|fix|update)|rustfmt|prettier\s+--write|eslint\s+--fix)\b/,
   ];
 
-  if (/\bgit\s+commit\b/.test(command) && stagedOnlyFrameworkPaths(projectDir)) return false;
-  return mutatingPatterns.some((pattern) => pattern.test(command)) || redirectLooksMutating(command, projectDir, memoryDir);
+  const gitCommit = /(?:^|[;&|(\n]\s*)(?:sudo\s+)?git(?:\s+-C\s+\S+)?\s+commit\b/.test(visible);
+  if (gitCommit && stagedOnlyFrameworkPaths(projectDir)) return false;
+
+  const filesystem = filesystemMutationStatus(command, projectDir, memoryDir);
+  return mutatingPatterns.some((pattern) => pattern.test(visible)) ||
+    filesystem.unsafe ||
+    redirectLooksMutating(command, projectDir, memoryDir);
+}
+
+function isConsentCommand(command, branch) {
+  const escaped = branch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(
+    `^\\s*echo\\s+['"]?${escaped}['"]?\\s*>\\s*(?:\\./)?\\.egregore-branch-consent\\s*$`
+  ).test(String(command || ""));
 }
 
 function deny(reason) {
@@ -194,7 +399,9 @@ function deny(reason) {
 
 function main() {
   const input = parseJson(readStdin());
-  const projectDir = findProjectDir(input);
+  const context = findProjectContext(input);
+  if (context.external) return;
+  const projectDir = context.projectDir;
   const branch = currentBranch(projectDir);
   if (!isProtectedBranch(branch)) return;
 
@@ -211,11 +418,11 @@ function main() {
   const memoryDir = realish(path.join(projectDir, "memory"));
   const author = currentAuthor(projectDir);
   const reason = [
-    `Protected branch (${branch}). Ask the user how to proceed — do NOT auto-branch silently.`,
-    "Offer a choice (numbered or structured): Branch off (default) / Proceed on this branch / Cancel.",
-    `  • Branch off:        bin/agent.sh branch --topic "<work topic>"  (prefix dev/${author}/...)`,
-    `  • Proceed on ${branch}: echo '${branch}' > .egregore-branch-consent  then retry`,
-    "Proceeding records consent for this branch for the rest of the session (cleared on next session start).",
+    `Protected branch (${branch}). Move project work to a task branch before writing.`,
+    `If the work topic is clear, run bin/agent.sh branch --topic "<work topic>" automatically (prefix dev/${author}/...), continue in the printed worktree, and briefly tell the user.`,
+    "Ask only when the work topic is genuinely ambiguous; ask for the topic, not for routine Git permission.",
+    `Only when the user explicitly requested writing on ${branch}, record consent with: echo '${branch}' > .egregore-branch-consent`,
+    "Memory, framework-runtime, and managed-repo writes are exempt and should not trigger this guard.",
   ].join("\n");
 
   if (toolName === "apply_patch") {
@@ -234,6 +441,7 @@ function main() {
 
   if (toolName === "Bash") {
     const command = String(toolInput.command || "");
+    if (isConsentCommand(command, branch)) return;
     if (commandTargetsOtherRepo(command, projectDir, memoryDir)) return;
     if (shellLooksMutating(command, projectDir, memoryDir)) deny(reason);
   }

package/runtime/codex/.codex/skills/activity/SKILL.md

@@ -15,15 +15,27 @@ remain enough to render a useful answer.
 
 1. Verify `bin/agent.sh` exists. If it does not, say this is not an Egregore
    checkout.
-2. Run `bin/agent.sh sync`.
-3. Resolve the requested handle:
+2. If the request is `activity done N`, `activity expire N`, or
+   `activity reopen N`, fetch `bin/activity-data.sh` to a temporary JSON file,
+   map `N` to the corresponding `handoffs_to_me[N-1].sessionId`, and run:
+
+```bash
+bash bin/activity-action.sh <done|expire|reopen> "<session-id>"
+```
+
+Report the resulting topic and state. Never accept a raw session ID from the
+visible command when a numbered activity item is available; the number keeps
+the mutation tied to what the user just saw. In local mode, preserve the
+script's explicit unavailable result.
+3. Run `bin/agent.sh sync`.
+4. Resolve the requested handle:
    - If the user named a person, match it against `memory/people/*.md`.
    - Otherwise use `.egregore-state.json` `github_username`, then git user
      fallback.
-4. Run `bash bin/activity-data.sh [handle]` with network escalation and capture
+5. Run `bash bin/activity-data.sh [handle]` with network escalation and capture
    stdout as JSON. This command performs the graph API call internally; a
    normal sandboxed Codex shell can make a healthy graph look unreachable.
-5. Classify the graph status:
+6. Classify the graph status:
 
 ```bash
 node bin/codex-skill-render.mjs classify-graph --mode connected
@@ -37,7 +49,7 @@ say Codex graph network access was not granted; do not claim the graph itself
 was unreachable. Do not retry for `missing_config`, `auth_error`, or
 `server_error`; render the clear reason instead.
 
-6. Render the card with:
+7. Render the card with:
 
 ```bash
 node bin/codex-skill-render.mjs activity-card <json-file>
@@ -47,7 +59,7 @@ Paste the rendered card exactly in the visible response, preferably in a
 `text` fenced block. Do not paraphrase the card into bullets unless the user
 asks for a summary.
 
-7. Offer one compact focus prompt:
+8. Offer one compact focus prompt:
    - `Handoffs` - open pending handoffs.
    - `Questions` - answer or inspect pending questions.
    - `Recent work` - inspect sessions and wraps.