@lazyingart/agintiflow 0.20.89 → 0.20.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.89",
+  "version": "0.20.91",
   "type": "module",
   "description": "Low-cost, project-aware Web and CLI agents with DeepSeek/Venice/OpenAI routing, visible tool calls, durable sessions, scouts, AAPS, SCS, and guarded local execution.",
   "license": "Apache-2.0",

package/scripts/smoke-coding-tools.js

@@ -288,6 +288,18 @@ try {
   );
   assert(readonlyTestEchoPolicy.allowed, "read-only test/echo probe sequence should not require package-install-policy=allow");
   assert(readonlyTestEchoPolicy.category === "read-only", "read-only test/echo probe sequence should be classified as read-only");
+  const pdflatexCompilePolicy = evaluateCommandPolicy(
+    'cd profile-latex-20260506 && pdflatex -interaction=nonstopmode -halt-on-error main.tex 2>&1; echo "PDFLATEX_EXIT:$?"',
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(pdflatexCompilePolicy.allowed, "workspace-local pdflatex compile should be allowed without package installs");
+  assert(pdflatexCompilePolicy.category === "toolchain", "workspace-local pdflatex compile should be classified as toolchain");
+  const latexmkCompilePolicy = evaluateCommandPolicy(
+    'cd profile-latex-20260506 && latexmk -pdf main.tex 2>&1; echo "LATEXMK_EXIT:$?"',
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(latexmkCompilePolicy.allowed, "workspace-local latexmk compile should be allowed without package installs");
+  assert(latexmkCompilePolicy.category === "toolchain", "workspace-local latexmk compile should be classified as toolchain");
   const curlPolicy = evaluateCommandPolicy("curl -s -o /dev/null -w '%{http_code}' https://github.com/lazyingart/AgInTiFlow.git", dockerWorkspacePolicy);
   assert(curlPolicy.allowed, "curl URL probe with flags should be allowed in docker-workspace allow mode");
   assert(curlPolicy.needsNetwork, "curl URL probe with flags was not classified as network");
@@ -318,6 +330,18 @@ try {
   assert(cdWorkspacePolicy.allowed, "cd /workspace should be allowed in docker-workspace mode");
   const gitCleanDryRunPolicy = evaluateCommandPolicy("git clean -nd reports", dockerWorkspacePolicy);
   assert(gitCleanDryRunPolicy.allowed, "git clean dry-run should be allowed as read-only inspection evidence");
+  const localGitInitPolicy = evaluateCommandPolicy("git init", dockerWorkspaceNoInstallsPolicy);
+  assert(localGitInitPolicy.allowed, "local git init should be allowed without package installs");
+  assert(localGitInitPolicy.category === "git-workflow", "local git init should be classified as git-workflow");
+  const localGitCommitPolicy = evaluateCommandPolicy('git commit -m "Initial local workflow commit"', dockerWorkspaceNoInstallsPolicy);
+  assert(localGitCommitPolicy.allowed, "local git commit should be allowed without package installs");
+  assert(localGitCommitPolicy.category === "git-workflow", "local git commit should be classified as git-workflow");
+  const localGitSwitchPolicy = evaluateCommandPolicy("git switch -c feature-a", dockerWorkspaceNoInstallsPolicy);
+  assert(localGitSwitchPolicy.allowed, "local git switch -c should be allowed without package installs");
+  const localGitMergePolicy = evaluateCommandPolicy("git merge --ff-only feature-a", dockerWorkspaceNoInstallsPolicy);
+  assert(localGitMergePolicy.allowed, "local git fast-forward merge should be allowed without package installs");
+  const unsafeRebasePolicy = evaluateCommandPolicy("git rebase main", dockerWorkspaceNoInstallsPolicy);
+  assert(!unsafeRebasePolicy.allowed, "git rebase should still require stronger permission because it rewrites history");
   const unsafeCloneTarget = evaluateCommandPolicy("git clone https://github.com/lazyingart/AgInTiFlow.git ../AgInTiFlow", dockerWorkspacePolicy);
   assert(!unsafeCloneTarget.allowed, "git clone outside the workspace should be blocked");
   const blockedClonePolicy = evaluateCommandPolicy("git clone https://github.com/lazyingart/AgInTiFlow.git", {
@@ -750,6 +774,10 @@ try {
           "command_policy_readonly_probe_sequence_no_installs",
           "command_policy_readonly_version_pipeline_no_installs",
           "command_policy_readonly_test_echo_no_installs",
+          "command_policy_pdflatex_compile_no_installs",
+          "command_policy_latexmk_compile_no_installs",
+          "command_policy_local_git_workflow_no_installs",
+          "command_policy_git_rebase_still_guarded",
           "command_policy_git_clone_network",
           "command_policy_safe_chmod_sequence",
           "command_policy_cd_workspace",

package/skills/github-maintenance/SKILL.md

@@ -20,4 +20,6 @@ tools:
 
 Always inspect `git status --short` and relevant diffs before committing or pushing. Keep commits scoped and stop on conflicts, divergence, or unrelated dirty work.
 
+For local workflow practice or repository setup, prefer a disposable subdirectory if the user did not clearly target the current repository. Configure only local git identity (`git config user.name`, `git config user.email`) inside that repo; never change global git config. Use accurate git scenarios: a fast-forward merge means the target branch has not diverged; a non-fast-forward merge intentionally creates a merge commit after both branches diverge; a rebase rewrites local branch commits and should be used only in an explicitly disposable/local branch or after user approval.
+
 Use `gh` for PR/release/status workflows when authenticated. Fold long command output but preserve key errors, URLs, branch names, and commit hashes.

package/src/command-policy.js

@@ -71,8 +71,19 @@ const NETWORK_FETCH_PATTERNS = [
 ];
 
 const GIT_WORKFLOW_PATTERNS = [
+  /^git\s+init(?:\s+(?:\.|[-\w./]+))?$/,
+  /^git\s+config(?:\s+--local)?\s+user\.(?:name|email)\s+(['"])[^'"\n]{1,160}\1$/,
+  /^git\s+config(?:\s+--local)?\s+init\.defaultBranch\s+(?:main|master|trunk|develop)$/,
   /^git\s+add(?:\s+[-\w./*]+)+$/,
-  /^git\s+commit\s+(?:-a\s+)?-m\s+(['"])[^'"\n]{1,220}\1$/,
+  /^git\s+add\s+-A$/,
+  /^git\s+commit\s+(?:(?:-a|--allow-empty)\s+)*-m\s+(['"])[^'"\n]{1,220}\1$/,
+  /^git\s+branch\s+-M\s+[A-Za-z0-9][-\w./]*$/,
+  /^git\s+branch\s+[A-Za-z0-9][-\w./]*$/,
+  /^git\s+switch\s+(?:-c\s+)?[A-Za-z0-9][-\w./]*$/,
+  /^git\s+checkout\s+-b\s+[A-Za-z0-9][-\w./]*$/,
+  /^git\s+merge\s+--ff-only\s+[A-Za-z0-9][-\w./]*$/,
+  /^git\s+merge\s+--no-ff\s+--no-edit\s+[A-Za-z0-9][-\w./]*$/,
+  /^git\s+merge\s+[A-Za-z0-9][-\w./]*\s+--no-ff\s+--no-edit$/,
   /^git\s+fetch(?:\s+[-\w./:=]+)*$/,
   /^git\s+pull\s+--ff-only(?:\s+[-\w./:=]+)*$/,
   /^git\s+push(?:\s+[-\w./:=]+)*$/,
@@ -264,8 +275,23 @@ function classifyGitClone(normalized) {
   };
 }
 
+function classifyGitWorkflow(normalized) {
+  if (!matchAny(GIT_WORKFLOW_PATTERNS, normalized)) return null;
+  const remote = /^git\s+(fetch|pull|push)\b/.test(normalized);
+  const writesWorkspace = !/^git\s+fetch\b/.test(normalized);
+  return {
+    category: remote ? "git-remote" : "git-workflow",
+    needsNetwork: remote,
+    writesWorkspace,
+    reason:
+      remote
+        ? "Git remote workflow command. Agent should inspect status/diff first and stop on divergence or conflicts."
+        : "Local git workflow command. Agent should inspect status/diff first and stop on conflicts or unrelated dirty work.",
+  };
+}
+
 function classifySimpleCommand(normalized) {
-  const readOnlyCommand = stripBenignRedirections(normalized);
+  const benignRedirectCommand = stripBenignRedirections(normalized);
   if (ALWAYS_BLOCKED_PATTERNS.some((pattern) => pattern.test(normalized))) {
     return { category: "blocked", reason: "Command is blocked because it may expose secrets or publish packages." };
   }
@@ -274,6 +300,8 @@ function classifySimpleCommand(normalized) {
   }
   const gitCleanDryRun = classifyGitCleanDryRun(normalized);
   if (gitCleanDryRun) return gitCleanDryRun;
+  const gitWorkflowClassification = classifyGitWorkflow(normalized);
+  if (gitWorkflowClassification) return gitWorkflowClassification;
   if (matchAny(UNSAFE_GIT_PATTERNS, normalized)) {
     return {
       category: "destructive",
@@ -305,20 +333,10 @@ function classifySimpleCommand(normalized) {
       reason: `Command changes workspace file mode: ${normalized}`,
     };
   }
-  if (matchAny(GIT_WORKFLOW_PATTERNS, normalized)) {
-    const remote = /^git\s+(fetch|pull|push)\b/.test(normalized);
-    const writesWorkspace = /^git\s+(add|commit|pull)\b/.test(normalized);
-    return {
-      category: remote ? "git-remote" : "git-workflow",
-      needsNetwork: remote,
-      writesWorkspace,
-      reason: "Git workflow command. Agent should run git status/diff first and stop on conflicts or divergence.",
-    };
-  }
   const gitCloneClassification = classifyGitClone(normalized);
   if (gitCloneClassification) return gitCloneClassification;
 
-  const unquoted = stripQuotedSegments(readOnlyCommand);
+  const unquoted = stripQuotedSegments(benignRedirectCommand);
   const lowered = ` ${unquoted.toLowerCase()} `;
   if (BLOCKED_WRITE_TOKENS.some((part) => lowered.includes(part))) {
     return {
@@ -337,25 +355,25 @@ function classifySimpleCommand(normalized) {
     };
   }
 
-  if (matchAny(READ_ONLY_PATTERNS, readOnlyCommand) || isReadOnlyFindCommand(normalized)) {
+  if (matchAny(READ_ONLY_PATTERNS, benignRedirectCommand) || isReadOnlyFindCommand(normalized)) {
     return { category: "read-only", needsNetwork: false, writesWorkspace: false };
   }
-  if (matchAny(TEST_PATTERNS, normalized)) {
+  if (matchAny(TEST_PATTERNS, benignRedirectCommand)) {
     return { category: "test", needsNetwork: false, writesWorkspace: false };
   }
-  if (matchAny(TOOLCHAIN_PATTERNS, normalized)) {
+  if (matchAny(TOOLCHAIN_PATTERNS, benignRedirectCommand)) {
     return { category: "toolchain", needsNetwork: false, writesWorkspace: true };
   }
-  if (matchAny(NETWORK_FETCH_PATTERNS, normalized)) {
-    return { category: "network-fetch", needsNetwork: true, writesWorkspace: /(\s-o\s|\s-O\s)/.test(normalized) };
+  if (matchAny(NETWORK_FETCH_PATTERNS, benignRedirectCommand)) {
+    return { category: "network-fetch", needsNetwork: true, writesWorkspace: /(\s-o\s|\s-O\s)/.test(benignRedirectCommand) };
   }
-  if (matchAny(SYSTEM_PACKAGE_INSTALL_PATTERNS, normalized)) {
+  if (matchAny(SYSTEM_PACKAGE_INSTALL_PATTERNS, benignRedirectCommand)) {
     return { category: "system-package-install", needsNetwork: true, writesWorkspace: false, requiresDockerRoot: true };
   }
-  if (matchAny(PACKAGE_INSTALL_PATTERNS, normalized)) {
+  if (matchAny(PACKAGE_INSTALL_PATTERNS, benignRedirectCommand)) {
     return { category: "package-install", needsNetwork: true, writesWorkspace: true };
   }
-  if (matchAny(ENV_SETUP_PATTERNS, normalized)) {
+  if (matchAny(ENV_SETUP_PATTERNS, benignRedirectCommand)) {
     return { category: "env-setup", needsNetwork: false, writesWorkspace: true };
   }
 

package/src/task-profiles.js

@@ -255,7 +255,7 @@ export const TASK_PROFILES = {
     id: "github",
     label: "GitHub maintenance",
     prompt:
-      "Bias toward safe git and GitHub maintenance while still fixing code/docs when asked. Always inspect git status and remotes first, separate unrelated changes, run relevant checks before commits, use gh when available for PR/issues/releases, prefer fast-forward pulls, and stop on conflicts or ambiguous history.",
+      "Bias toward safe git and GitHub maintenance while still fixing code/docs when asked. Always inspect git status and remotes first, separate unrelated changes, run relevant checks before commits, use gh when available for PR/issues/releases, prefer fast-forward pulls, and stop on conflicts or ambiguous history. For local workflow practice, use a disposable subdirectory, set only local git identity, avoid real remotes unless explicitly requested, and describe fast-forward, non-fast-forward merge, and rebase evidence accurately.",
     tools: ["shell", "files", "web_search", "inspect_project"],
   },
   word: {