@open-mercato/cli 0.6.7-develop.6695.1.d1b48a09b3 → 0.6.7-develop.6706.1.b3a4c759bb

package/dist/agentic/shared/ai/skills/om-share-this-session/scripts/prepare-share-bundle.mjs

@@ -0,0 +1,486 @@
+#!/usr/bin/env node
+
+import { createHash, randomBytes } from 'node:crypto'
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { TextDecoder } from 'node:util'
+
+const MAX_SESSION_BYTES = 20 * 1024 * 1024
+const MAX_FILE_BYTES = 5 * 1024 * 1024
+const MAX_TOTAL_FILE_BYTES = 20 * 1024 * 1024
+const MAX_PUBLIC_ARTIFACT_BYTES = 25 * 1024 * 1024
+const MAX_ARCHIVE_BYTES = MAX_PUBLIC_ARTIFACT_BYTES
+const MAX_PUBLIC_BUNDLE_BYTES = 30 * 1024 * 1024
+const SHARE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{1,46}[a-z0-9]$/
+const textDecoder = new TextDecoder('utf-8', { fatal: true })
+
+const sensitiveValueKeyPattern = /^(authorization|cookie|set-cookie|password|passwd|pwd|secret|client[_-]?secret|api[_-]?key|access[_-]?token|refresh[_-]?token|private[_-]?key)$/i
+const pseudonymKeyPattern = /^(session[_-]?id|thread[_-]?id|user[_-]?id|account[_-]?id|organization[_-]?id|tenant[_-]?id|git[_-]?branch)$/i
+const pathKeyPattern = /^(cwd|file|filePath|file_path|filename|path)$/i
+const commandKeyPattern = /^(command|cmd|shell)$/i
+const dangerousPathPattern = /(^|\/)(\.env(?:\.[^/]*)?|\.ssh|\.aws|\.gcloud|\.kube|id_(?:rsa|dsa|ecdsa|ed25519)|credentials(?:\.json)?|service-account(?:\.json)?|\.npmrc|\.pypirc)(\/|$)|\.(?:pem|key|p12|pfx|keystore)$/i
+const completeRedactionMarkerPattern = /^«redacted:[a-z0-9-]+(?::[a-f0-9]{12})?»$/
+
+function fail(message) {
+  throw new Error(message)
+}
+
+function parseArguments(argv) {
+  const allowed = new Set(['name', 'session', 'project-root', 'files', 'out', 'redact-list'])
+  const values = new Map()
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index]
+    if (!argument.startsWith('--')) fail('Every argument must use a named --flag.')
+    const key = argument.slice(2)
+    if (!allowed.has(key)) fail(`Unknown argument: --${key}`)
+    if (values.has(key)) fail(`Duplicate argument: --${key}`)
+    const value = argv[index + 1]
+    if (!value || value.startsWith('--')) fail(`Missing value for --${key}.`)
+    values.set(key, value)
+    index += 1
+  }
+
+  for (const required of ['name', 'session', 'project-root', 'files', 'out']) {
+    if (!values.has(required)) fail(`Missing required argument: --${required}.`)
+  }
+  return Object.fromEntries(values)
+}
+
+function sha256(value) {
+  return createHash('sha256').update(value).digest('hex')
+}
+
+function pseudonym(value, label, salt) {
+  const digest = createHash('sha256').update(salt).update('\0').update(value).digest('hex')
+  return `«redacted:${label}:${digest.slice(0, 12)}»`
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function normalizeSlashes(value) {
+  return value.replaceAll('\\', '/')
+}
+
+function isWithin(root, candidate) {
+  const pathFromRoot = relative(root, candidate)
+  return pathFromRoot !== '' && !pathFromRoot.startsWith(`..${sep}`) && pathFromRoot !== '..' && !isAbsolute(pathFromRoot)
+}
+
+function isDangerousPath(value) {
+  const normalized = value.replaceAll('\\', '/')
+  return dangerousPathPattern.test(normalized)
+}
+
+function countReplacement(state, category) {
+  state.redactions[category] += 1
+}
+
+function replaceMatches(value, pattern, replacement, state, category) {
+  return value.replace(pattern, (...match) => {
+    countReplacement(state, category)
+    return typeof replacement === 'function' ? replacement(...match) : replacement
+  })
+}
+
+function shannonEntropy(value) {
+  const frequencies = new Map()
+  for (const character of value) frequencies.set(character, (frequencies.get(character) ?? 0) + 1)
+  let entropy = 0
+  for (const count of frequencies.values()) {
+    const probability = count / value.length
+    entropy -= probability * Math.log2(probability)
+  }
+  return entropy
+}
+
+function redactHighEntropy(value, state) {
+  return value.replace(/[A-Za-z0-9+/_=-]{32,}/g, (candidate) => {
+    if (/^[a-f0-9]+$/i.test(candidate) || /^[0-9a-f]{8}-[0-9a-f-]{27,}$/i.test(candidate)) return candidate
+    if (!/[A-Za-z]/.test(candidate) || !/[0-9]/.test(candidate) || shannonEntropy(candidate) < 4.1) return candidate
+    countReplacement(state, 'secrets')
+    return '«redacted:high-entropy»'
+  })
+}
+
+function sanitizeString(input, key, state) {
+  if (completeRedactionMarkerPattern.test(input)) return input
+  if (sensitiveValueKeyPattern.test(key) && input.length > 0) {
+    countReplacement(state, 'secrets')
+    return '«redacted:secret-value»'
+  }
+  if (pseudonymKeyPattern.test(key) && input.length > 0) {
+    countReplacement(state, 'identifiers')
+    return pseudonym(input, 'identifier', state.pseudonymSalt)
+  }
+  if (commandKeyPattern.test(key) && isDangerousPath(input)) {
+    countReplacement(state, 'dangerous')
+    return '«redacted:dangerous-file-command»'
+  }
+
+  let value = input
+  if (state.projectRootPattern) {
+    value = replaceMatches(value, state.projectRootPattern, '<project-root>', state, 'paths')
+  }
+  if (state.homePattern) {
+    value = replaceMatches(value, state.homePattern, '~', state, 'paths')
+  }
+  value = replaceMatches(value, /(?:\/Users|\/home)\/[^/\s"']+/g, '~', state, 'paths')
+  value = replaceMatches(value, /[A-Za-z]:\\Users\\[^\\\s"']+/g, '~', state, 'paths')
+
+  for (const literal of state.customLiterals) {
+    const pattern = new RegExp(escapeRegExp(literal), 'g')
+    value = replaceMatches(value, pattern, '«redacted:custom-literal»', state, 'custom')
+  }
+
+  value = replaceMatches(
+    value,
+    /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+    '«redacted:private-key»',
+    state,
+    'secrets',
+  )
+  value = replaceMatches(value, /\b(?:github_pat_[A-Za-z0-9_]{20,}|gh[pousr]_[A-Za-z0-9]{20,}|AKIA[0-9A-Z]{16}|ASIA[0-9A-Z]{16}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g, '«redacted:credential»', state, 'secrets')
+  value = replaceMatches(value, /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, '«redacted:jwt»', state, 'secrets')
+  value = replaceMatches(value, /\b(Bearer|Basic)\s+[A-Za-z0-9+/_=.-]{8,}\b/gi, (_match, scheme) => `${scheme} «redacted:authorization»`, state, 'secrets')
+  value = replaceMatches(value, /\b(Authorization\s*:\s*)[^\s,;]+/gi, (_match, prefix) => `${prefix}«redacted:authorization»`, state, 'secrets')
+  value = replaceMatches(value, /([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]+:[^/\s@]+@/gi, (_match, prefix) => `${prefix}«redacted:credential»@`, state, 'secrets')
+  value = replaceMatches(value, /\b((?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret|client[_-]?secret)\s*[:=]\s*)[^\s,;"']+/gi, (_match, prefix) => `${prefix}«redacted:secret»`, state, 'secrets')
+  value = redactHighEntropy(value, state)
+
+  value = replaceMatches(value, /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '«redacted:email»', state, 'pii')
+  value = replaceMatches(value, /\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '«redacted:ip»', state, 'pii')
+  value = replaceMatches(value, /\b(?:[A-F0-9]{1,4}:){2,7}[A-F0-9]{1,4}\b/gi, '«redacted:ip»', state, 'pii')
+  value = replaceMatches(value, /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi, '«redacted:identifier»', state, 'identifiers')
+  value = replaceMatches(value, /\b[0-9a-f]{64,}\b/gi, '«redacted:hex-secret»', state, 'secrets')
+  value = value.replace(/\+?\d[\d ()-]{7,}\d/g, (candidate) => {
+    const digits = candidate.replace(/\D/g, '')
+    if (digits.length < 9 || digits.length > 15) return candidate
+    countReplacement(state, 'pii')
+    return '«redacted:phone»'
+  })
+
+  return value
+}
+
+function sanitizeNode(value, key, state) {
+  if (typeof value === 'string') return sanitizeString(value, key, state)
+  if (Array.isArray(value)) return value.map((item) => sanitizeNode(item, '', state))
+  if (!value || typeof value !== 'object') return value
+
+  for (const [candidateKey, candidateValue] of Object.entries(value)) {
+    if (pathKeyPattern.test(candidateKey) && typeof candidateValue === 'string' && isDangerousPath(candidateValue)) {
+      countReplacement(state, 'dangerous')
+      return { redacted: 'dangerous-file-reference' }
+    }
+  }
+
+  const output = Object.create(null)
+  for (const [childKey, childValue] of Object.entries(value)) {
+    const sanitizedKey = sanitizeString(childKey, 'object-key', state)
+    if (Object.hasOwn(output, sanitizedKey)) fail('Sanitization produced duplicate object keys.')
+    output[sanitizedKey] = sanitizeNode(childValue, childKey, state)
+  }
+  return output
+}
+
+function inferRole(value) {
+  if (!value || typeof value !== 'object') return null
+  for (const candidate of [value.type, value.role, value.message?.role]) {
+    if (candidate === 'user' || candidate === 'assistant') return candidate
+  }
+  return null
+}
+
+function analyzeSession(session) {
+  let entries
+  let collectionName
+  if (Array.isArray(session)) {
+    entries = session
+    collectionName = 'root'
+  } else if (session && typeof session === 'object') {
+    for (const key of ['turns', 'messages', 'events', 'conversation']) {
+      if (Array.isArray(session[key])) {
+        entries = session[key]
+        collectionName = key
+        break
+      }
+    }
+  }
+  if (!entries) fail('Session JSON has no recognizable turn/event collection.')
+
+  const roles = entries.map(inferRole).filter(Boolean)
+  const userTurns = roles.filter((role) => role === 'user').length
+  const assistantTurns = roles.filter((role) => role === 'assistant').length
+  if (userTurns === 0 || assistantTurns === 0) {
+    fail('Session JSON must contain at least one recognizable user turn and one assistant turn.')
+  }
+  return {
+    collection: collectionName,
+    entries: entries.length,
+    recognizedTurns: roles.length,
+    userTurns,
+    assistantTurns,
+    firstRecognizedRole: roles[0],
+    lastRecognizedRole: roles.at(-1),
+  }
+}
+
+function readUtf8File(path, maxBytes, label) {
+  const stat = lstatSync(path)
+  if (!stat.isFile()) fail(`${label} must be a regular file.`)
+  if (stat.isSymbolicLink()) fail(`${label} must not be a symlink.`)
+  if (stat.size > maxBytes) fail(`${label} exceeds the allowed size.`)
+  const buffer = readFileSync(path)
+  if (buffer.includes(0)) fail(`${label} contains binary data.`)
+  try {
+    return { content: textDecoder.decode(buffer), stat }
+  } catch {
+    fail(`${label} is not valid UTF-8 text.`)
+  }
+}
+
+function loadCustomLiterals(path) {
+  if (!path) return []
+  const { content } = readUtf8File(resolve(path), 1024 * 1024, 'Redaction list')
+  const literals = [...new Set(content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean))]
+  for (const literal of literals) {
+    if (literal.length < 4) fail('Every custom redaction literal must contain at least four characters.')
+  }
+  return literals.sort((left, right) => right.length - left.length)
+}
+
+function validateRelativePath(value) {
+  if (value.includes('\0') || isAbsolute(value)) fail('Generated-file paths must be relative and contain no NUL bytes.')
+  const withSlashes = normalizeSlashes(value)
+  if (withSlashes.startsWith('../') || withSlashes.includes('/../')) {
+    fail('Generated-file paths must stay below the project root.')
+  }
+  const normalized = posix.normalize(withSlashes.replace(/^\.\//, ''))
+  if (!normalized || normalized === '.' || normalized.startsWith('../')) fail('Generated-file paths must stay below the project root.')
+  if (isDangerousPath(normalized)) fail(`Dangerous generated-file path rejected: ${normalized}`)
+  if (/@|(?:\/Users|\/home)\//i.test(normalized)) fail(`Potentially identifying generated-file path rejected: ${normalized}`)
+  return normalized
+}
+
+function loadGeneratedFiles(manifestPath, projectRoot, state) {
+  const { content } = readUtf8File(manifestPath, 1024 * 1024, 'Files manifest')
+  const relativePaths = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith('#'))
+  if (relativePaths.length === 0) fail('Files manifest must name at least one generated or modified file.')
+  if (new Set(relativePaths).size !== relativePaths.length) fail('Files manifest contains duplicate paths.')
+  const safePaths = relativePaths.map(validateRelativePath)
+  if (new Set(safePaths).size !== safePaths.length) fail('Files manifest contains paths that resolve to the same normalized path.')
+
+  let totalBytes = 0
+  return safePaths.map((safePath) => {
+    const resolvedPath = resolve(projectRoot, safePath)
+    if (!existsSync(resolvedPath)) fail(`Generated file does not exist: ${safePath}`)
+    const stat = lstatSync(resolvedPath)
+    if (stat.isSymbolicLink()) fail(`Generated file must not be a symlink: ${safePath}`)
+    const realPath = realpathSync(resolvedPath)
+    if (!isWithin(projectRoot, realPath)) fail(`Generated file escapes the project root: ${safePath}`)
+    const { content: sourceContent } = readUtf8File(realPath, MAX_FILE_BYTES, `Generated file ${safePath}`)
+    totalBytes += stat.size
+    if (totalBytes > MAX_TOTAL_FILE_BYTES) fail('Generated files exceed the total allowed size.')
+    const sanitizedContent = sanitizeString(sourceContent, 'file-content', state)
+    return {
+      relativePath: safePath,
+      mode: stat.mode & 0o777,
+      originalBytes: stat.size,
+      sanitizedContent,
+      sanitizedBytes: Buffer.byteLength(sanitizedContent),
+      sha256: sha256(sanitizedContent),
+    }
+  }).sort((left, right) => left.relativePath.localeCompare(right.relativePath))
+}
+
+function createResidualScanState(state) {
+  return {
+    customLiterals: state.customLiterals,
+    projectRootPattern: state.projectRootPattern,
+    homePattern: state.homePattern,
+    pseudonymSalt: state.pseudonymSalt,
+    redactions: { secrets: 0, pii: 0, paths: 0, dangerous: 0, identifiers: 0, custom: 0 },
+  }
+}
+
+function verifyResidualScan(sanitizedSession, files, state) {
+  const scanState = createResidualScanState(state)
+  if (JSON.stringify(sanitizeNode(sanitizedSession, '', scanState)) !== JSON.stringify(sanitizedSession)) {
+    fail('Residual privacy scan found sensitive session content after sanitization.')
+  }
+  for (const file of files) {
+    if (sanitizeString(file.relativePath, 'generated-file-path', scanState) !== file.relativePath) {
+      fail('Residual privacy scan found a sensitive generated-file path after sanitization.')
+    }
+    if (sanitizeString(file.sanitizedContent, 'file-content', scanState) !== file.sanitizedContent) {
+      fail('Residual privacy scan found sensitive generated-file content after sanitization.')
+    }
+  }
+}
+
+function runGit(argumentsList, cwd) {
+  const result = spawnSync('git', argumentsList, { cwd, encoding: 'utf8' })
+  if (result.status !== 0) fail('Git could not create the generated-files ZIP archive.')
+}
+
+function createArchive(files, sourceDirectory, archivePath) {
+  for (const file of files) {
+    const destination = join(sourceDirectory, ...file.relativePath.split('/'))
+    mkdirSync(dirname(destination), { recursive: true })
+    writeFileSync(destination, file.sanitizedContent, 'utf8')
+    chmodSync(destination, file.mode)
+  }
+  runGit(['init', '--quiet'], sourceDirectory)
+  runGit(['add', '--all'], sourceDirectory)
+  runGit(['-c', 'user.name=Session Share', '-c', 'user.email=session-share.invalid', 'commit', '--quiet', '--message', 'session share bundle'], sourceDirectory)
+  runGit(['archive', '--format=zip', `--output=${archivePath}`, 'HEAD'], sourceDirectory)
+  const archive = readFileSync(archivePath)
+  if (archive.length > MAX_ARCHIVE_BYTES) fail('Generated-files ZIP exceeds the allowed size.')
+  return archive
+}
+
+function main() {
+  const args = parseArguments(process.argv.slice(2))
+  if (!SHARE_NAME_PATTERN.test(args.name)) fail('Share name must be a 3–48 character kebab-case slug.')
+
+  const sessionPath = resolve(args.session)
+  const manifestPath = resolve(args.files)
+  const projectRoot = realpathSync(resolve(args['project-root']))
+  const outputPath = resolve(args.out)
+  if (existsSync(outputPath)) fail('Output path already exists; use a new temporary location.')
+
+  const outputParent = dirname(outputPath)
+  mkdirSync(outputParent, { recursive: true })
+  const stagingDirectory = mkdtempSync(join(outputParent, `.${basename(outputPath)}-preparing-`))
+  const bundleDirectory = join(stagingDirectory, 'bundle')
+  const archiveSourceDirectory = join(stagingDirectory, 'archive-source')
+  mkdirSync(bundleDirectory)
+  mkdirSync(archiveSourceDirectory)
+
+  try {
+    const homeDirectory = process.env.HOME ? resolve(process.env.HOME) : null
+    const state = {
+      customLiterals: loadCustomLiterals(args['redact-list']),
+      projectRootPattern: new RegExp(escapeRegExp(projectRoot), 'g'),
+      homePattern: homeDirectory ? new RegExp(escapeRegExp(homeDirectory), 'g') : null,
+      pseudonymSalt: randomBytes(32),
+      redactions: { secrets: 0, pii: 0, paths: 0, dangerous: 0, identifiers: 0, custom: 0 },
+    }
+
+    const { content: sessionSource } = readUtf8File(sessionPath, MAX_SESSION_BYTES, 'Session export')
+    let session
+    try {
+      session = JSON.parse(sessionSource)
+    } catch {
+      fail('Session export is not valid JSON.')
+    }
+    const sessionSummary = analyzeSession(session)
+    const sanitizedSession = sanitizeNode(session, '', state)
+    const sanitizedSessionText = `${JSON.stringify(sanitizedSession, null, 2)}\n`
+    const sessionOutputPath = join(bundleDirectory, 'session.json')
+    writeFileSync(sessionOutputPath, sanitizedSessionText, 'utf8')
+
+    const files = loadGeneratedFiles(manifestPath, projectRoot, state)
+    verifyResidualScan(sanitizedSession, files, state)
+    const archivePath = join(bundleDirectory, 'generated-files.zip')
+    const archive = createArchive(files, archiveSourceDirectory, archivePath)
+
+    const reviewDirectory = join(bundleDirectory, 'review', 'generated-files')
+    mkdirSync(reviewDirectory, { recursive: true })
+    for (const file of files) {
+      const source = join(archiveSourceDirectory, ...file.relativePath.split('/'))
+      const destination = join(reviewDirectory, ...file.relativePath.split('/'))
+      mkdirSync(dirname(destination), { recursive: true })
+      copyFileSync(source, destination)
+      chmodSync(destination, file.mode)
+    }
+
+    const privacyReport = {
+      version: 1,
+      automatedScan: 'pass',
+      semanticReview: 'required',
+      guarantee: 'Automated scanning cannot prove that contextual personal or confidential data is absent.',
+      redactions: state.redactions,
+      rejectedInputClasses: ['dangerous paths', 'symlinks', 'binary or invalid UTF-8 files', 'out-of-root files', 'oversized inputs'],
+    }
+    const privacyReportText = `${JSON.stringify(privacyReport, null, 2)}\n`
+    const privacyReportPath = join(bundleDirectory, 'privacy-report.json')
+    writeFileSync(privacyReportPath, privacyReportText, 'utf8')
+
+    const manifest = {
+      version: 1,
+      shareName: args.name,
+      createdAt: new Date().toISOString(),
+      session: {
+        ...sessionSummary,
+        bytes: Buffer.byteLength(sanitizedSessionText),
+        sha256: sha256(sanitizedSessionText),
+      },
+      generatedFiles: files.map(({ relativePath, mode, originalBytes, sanitizedBytes, sha256: fileHash }) => ({
+        path: relativePath,
+        mode: mode.toString(8).padStart(3, '0'),
+        originalBytes,
+        sanitizedBytes,
+        sha256: fileHash,
+      })),
+      artifacts: {
+        'generated-files.zip': { bytes: archive.length, sha256: sha256(archive) },
+        'privacy-report.json': { bytes: Buffer.byteLength(privacyReportText), sha256: sha256(privacyReportText) },
+      },
+    }
+    const manifestText = `${JSON.stringify(manifest, null, 2)}\n`
+    const publishedArtifactSizes = [
+      Buffer.byteLength(sanitizedSessionText),
+      archive.length,
+      Buffer.byteLength(manifestText),
+      Buffer.byteLength(privacyReportText),
+    ]
+    if (publishedArtifactSizes.some((size) => size > MAX_PUBLIC_ARTIFACT_BYTES)) {
+      fail('A public session-share artifact exceeds the provider size limit.')
+    }
+    if (publishedArtifactSizes.reduce((total, size) => total + size, 0) > MAX_PUBLIC_BUNDLE_BYTES) {
+      fail('Public session-share artifacts exceed the provider total size limit.')
+    }
+    writeFileSync(join(bundleDirectory, 'manifest.json'), manifestText, 'utf8')
+
+    renameSync(bundleDirectory, outputPath)
+    rmSync(stagingDirectory, { recursive: true, force: true })
+    process.stdout.write(`${JSON.stringify({
+      status: 'prepared',
+      entries: sessionSummary.entries,
+      userTurns: sessionSummary.userTurns,
+      assistantTurns: sessionSummary.assistantTurns,
+      generatedFiles: files.length,
+      archiveBytes: archive.length,
+      redactions: state.redactions,
+      semanticReview: 'required',
+    })}\n`)
+  } catch (error) {
+    rmSync(stagingDirectory, { recursive: true, force: true })
+    throw error
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'Unknown bundle-preparation failure.'
+  process.stderr.write(`Session share bundle was not prepared: ${message}\n`)
+  process.exitCode = 1
+}

package/dist/agentic/shared/ai/skills/tiers.json

@@ -156,6 +156,7 @@
         "om-troubleshooter",
         "om-framework-context",
         "om-evolve-harness",
+        "om-share-this-session",
         "om-eject-and-customize"
       ]
     },

package/dist/agentic/shared/ai/trackers/github.md

@@ -1,8 +1,8 @@
 # Tracker provider: GitHub
 
-This file is the GitHub implementation of the tracker operations contract (see `TEMPLATE.md` for the contract itself). Every skill in the collection performs issue/PR state management through **named tracker operations** — `**get-issue**`, `**comment-pr**`, and so on — and this file defines what each operation means for GitHub, using the `gh` CLI.
+This file is the GitHub implementation of the tracker operations contract (see `TEMPLATE.md` for the contract itself). Skills perform issue/PR state management through **named tracker operations** — `**get-issue**`, `**comment-pr**`, and so on — and this file defines what each operation means for GitHub, using the `gh` CLI.
 
-How it is used at runtime: `om-setup-agent-pipeline` copies this file into the repository at `.ai/trackers/github.md`, and the config's `tracker` field selects it. When a skill says "tracker operation **get-pr**", execute the command documented under that operation heading in the repo's copy. The repo's copy is authoritative: teams extend or override any operation by editing it — add flags, swap a command, append repo-specific conventions — and every skill picks the change up on its next run. An operation not covered by an edit keeps its behavior from this file's text as copied.
+At runtime: `om-setup-agent-pipeline` copies this file into the repository at `.ai/trackers/github.md`, and the config's `tracker` field selects it. When a skill says "tracker operation **get-pr**", execute the command documented under that operation heading in the repo's copy. The repo's copy is authoritative: teams extend or override any operation by editing it, and every skill picks the change up on its next run. An operation not covered by an edit keeps its behavior from this file's text as copied.
 
 ## Prerequisites
 
@@ -98,6 +98,84 @@ BASE_BRANCH=$(gh repo view --json defaultBranchRef --jq '.defaultBranchRef.name'
 [ -z "$BASE_BRANCH" ] && BASE_BRANCH="main"
 ```
 
+### Public session-share artifacts
+
+#### publish-session-share
+`{owner}/{repo}`, `{branch}`, `{shareName}`, and a local `{bundleDir}` → atomically publish the four reviewed session-share artifacts on a new public branch and return repository, branch, commit, branch URL, and raw artifact URLs as JSON.
+
+This operation is intentionally strict: the repository must already be public; the branch must be a new slash-free `session-share-…` ref; and the bundle directory must contain regular, non-symlinked `session.json`, `generated-files.zip`, `manifest.json`, and `privacy-report.json` files within the documented size cap. Git blobs, a tree, and a commit are created first; the public ref is created last, so a preparation failure does not expose a partial branch.
+
+```bash
+TARGET_REPO="{owner}/{repo}"
+SHARE_BRANCH="{branch}"
+SHARE_NAME="{shareName}"
+BUNDLE_DIR="{bundleDir}"
+printf '%s' "$TARGET_REPO" | grep -Eq '^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$' || exit 1
+printf '%s' "$SHARE_NAME" | grep -Eq '^[a-z0-9][a-z0-9-]{1,46}[a-z0-9]$' || exit 1
+[ "$SHARE_BRANCH" = "session-share-$SHARE_NAME" ] || exit 1
+[ "$(gh repo view "$TARGET_REPO" --json visibility --jq .visibility)" = "PUBLIC" ] || exit 1
+gh api "repos/${TARGET_REPO}/git/ref/heads/${SHARE_BRANCH}" >/dev/null 2>&1 && exit 1
+
+SESSION_SHARE_TMP=$(mktemp -d)
+trap 'rm -rf "$SESSION_SHARE_TMP"' EXIT HUP INT TERM
+printf '[]\n' > "$SESSION_SHARE_TMP/tree.json"
+TOTAL_BYTES=0
+for ARTIFACT in session.json generated-files.zip manifest.json privacy-report.json; do
+  ARTIFACT_PATH="$BUNDLE_DIR/$ARTIFACT"
+  [ -f "$ARTIFACT_PATH" ] && [ ! -L "$ARTIFACT_PATH" ] || exit 1
+  ARTIFACT_BYTES=$(wc -c < "$ARTIFACT_PATH" | tr -d ' ')
+  TOTAL_BYTES=$((TOTAL_BYTES + ARTIFACT_BYTES))
+  [ "$ARTIFACT_BYTES" -le 26214400 ] && [ "$TOTAL_BYTES" -le 31457280 ] || exit 1
+done
+
+for ARTIFACT in session.json generated-files.zip manifest.json privacy-report.json; do
+  ARTIFACT_PATH="$BUNDLE_DIR/$ARTIFACT"
+  base64 < "$ARTIFACT_PATH" | tr -d '\n' > "$SESSION_SHARE_TMP/content.b64"
+  BLOB_SHA=$(jq -n --rawfile content "$SESSION_SHARE_TMP/content.b64" '{content:$content,encoding:"base64"}' \
+    | gh api -X POST "repos/${TARGET_REPO}/git/blobs" --input - --jq .sha) || exit 1
+  jq --arg path "$ARTIFACT" --arg sha "$BLOB_SHA" \
+    '. + [{path:$path,mode:"100644",type:"blob",sha:$sha}]' \
+    "$SESSION_SHARE_TMP/tree.json" > "$SESSION_SHARE_TMP/tree.next.json" || exit 1
+  mv "$SESSION_SHARE_TMP/tree.next.json" "$SESSION_SHARE_TMP/tree.json"
+done
+
+DEFAULT_BRANCH=$(gh repo view "$TARGET_REPO" --json defaultBranchRef --jq .defaultBranchRef.name) || exit 1
+BASE_COMMIT=$(gh api "repos/${TARGET_REPO}/git/ref/heads/${DEFAULT_BRANCH}" --jq .object.sha) || exit 1
+BASE_TREE=$(gh api "repos/${TARGET_REPO}/git/commits/${BASE_COMMIT}" --jq .tree.sha) || exit 1
+TREE_SHA=$(jq -n --arg base "$BASE_TREE" --slurpfile entries "$SESSION_SHARE_TMP/tree.json" \
+  '{base_tree:$base,tree:$entries[0]}' \
+  | gh api -X POST "repos/${TARGET_REPO}/git/trees" --input - --jq .sha) || exit 1
+COMMIT_SHA=$(jq -n --arg message "session share ${SHARE_NAME}" --arg tree "$TREE_SHA" --arg parent "$BASE_COMMIT" \
+  '{message:$message,tree:$tree,parents:[$parent]}' \
+  | gh api -X POST "repos/${TARGET_REPO}/git/commits" --input - --jq .sha) || exit 1
+jq -n --arg ref "refs/heads/${SHARE_BRANCH}" --arg sha "$COMMIT_SHA" '{ref:$ref,sha:$sha}' \
+  | gh api -X POST "repos/${TARGET_REPO}/git/refs" --input - >/dev/null || exit 1
+
+jq -n \
+  --arg repository "$TARGET_REPO" \
+  --arg branch "$SHARE_BRANCH" \
+  --arg commit "$COMMIT_SHA" \
+  --arg branchUrl "https://github.com/${TARGET_REPO}/tree/${SHARE_BRANCH}" \
+  --arg sessionUrl "https://raw.githubusercontent.com/${TARGET_REPO}/${SHARE_BRANCH}/session.json" \
+  --arg archiveUrl "https://raw.githubusercontent.com/${TARGET_REPO}/${SHARE_BRANCH}/generated-files.zip" \
+  --arg manifestUrl "https://raw.githubusercontent.com/${TARGET_REPO}/${SHARE_BRANCH}/manifest.json" \
+  --arg privacyUrl "https://raw.githubusercontent.com/${TARGET_REPO}/${SHARE_BRANCH}/privacy-report.json" \
+  '{repository:$repository,branch:$branch,commit:$commit,branchUrl:$branchUrl,artifacts:{session:$sessionUrl,archive:$archiveUrl,manifest:$manifestUrl,privacy:$privacyUrl}}'
+```
+
+#### delete-session-share
+`{owner}/{repo}`, `{branch}`, and `{shareName}` → remove only the exact derived session-share ref after a failed issue creation or an explicit retention cleanup request. Deleting a public ref cannot guarantee erasure from clones, forks, caches, logs, or archives.
+
+```bash
+TARGET_REPO="{owner}/{repo}"
+SHARE_BRANCH="{branch}"
+SHARE_NAME="{shareName}"
+printf '%s' "$TARGET_REPO" | grep -Eq '^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$' || exit 1
+printf '%s' "$SHARE_NAME" | grep -Eq '^[a-z0-9][a-z0-9-]{1,46}[a-z0-9]$' || exit 1
+[ "$SHARE_BRANCH" = "session-share-$SHARE_NAME" ] || exit 1
+gh api -X DELETE "repos/${TARGET_REPO}/git/refs/heads/${SHARE_BRANCH}"
+```
+
 ### Issues
 
 #### get-issue
@@ -109,7 +187,9 @@ gh issue view {issueId} --repo {owner}/{repo} --json number,title,body,state,aut
 #### search-issues
 Query (text, `in:title,body`, state) → matching issues.
 ```bash
-gh issue list --repo {owner}/{repo} --state open --search "<query> in:title,body" --json number,title,url
+ISSUE_STATE="{state}"
+case "$ISSUE_STATE" in open|closed|all) ;; *) exit 1 ;; esac
+gh issue list --repo {owner}/{repo} --state "$ISSUE_STATE" --search "<query> in:title,body" --json number,title,url
 ```
 
 #### create-issue
@@ -130,6 +210,12 @@ gh issue close {issueId} --repo {owner}/{repo} --reason completed --comment "<co
 gh issue comment {issueId} --repo {owner}/{repo} --body "<body>"
 ```
 
+#### update-issue
+`{issueId}`, new title and/or body (use a body-file for multi-line bodies). Edits the issue's own fields; does not touch labels or assignees (those have their own operations).
+```bash
+gh issue edit {issueId} --repo {owner}/{repo} --title "<title>" --body-file <file>
+```
+
 #### assign-issue / unassign-issue
 ```bash
 gh issue edit {issueId} --repo {owner}/{repo} --add-assignee "<login>"
@@ -151,6 +237,12 @@ gh api repos/{owner}/{repo}/issues/comments/{commentId} --jq '{body,user:.user.l
 gh api repos/{owner}/{repo}/issues/{number}/comments --jq '.[] | {id,user:.user.login,body}'
 ```
 
+#### update-comment
+`{commentId}`, new body → rewrite an existing conversation comment in place (works for issue and PR conversation comments alike). This is how marker-idempotent comments (label rationale, verification, claim take-overs) are updated on re-runs: find your `🤖 …` marker via **list-issue-comments**, then update that comment instead of posting a new one. Use a body file so multi-line bodies survive.
+```bash
+gh api -X PATCH repos/{owner}/{repo}/issues/comments/{commentId} -F body=@<path>
+```
+
 ### Pull requests
 
 #### get-pr
@@ -181,6 +273,17 @@ PR_URL=$(gh pr view --json url --jq .url)
 PR_NUMBER=$(gh pr view --json number --jq .number)
 ```
 
+#### update-pr
+`{prNumber}`, new title and/or new body → the PR's own title/body rewritten in place (not a comment), e.g. reframing a doc-originated spec PR that grew a feature implementation. Pass whichever of `--title` / `--body-file` changed; omit the other. Use a body file so multi-line bodies survive.
+```bash
+gh pr edit {prNumber} --title "<title>"
+gh pr edit {prNumber} --body-file <path-or-process-substitution>
+```
+If `gh pr edit` silently no-ops in this repo (some GitHub setups do), fall back to the REST API:
+```bash
+gh api -X PATCH repos/{owner}/{repo}/pulls/{prNumber} -f title="<title>" -f body="$(cat <path>)"
+```
+
 #### comment-pr
 `{prNumber}`, body. For long structured comments:
 ```bash

package/dist/agentic/shared/scripts/run-agent-harness-release.mjs

@@ -47,7 +47,7 @@ Usage:
 Options:
   --root <absolute-app>          Controller/generated app root (default: current directory)
   --runner <codex|claude>        Required primary runner for every blocking live lane
-  --portability-runner <runner> Optional different runner for the 45-case read-only portability lane
+  --portability-runner <runner> Optional different runner for the 46-case read-only portability lane
   --prepare-targets <absolute>   Clone this fresh scaffold once per writable case under an empty/new directory
   --writable-targets <absolute> JSON map of every writable case to a fresh disposable app
   --case-timeout <ms>           Per-model invocation timeout floor (default: 120000; a writable case may raise it)